diff --git a/test/tools/ossfuzz/CMakeLists.txt b/test/tools/ossfuzz/CMakeLists.txt index a799bd736..e87782073 100644 --- a/test/tools/ossfuzz/CMakeLists.txt +++ b/test/tools/ossfuzz/CMakeLists.txt @@ -1,3 +1,5 @@ +link_directories(/usr/local/lib) +add_subdirectory(antlr4-runtime) add_custom_target(ossfuzz) add_dependencies(ossfuzz solc_opt_ossfuzz @@ -27,8 +29,13 @@ if (OSSFUZZ) target_link_libraries(solc_opt_ossfuzz PRIVATE libsolc evmasm) set_target_properties(solc_opt_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE}) - add_executable(solc_noopt_ossfuzz solc_noopt_ossfuzz.cpp ../fuzzer_common.cpp ../../TestCaseReader.cpp) - target_link_libraries(solc_noopt_ossfuzz PRIVATE libsolc evmasm) + add_executable(solc_noopt_ossfuzz + solc_noopt_ossfuzz.cpp + ../fuzzer_common.cpp + ../../TestCaseReader.cpp + libFuzzerMutator.cpp + ) + target_link_libraries(solc_noopt_ossfuzz PRIVATE libsolc evmasm antlr4mutator antlr4-runtime) set_target_properties(solc_noopt_ossfuzz PROPERTIES LINK_FLAGS ${LIB_FUZZING_ENGINE}) add_executable(const_opt_ossfuzz const_opt_ossfuzz.cpp ../fuzzer_common.cpp) diff --git a/test/tools/ossfuzz/antlr4-runtime/CMakeLists.txt b/test/tools/ossfuzz/antlr4-runtime/CMakeLists.txt new file mode 100644 index 000000000..14ec14510 --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/CMakeLists.txt @@ -0,0 +1,15 @@ +set(sources + SolidityBaseVisitor.h + SolidityVisitor.h + SolidityMutator.cpp + SolidityMutator.h + SolidityParser.cpp + SolidityParser.h + SolidityLexer.cpp + SolidityLexer.h + ) +add_library(antlr4mutator ${sources}) +target_include_directories(antlr4mutator PUBLIC + "${CMAKE_SOURCE_DIR}" + /usr/local/include/antlr4-runtime +) \ No newline at end of file diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityBaseVisitor.h b/test/tools/ossfuzz/antlr4-runtime/SolidityBaseVisitor.h new file mode 100644 index 000000000..4aae29440 --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityBaseVisitor.h @@ -0,0 +1,447 @@ + +// Generated from Solidity.g4 by ANTLR 4.8 + +#pragma once + + +#include "antlr4-runtime.h" +#include + +/** + * This class provides an empty implementation of SolidityVisitor, which can be + * extended to create a visitor which only needs to handle a subset of the available methods. + */ +class SolidityBaseVisitor : public SolidityVisitor { +public: + + virtual antlrcpp::Any visitSourceUnit(SolidityParser::SourceUnitContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitPragmaDirective(SolidityParser::PragmaDirectiveContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitImportDirective(SolidityParser::ImportDirectiveContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitImportAliases(SolidityParser::ImportAliasesContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitPath(SolidityParser::PathContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitSymbolAliases(SolidityParser::SymbolAliasesContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitContractDefinition(SolidityParser::ContractDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitInterfaceDefinition(SolidityParser::InterfaceDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitLibraryDefinition(SolidityParser::LibraryDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitInheritanceSpecifierList(SolidityParser::InheritanceSpecifierListContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitInheritanceSpecifier(SolidityParser::InheritanceSpecifierContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitContractBodyElement(SolidityParser::ContractBodyElementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNamedArgument(SolidityParser::NamedArgumentContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitCallArgumentList(SolidityParser::CallArgumentListContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUserDefinedTypeName(SolidityParser::UserDefinedTypeNameContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitModifierInvocation(SolidityParser::ModifierInvocationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVisibility(SolidityParser::VisibilityContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitParameterList(SolidityParser::ParameterListContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitParameterDeclaration(SolidityParser::ParameterDeclarationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConstructorDefinition(SolidityParser::ConstructorDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStateMutability(SolidityParser::StateMutabilityContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitOverrideSpecifier(SolidityParser::OverrideSpecifierContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFunctionDefinition(SolidityParser::FunctionDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitModifierDefinition(SolidityParser::ModifierDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFallbackReceiveFunctionDefinition(SolidityParser::FallbackReceiveFunctionDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStructDefinition(SolidityParser::StructDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStructMember(SolidityParser::StructMemberContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitEnumDefinition(SolidityParser::EnumDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStateVariableDeclaration(SolidityParser::StateVariableDeclarationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitEventParameter(SolidityParser::EventParameterContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitEventDefinition(SolidityParser::EventDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUsingDirective(SolidityParser::UsingDirectiveContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitTypeName(SolidityParser::TypeNameContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitElementaryTypeName(SolidityParser::ElementaryTypeNameContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFunctionTypeName(SolidityParser::FunctionTypeNameContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVariableDeclaration(SolidityParser::VariableDeclarationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitDataLocation(SolidityParser::DataLocationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnaryPrefixOperation(SolidityParser::UnaryPrefixOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitPrimaryExpression(SolidityParser::PrimaryExpressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitOrderComparison(SolidityParser::OrderComparisonContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitConditional(SolidityParser::ConditionalContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitPayableConversion(SolidityParser::PayableConversionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAssignment(SolidityParser::AssignmentContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnarySuffixOperation(SolidityParser::UnarySuffixOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitShiftOperation(SolidityParser::ShiftOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBitAndOperation(SolidityParser::BitAndOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFunctionCall(SolidityParser::FunctionCallContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitIndexRangeAccess(SolidityParser::IndexRangeAccessContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNewExpression(SolidityParser::NewExpressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitIndexAccess(SolidityParser::IndexAccessContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAddSubOperation(SolidityParser::AddSubOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBitOrOperation(SolidityParser::BitOrOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitExpOperation(SolidityParser::ExpOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAndOperation(SolidityParser::AndOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitInlineArray(SolidityParser::InlineArrayContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitOrOperation(SolidityParser::OrOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitMemberAccess(SolidityParser::MemberAccessContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitMulDivModOperation(SolidityParser::MulDivModOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitFunctionCallOptions(SolidityParser::FunctionCallOptionsContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBitXorOperation(SolidityParser::BitXorOperationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitTuple(SolidityParser::TupleContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitEqualityComparison(SolidityParser::EqualityComparisonContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitMetaType(SolidityParser::MetaTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAssignOp(SolidityParser::AssignOpContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitTupleExpression(SolidityParser::TupleExpressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitInlineArrayExpression(SolidityParser::InlineArrayExpressionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitIdentifier(SolidityParser::IdentifierContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitLiteral(SolidityParser::LiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBooleanLiteral(SolidityParser::boolLiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStringLiteral(SolidityParser::StringLiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitHexStringLiteral(SolidityParser::HexStringLiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitUnicodeStringLiteral(SolidityParser::UnicodeStringLiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitNumberLiteral(SolidityParser::NumberLiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBlock(SolidityParser::BlockContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitStatement(SolidityParser::StatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitSimpleStatement(SolidityParser::SimpleStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitIfStatement(SolidityParser::IfStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitForStatement(SolidityParser::ForStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitWhileStatement(SolidityParser::WhileStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitDoWhileStatement(SolidityParser::DoWhileStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitContinueStatement(SolidityParser::ContinueStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitBreakStatement(SolidityParser::BreakStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitTryStatement(SolidityParser::TryStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitCatchClause(SolidityParser::CatchClauseContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitReturnStatement(SolidityParser::ReturnStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitEmitStatement(SolidityParser::EmitStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitAssemblyStatement(SolidityParser::AssemblyStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVariableDeclarationList(SolidityParser::VariableDeclarationListContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVariableDeclarationTuple(SolidityParser::VariableDeclarationTupleContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitVariableDeclarationStatement(SolidityParser::VariableDeclarationStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitExpressionStatement(SolidityParser::ExpressionStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitMappingType(SolidityParser::MappingTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitMappingKeyType(SolidityParser::MappingKeyTypeContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulStatement(SolidityParser::YulStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulBlock(SolidityParser::YulBlockContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulVariableDeclaration(SolidityParser::YulVariableDeclarationContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulAssignment(SolidityParser::YulAssignmentContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulIfStatement(SolidityParser::YulIfStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulForStatement(SolidityParser::YulForStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulSwitchCase(SolidityParser::YulSwitchCaseContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulSwitchStatement(SolidityParser::YulSwitchStatementContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulFunctionDefinition(SolidityParser::YulFunctionDefinitionContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulPath(SolidityParser::YulPathContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulFunctionCall(SolidityParser::YulFunctionCallContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulBoolean(SolidityParser::YulboolContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulLiteral(SolidityParser::YulLiteralContext *ctx) override { + return visitChildren(ctx); + } + + virtual antlrcpp::Any visitYulExpression(SolidityParser::YulExpressionContext *ctx) override { + return visitChildren(ctx); + } + + +}; + diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityLexer.cpp b/test/tools/ossfuzz/antlr4-runtime/SolidityLexer.cpp new file mode 100644 index 000000000..ef275dacb --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityLexer.cpp @@ -0,0 +1,2192 @@ + +// Generated from docs/grammar/SolidityLexer.g4 by ANTLR 4.8 + + +#include + + +using namespace antlr4; + + +SolidityLexer::SolidityLexer(CharStream *input) : Lexer(input) { + _interpreter = new atn::LexerATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +SolidityLexer::~SolidityLexer() { + delete _interpreter; +} + +std::string SolidityLexer::getGrammarFileName() const { + return "SolidityLexer.g4"; +} + +const std::vector& SolidityLexer::getRuleNames() const { + return _ruleNames; +} + +const std::vector& SolidityLexer::getChannelNames() const { + return _channelNames; +} + +const std::vector& SolidityLexer::getModeNames() const { + return _modeNames; +} + +const std::vector& SolidityLexer::getTokenNames() const { + return _tokenNames; +} + +dfa::Vocabulary& SolidityLexer::getVocabulary() const { + return _vocabulary; +} + +const std::vector SolidityLexer::getSerializedATN() const { + return _serializedATN; +} + +const atn::ATN& SolidityLexer::getATN() const { + return _atn; +} + + + + +// Static vars and initialization. +std::vector SolidityLexer::_decisionToDFA; +atn::PredictionContextCache SolidityLexer::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN SolidityLexer::_atn; +std::vector SolidityLexer::_serializedATN; + +std::vector SolidityLexer::_ruleNames = { + u8"ReservedKeywords", u8"Pragma", u8"Abstract", u8"Anonymous", u8"Address", + u8"As", u8"Assembly", u8"Bool", u8"Break", u8"Bytes", u8"Calldata", u8"Catch", + u8"Constant", u8"Constructor", u8"Continue", u8"Contract", u8"Delete", + u8"Do", u8"Else", u8"Emit", u8"Enum", u8"Event", u8"External", u8"Fallback", + u8"False", u8"Fixed", u8"From", u8"FixedBytes", u8"For", u8"Function", + u8"Hex", u8"If", u8"Immutable", u8"Import", u8"Indexed", u8"Interface", + u8"Internal", u8"Is", u8"Library", u8"Mapping", u8"Memory", u8"Modifier", + u8"New", u8"NumberUnit", u8"Override", u8"Payable", u8"Private", u8"Public", + u8"Pure", u8"Receive", u8"Return", u8"Returns", u8"SignedIntegerType", + u8"Storage", u8"String", u8"Struct", u8"True", u8"Try", u8"Type", u8"Ufixed", + u8"UnsignedIntegerType", u8"Using", u8"View", u8"Virtual", u8"While", + u8"LParen", u8"RParen", u8"LBrack", u8"RBrack", u8"LBrace", u8"RBrace", + u8"Colon", u8"Semicolon", u8"Period", u8"Conditional", u8"Arrow", u8"Assign", + u8"AssignBitOr", u8"AssignBitXor", u8"AssignBitAnd", u8"AssignShl", u8"AssignSar", + u8"AssignShr", u8"AssignAdd", u8"AssignSub", u8"AssignMul", u8"AssignDiv", + u8"AssignMod", u8"Comma", u8"Or", u8"And", u8"BitOr", u8"BitXor", u8"BitAnd", + u8"Shl", u8"Sar", u8"Shr", u8"Add", u8"Sub", u8"Mul", u8"Div", u8"Mod", + u8"Exp", u8"Equal", u8"NotEqual", u8"LessThan", u8"GreaterThan", u8"LessThanOrEqual", + u8"GreaterThanOrEqual", u8"Not", u8"BitNot", u8"Inc", u8"Dec", u8"StringLiteral", + u8"NonEmptyStringLiteral", u8"DoubleQuotedStringCharacter", u8"SingleQuotedStringCharacter", + u8"SingleQuotedPrintable", u8"DoubleQuotedPrintable", u8"EscapeSequence", + u8"UnicodeStringLiteral", u8"DoubleQuotedUnicodeStringCharacter", u8"SingleQuotedUnicodeStringCharacter", + u8"HexString", u8"HexNumber", u8"HexDigits", u8"EvenHexDigits", u8"HexCharacter", + u8"DecimalNumber", u8"DecimalDigits", u8"Identifier", u8"IdentifierStart", + u8"IdentifierPart", u8"WS", u8"COMMENT", u8"LINE_COMMENT", u8"AssemblyDialect", + u8"AssemblyLBrace", u8"AssemblyBlockWS", u8"AssemblyBlockCOMMENT", u8"AssemblyBlockLINE_COMMENT", + u8"YulBreak", u8"YulCase", u8"YulContinue", u8"YulDefault", u8"YulFalse", + u8"YulFor", u8"YulFunction", u8"YulIf", u8"YulLeave", u8"YulLet", u8"YulSwitch", + u8"YulTrue", u8"YulEVMBuiltin", u8"YulLBrace", u8"YulRBrace", u8"YulLParen", + u8"YulRParen", u8"YulAssign", u8"YulPeriod", u8"YulComma", u8"YulArrow", + u8"YulIdentifier", u8"YulIdentifierStart", u8"YulIdentifierPart", u8"YulHexNumber", + u8"YulDecimalNumber", u8"YulStringLiteral", u8"YulWS", u8"YulCOMMENT", + u8"YulLINE_COMMENT", u8"PragmaToken", u8"PragmaSemicolon", u8"PragmaWS", + u8"PragmaCOMMENT", u8"PragmaLINE_COMMENT" +}; + +std::vector SolidityLexer::_channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" +}; + +std::vector SolidityLexer::_modeNames = { + u8"DEFAULT_MODE", u8"AssemblyBlockMode", u8"YulMode", u8"PragmaMode" +}; + +std::vector SolidityLexer::_literalNames = { + "", "", u8"'pragma'", u8"'abstract'", u8"'anonymous'", u8"'address'", + u8"'as'", u8"'assembly'", u8"'bool'", "", u8"'bytes'", u8"'calldata'", + u8"'catch'", u8"'constant'", u8"'constructor'", "", u8"'contract'", u8"'delete'", + u8"'do'", u8"'else'", u8"'emit'", u8"'enum'", u8"'event'", u8"'external'", + u8"'fallback'", "", "", u8"'from'", "", "", "", u8"'hex'", "", u8"'immutable'", + u8"'import'", u8"'indexed'", u8"'interface'", u8"'internal'", u8"'is'", + u8"'library'", u8"'mapping'", u8"'memory'", u8"'modifier'", u8"'new'", + "", u8"'override'", u8"'payable'", u8"'private'", u8"'public'", u8"'pure'", + u8"'receive'", u8"'return'", u8"'returns'", "", u8"'storage'", u8"'string'", + u8"'struct'", "", u8"'try'", u8"'type'", "", "", u8"'using'", u8"'view'", + u8"'virtual'", u8"'while'", "", "", u8"'['", u8"']'", "", "", u8"':'", + "", "", u8"'?'", u8"'=>'", u8"'='", u8"'|='", u8"'^='", u8"'&='", u8"'<<='", + u8"'>>='", u8"'>>>='", u8"'+='", u8"'-='", u8"'*='", u8"'/='", u8"'%='", + "", u8"'||'", u8"'&&'", u8"'|'", u8"'^'", u8"'&'", u8"'<<'", u8"'>>'", + u8"'>>>'", u8"'+'", u8"'-'", u8"'*'", u8"'/'", u8"'%'", u8"'**'", u8"'=='", + u8"'!='", u8"'<'", u8"'>'", u8"'<='", u8"'>='", u8"'!'", u8"'~'", u8"'++'", + u8"'--'", "", "", "", "", "", "", "", "", "", "", u8"'\"evmasm\"'", "", + "", "", "", "", u8"'case'", "", u8"'default'", "", "", "", "", u8"'leave'", + u8"'let'", u8"'switch'", "", "", "", "", "", "", u8"':='" +}; + +std::vector SolidityLexer::_symbolicNames = { + "", u8"ReservedKeywords", u8"Pragma", u8"Abstract", u8"Anonymous", u8"Address", + u8"As", u8"Assembly", u8"Bool", u8"Break", u8"Bytes", u8"Calldata", u8"Catch", + u8"Constant", u8"Constructor", u8"Continue", u8"Contract", u8"Delete", + u8"Do", u8"Else", u8"Emit", u8"Enum", u8"Event", u8"External", u8"Fallback", + u8"False", u8"Fixed", u8"From", u8"FixedBytes", u8"For", u8"Function", + u8"Hex", u8"If", u8"Immutable", u8"Import", u8"Indexed", u8"Interface", + u8"Internal", u8"Is", u8"Library", u8"Mapping", u8"Memory", u8"Modifier", + u8"New", u8"NumberUnit", u8"Override", u8"Payable", u8"Private", u8"Public", + u8"Pure", u8"Receive", u8"Return", u8"Returns", u8"SignedIntegerType", + u8"Storage", u8"String", u8"Struct", u8"True", u8"Try", u8"Type", u8"Ufixed", + u8"UnsignedIntegerType", u8"Using", u8"View", u8"Virtual", u8"While", + u8"LParen", u8"RParen", u8"LBrack", u8"RBrack", u8"LBrace", u8"RBrace", + u8"Colon", u8"Semicolon", u8"Period", u8"Conditional", u8"Arrow", u8"Assign", + u8"AssignBitOr", u8"AssignBitXor", u8"AssignBitAnd", u8"AssignShl", u8"AssignSar", + u8"AssignShr", u8"AssignAdd", u8"AssignSub", u8"AssignMul", u8"AssignDiv", + u8"AssignMod", u8"Comma", u8"Or", u8"And", u8"BitOr", u8"BitXor", u8"BitAnd", + u8"Shl", u8"Sar", u8"Shr", u8"Add", u8"Sub", u8"Mul", u8"Div", u8"Mod", + u8"Exp", u8"Equal", u8"NotEqual", u8"LessThan", u8"GreaterThan", u8"LessThanOrEqual", + u8"GreaterThanOrEqual", u8"Not", u8"BitNot", u8"Inc", u8"Dec", u8"StringLiteral", + u8"NonEmptyStringLiteral", u8"UnicodeStringLiteral", u8"HexString", u8"HexNumber", + u8"DecimalNumber", u8"Identifier", u8"WS", u8"COMMENT", u8"LINE_COMMENT", + u8"AssemblyDialect", u8"AssemblyLBrace", u8"AssemblyBlockWS", u8"AssemblyBlockCOMMENT", + u8"AssemblyBlockLINE_COMMENT", u8"YulBreak", u8"YulCase", u8"YulContinue", + u8"YulDefault", u8"YulFalse", u8"YulFor", u8"YulFunction", u8"YulIf", + u8"YulLeave", u8"YulLet", u8"YulSwitch", u8"YulTrue", u8"YulEVMBuiltin", + u8"YulLBrace", u8"YulRBrace", u8"YulLParen", u8"YulRParen", u8"YulAssign", + u8"YulPeriod", u8"YulComma", u8"YulArrow", u8"YulIdentifier", u8"YulHexNumber", + u8"YulDecimalNumber", u8"YulStringLiteral", u8"YulWS", u8"YulCOMMENT", + u8"YulLINE_COMMENT", u8"PragmaToken", u8"PragmaSemicolon", u8"PragmaWS", + u8"PragmaCOMMENT", u8"PragmaLINE_COMMENT" +}; + +dfa::Vocabulary SolidityLexer::_vocabulary(_literalNames, _symbolicNames); + +std::vector SolidityLexer::_tokenNames; + +SolidityLexer::Initializer::Initializer() { + // This code could be in a static initializer lambda, but VS doesn't allow access to private class members from there. + for (size_t i = 0; i < _symbolicNames.size(); ++i) { + std::string name = _vocabulary.getLiteralName(i); + if (name.empty()) { + name = _vocabulary.getSymbolicName(i); + } + + if (name.empty()) { + _tokenNames.push_back(""); + } else { + _tokenNames.push_back(name); + } + } + + static uint16_t serializedATNSegment0[] = { + 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, + 0x2, 0xa3, 0xaa7, 0x8, 0x1, 0x8, 0x1, 0x8, 0x1, 0x8, 0x1, 0x4, 0x2, + 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 0x4, 0x4, 0x5, 0x9, + 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 0x4, 0x8, 0x9, 0x8, + 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 0xb, 0x4, + 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, 0x4, 0xf, + 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, 0x12, + 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, + 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, + 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, + 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, + 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, + 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, + 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, + 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, + 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 0x2c, 0x9, 0x2c, 0x4, 0x2d, + 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, 0x9, 0x2f, 0x4, 0x30, + 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9, 0x32, 0x4, 0x33, + 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35, 0x4, 0x36, + 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4, 0x39, + 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c, + 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, + 0x9, 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, + 0x9, 0x42, 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, + 0x9, 0x45, 0x4, 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, + 0x9, 0x48, 0x4, 0x49, 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, + 0x9, 0x4b, 0x4, 0x4c, 0x9, 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, + 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f, 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, + 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4, 0x53, 0x9, 0x53, 0x4, 0x54, + 0x9, 0x54, 0x4, 0x55, 0x9, 0x55, 0x4, 0x56, 0x9, 0x56, 0x4, 0x57, + 0x9, 0x57, 0x4, 0x58, 0x9, 0x58, 0x4, 0x59, 0x9, 0x59, 0x4, 0x5a, + 0x9, 0x5a, 0x4, 0x5b, 0x9, 0x5b, 0x4, 0x5c, 0x9, 0x5c, 0x4, 0x5d, + 0x9, 0x5d, 0x4, 0x5e, 0x9, 0x5e, 0x4, 0x5f, 0x9, 0x5f, 0x4, 0x60, + 0x9, 0x60, 0x4, 0x61, 0x9, 0x61, 0x4, 0x62, 0x9, 0x62, 0x4, 0x63, + 0x9, 0x63, 0x4, 0x64, 0x9, 0x64, 0x4, 0x65, 0x9, 0x65, 0x4, 0x66, + 0x9, 0x66, 0x4, 0x67, 0x9, 0x67, 0x4, 0x68, 0x9, 0x68, 0x4, 0x69, + 0x9, 0x69, 0x4, 0x6a, 0x9, 0x6a, 0x4, 0x6b, 0x9, 0x6b, 0x4, 0x6c, + 0x9, 0x6c, 0x4, 0x6d, 0x9, 0x6d, 0x4, 0x6e, 0x9, 0x6e, 0x4, 0x6f, + 0x9, 0x6f, 0x4, 0x70, 0x9, 0x70, 0x4, 0x71, 0x9, 0x71, 0x4, 0x72, + 0x9, 0x72, 0x4, 0x73, 0x9, 0x73, 0x4, 0x74, 0x9, 0x74, 0x4, 0x75, + 0x9, 0x75, 0x4, 0x76, 0x9, 0x76, 0x4, 0x77, 0x9, 0x77, 0x4, 0x78, + 0x9, 0x78, 0x4, 0x79, 0x9, 0x79, 0x4, 0x7a, 0x9, 0x7a, 0x4, 0x7b, + 0x9, 0x7b, 0x4, 0x7c, 0x9, 0x7c, 0x4, 0x7d, 0x9, 0x7d, 0x4, 0x7e, + 0x9, 0x7e, 0x4, 0x7f, 0x9, 0x7f, 0x4, 0x80, 0x9, 0x80, 0x4, 0x81, + 0x9, 0x81, 0x4, 0x82, 0x9, 0x82, 0x4, 0x83, 0x9, 0x83, 0x4, 0x84, + 0x9, 0x84, 0x4, 0x85, 0x9, 0x85, 0x4, 0x86, 0x9, 0x86, 0x4, 0x87, + 0x9, 0x87, 0x4, 0x88, 0x9, 0x88, 0x4, 0x89, 0x9, 0x89, 0x4, 0x8a, + 0x9, 0x8a, 0x4, 0x8b, 0x9, 0x8b, 0x4, 0x8c, 0x9, 0x8c, 0x4, 0x8d, + 0x9, 0x8d, 0x4, 0x8e, 0x9, 0x8e, 0x4, 0x8f, 0x9, 0x8f, 0x4, 0x90, + 0x9, 0x90, 0x4, 0x91, 0x9, 0x91, 0x4, 0x92, 0x9, 0x92, 0x4, 0x93, + 0x9, 0x93, 0x4, 0x94, 0x9, 0x94, 0x4, 0x95, 0x9, 0x95, 0x4, 0x96, + 0x9, 0x96, 0x4, 0x97, 0x9, 0x97, 0x4, 0x98, 0x9, 0x98, 0x4, 0x99, + 0x9, 0x99, 0x4, 0x9a, 0x9, 0x9a, 0x4, 0x9b, 0x9, 0x9b, 0x4, 0x9c, + 0x9, 0x9c, 0x4, 0x9d, 0x9, 0x9d, 0x4, 0x9e, 0x9, 0x9e, 0x4, 0x9f, + 0x9, 0x9f, 0x4, 0xa0, 0x9, 0xa0, 0x4, 0xa1, 0x9, 0xa1, 0x4, 0xa2, + 0x9, 0xa2, 0x4, 0xa3, 0x9, 0xa3, 0x4, 0xa4, 0x9, 0xa4, 0x4, 0xa5, + 0x9, 0xa5, 0x4, 0xa6, 0x9, 0xa6, 0x4, 0xa7, 0x9, 0xa7, 0x4, 0xa8, + 0x9, 0xa8, 0x4, 0xa9, 0x9, 0xa9, 0x4, 0xaa, 0x9, 0xaa, 0x4, 0xab, + 0x9, 0xab, 0x4, 0xac, 0x9, 0xac, 0x4, 0xad, 0x9, 0xad, 0x4, 0xae, + 0x9, 0xae, 0x4, 0xaf, 0x9, 0xaf, 0x4, 0xb0, 0x9, 0xb0, 0x4, 0xb1, + 0x9, 0xb1, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, + 0x3, 0x2, 0x5, 0x2, 0x21d, 0xa, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, + 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, + 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, + 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, + 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, + 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, + 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, + 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, + 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, + 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, + 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, + 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, + 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, + 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, + 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, + 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, + 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, + 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, + 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, + 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, + 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, + 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, + 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, + 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, + 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, + 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, + 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, + 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, + 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x6, 0x1b, 0x2db, 0xa, 0x1b, 0xd, + 0x1b, 0xe, 0x1b, 0x2dc, 0x3, 0x1b, 0x3, 0x1b, 0x6, 0x1b, 0x2e1, 0xa, + 0x1b, 0xd, 0x1b, 0xe, 0x1b, 0x2e2, 0x5, 0x1b, 0x2e5, 0xa, 0x1b, 0x3, + 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x3c7, 0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, + 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, + 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, + 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, + 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, + 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, + 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, + 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, + 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, + 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, + 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, + 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, + 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, 0x3, 0x28, + 0x3, 0x28, 0x3, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x29, + 0x3, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, + 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, + 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2b, + 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2d, + 0x3, 0x2d, 0x3, 0x2d, 0x5, 0x2d, 0x45d, 0xa, 0x2d, 0x3, 0x2e, 0x3, + 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2e, 0x3, + 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, + 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x2f, 0x3, 0x30, 0x3, 0x30, 0x3, + 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, 0x30, 0x3, + 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, 0x31, 0x3, + 0x31, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, + 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, + 0x33, 0x3, 0x33, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, + 0x34, 0x3, 0x34, 0x3, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, + 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, + 0x36, 0x5, 0x36, 0x551, 0xa, 0x36, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, + 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x38, + 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, + 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, 0x3, 0x39, + 0x3, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, + 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3c, 0x3, 0x3c, + 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, + 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, + 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x6, 0x3d, + 0x585, 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x586, 0x3, 0x3d, 0x3, 0x3d, + 0x6, 0x3d, 0x58b, 0xa, 0x3d, 0xd, 0x3d, 0xe, 0x3d, 0x58c, 0x5, 0x3d, + 0x58f, 0xa, 0x3d, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x5, 0x3e, 0x668, 0xa, 0x3e, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, + 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, + 0x3, 0x40, 0x3, 0x40, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, + 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, + 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, + 0x3, 0x44, 0x3, 0x44, 0x3, 0x45, 0x3, 0x45, 0x3, 0x46, 0x3, 0x46, + 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48, 0x3, 0x49, 0x3, 0x49, + 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, + 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, + 0x3, 0x4f, 0x3, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x51, + 0x3, 0x51, 0x3, 0x51, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, + 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x3, 0x54, 0x3, 0x54, + 0x3, 0x54, 0x3, 0x54, 0x3, 0x54, 0x3, 0x55, 0x3, 0x55, 0x3, 0x55, + 0x3, 0x56, 0x3, 0x56, 0x3, 0x56, 0x3, 0x57, 0x3, 0x57, 0x3, 0x57, + 0x3, 0x58, 0x3, 0x58, 0x3, 0x58, 0x3, 0x59, 0x3, 0x59, 0x3, 0x59, + 0x3, 0x5a, 0x3, 0x5a, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5b, 0x3, 0x5c, + 0x3, 0x5c, 0x3, 0x5c, 0x3, 0x5d, 0x3, 0x5d, 0x3, 0x5e, 0x3, 0x5e, + 0x3, 0x5f, 0x3, 0x5f, 0x3, 0x60, 0x3, 0x60, 0x3, 0x60, 0x3, 0x61, + 0x3, 0x61, 0x3, 0x61, 0x3, 0x62, 0x3, 0x62, 0x3, 0x62, 0x3, 0x62, + 0x3, 0x63, 0x3, 0x63, 0x3, 0x64, 0x3, 0x64, 0x3, 0x65, 0x3, 0x65, + 0x3, 0x66, 0x3, 0x66, 0x3, 0x67, 0x3, 0x67, 0x3, 0x68, 0x3, 0x68, + 0x3, 0x68, 0x3, 0x69, 0x3, 0x69, 0x3, 0x69, 0x3, 0x6a, 0x3, 0x6a, + 0x3, 0x6a, 0x3, 0x6b, 0x3, 0x6b, 0x3, 0x6c, 0x3, 0x6c, 0x3, 0x6d, + 0x3, 0x6d, 0x3, 0x6d, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6e, 0x3, 0x6f, + 0x3, 0x6f, 0x3, 0x70, 0x3, 0x70, 0x3, 0x71, 0x3, 0x71, 0x3, 0x71, + 0x3, 0x72, 0x3, 0x72, 0x3, 0x72, 0x3, 0x73, 0x3, 0x73, 0x7, 0x73, + 0x702, 0xa, 0x73, 0xc, 0x73, 0xe, 0x73, 0x705, 0xb, 0x73, 0x3, 0x73, + 0x3, 0x73, 0x3, 0x73, 0x7, 0x73, 0x70a, 0xa, 0x73, 0xc, 0x73, 0xe, + 0x73, 0x70d, 0xb, 0x73, 0x3, 0x73, 0x5, 0x73, 0x710, 0xa, 0x73, 0x3, + 0x74, 0x3, 0x74, 0x6, 0x74, 0x714, 0xa, 0x74, 0xd, 0x74, 0xe, 0x74, + 0x715, 0x3, 0x74, 0x3, 0x74, 0x3, 0x74, 0x3, 0x74, 0x6, 0x74, 0x71c, + 0xa, 0x74, 0xd, 0x74, 0xe, 0x74, 0x71d, 0x3, 0x74, 0x3, 0x74, 0x5, + 0x74, 0x722, 0xa, 0x74, 0x3, 0x75, 0x3, 0x75, 0x5, 0x75, 0x726, 0xa, + 0x75, 0x3, 0x76, 0x3, 0x76, 0x5, 0x76, 0x72a, 0xa, 0x76, 0x3, 0x77, + 0x3, 0x77, 0x3, 0x78, 0x3, 0x78, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, + 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, + 0x3, 0x79, 0x3, 0x79, 0x3, 0x79, 0x5, 0x79, 0x73c, 0xa, 0x79, 0x3, + 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, + 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x7, 0x7a, 0x748, 0xa, 0x7a, + 0xc, 0x7a, 0xe, 0x7a, 0x74b, 0xb, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, + 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x3, + 0x7a, 0x3, 0x7a, 0x3, 0x7a, 0x7, 0x7a, 0x758, 0xa, 0x7a, 0xc, 0x7a, + 0xe, 0x7a, 0x75b, 0xb, 0x7a, 0x3, 0x7a, 0x5, 0x7a, 0x75e, 0xa, 0x7a, + 0x3, 0x7b, 0x3, 0x7b, 0x5, 0x7b, 0x762, 0xa, 0x7b, 0x3, 0x7c, 0x3, + 0x7c, 0x5, 0x7c, 0x766, 0xa, 0x7c, 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, + 0x3, 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x5, 0x7d, 0x76e, 0xa, 0x7d, 0x3, + 0x7d, 0x3, 0x7d, 0x3, 0x7d, 0x5, 0x7d, 0x773, 0xa, 0x7d, 0x3, 0x7d, + 0x5, 0x7d, 0x776, 0xa, 0x7d, 0x3, 0x7e, 0x3, 0x7e, 0x3, 0x7e, 0x3, + 0x7e, 0x3, 0x7f, 0x3, 0x7f, 0x5, 0x7f, 0x77e, 0xa, 0x7f, 0x3, 0x7f, + 0x7, 0x7f, 0x781, 0xa, 0x7f, 0xc, 0x7f, 0xe, 0x7f, 0x784, 0xb, 0x7f, + 0x3, 0x80, 0x3, 0x80, 0x3, 0x80, 0x5, 0x80, 0x789, 0xa, 0x80, 0x3, + 0x80, 0x3, 0x80, 0x3, 0x80, 0x7, 0x80, 0x78e, 0xa, 0x80, 0xc, 0x80, + 0xe, 0x80, 0x791, 0xb, 0x80, 0x3, 0x81, 0x3, 0x81, 0x3, 0x82, 0x3, + 0x82, 0x5, 0x82, 0x797, 0xa, 0x82, 0x3, 0x82, 0x3, 0x82, 0x5, 0x82, + 0x79b, 0xa, 0x82, 0x3, 0x82, 0x3, 0x82, 0x5, 0x82, 0x79f, 0xa, 0x82, + 0x3, 0x82, 0x5, 0x82, 0x7a2, 0xa, 0x82, 0x3, 0x83, 0x3, 0x83, 0x5, + 0x83, 0x7a6, 0xa, 0x83, 0x3, 0x83, 0x7, 0x83, 0x7a9, 0xa, 0x83, 0xc, + 0x83, 0xe, 0x83, 0x7ac, 0xb, 0x83, 0x3, 0x84, 0x3, 0x84, 0x7, 0x84, + 0x7b0, 0xa, 0x84, 0xc, 0x84, 0xe, 0x84, 0x7b3, 0xb, 0x84, 0x3, 0x85, + 0x3, 0x85, 0x3, 0x86, 0x3, 0x86, 0x3, 0x87, 0x6, 0x87, 0x7ba, 0xa, + 0x87, 0xd, 0x87, 0xe, 0x87, 0x7bb, 0x3, 0x87, 0x3, 0x87, 0x3, 0x88, + 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, 0x7, 0x88, 0x7c4, 0xa, 0x88, 0xc, + 0x88, 0xe, 0x88, 0x7c7, 0xb, 0x88, 0x3, 0x88, 0x3, 0x88, 0x3, 0x88, + 0x3, 0x88, 0x3, 0x88, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, 0x3, 0x89, + 0x7, 0x89, 0x7d2, 0xa, 0x89, 0xc, 0x89, 0xe, 0x89, 0x7d5, 0xb, 0x89, + 0x3, 0x89, 0x3, 0x89, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, + 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8a, 0x3, 0x8b, + 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8b, 0x3, 0x8c, 0x6, 0x8c, + 0x7e8, 0xa, 0x8c, 0xd, 0x8c, 0xe, 0x8c, 0x7e9, 0x3, 0x8c, 0x3, 0x8c, + 0x3, 0x8d, 0x3, 0x8d, 0x3, 0x8d, 0x3, 0x8d, 0x7, 0x8d, 0x7f2, 0xa, + 0x8d, 0xc, 0x8d, 0xe, 0x8d, 0x7f5, 0xb, 0x8d, 0x3, 0x8d, 0x3, 0x8d, + 0x3, 0x8d, 0x3, 0x8d, 0x3, 0x8d, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8e, + 0x3, 0x8e, 0x7, 0x8e, 0x800, 0xa, 0x8e, 0xc, 0x8e, 0xe, 0x8e, 0x803, + 0xb, 0x8e, 0x3, 0x8e, 0x3, 0x8e, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, + 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x8f, 0x3, 0x90, 0x3, 0x90, 0x3, 0x90, + 0x3, 0x90, 0x3, 0x90, 0x3, 0x91, 0x3, 0x91, 0x3, 0x91, 0x3, 0x91, + 0x3, 0x91, 0x3, 0x91, 0x3, 0x91, 0x3, 0x91, 0x3, 0x91, 0x3, 0x92, + 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, 0x3, 0x92, + 0x3, 0x92, 0x3, 0x93, 0x3, 0x93, 0x3, 0x93, 0x3, 0x93, 0x3, 0x93, + 0x3, 0x93, 0x3, 0x94, 0x3, 0x94, 0x3, 0x94, 0x3, 0x94, 0x3, 0x95, + 0x3, 0x95, 0x3, 0x95, 0x3, 0x95, 0x3, 0x95, 0x3, 0x95, 0x3, 0x95, + 0x3, 0x95, 0x3, 0x95, 0x3, 0x96, 0x3, 0x96, 0x3, 0x96, 0x3, 0x97, + 0x3, 0x97, 0x3, 0x97, 0x3, 0x97, 0x3, 0x97, 0x3, 0x97, 0x3, 0x98, + 0x3, 0x98, 0x3, 0x98, 0x3, 0x98, 0x3, 0x99, 0x3, 0x99, 0x3, 0x99, + 0x3, 0x99, 0x3, 0x99, 0x3, 0x99, 0x3, 0x99, 0x3, 0x9a, 0x3, 0x9a, + 0x3, 0x9a, 0x3, 0x9a, 0x3, 0x9a, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, 0x3, 0x9b, + 0x3, 0x9b, 0x3, 0x9b, 0x5, 0x9b, 0xa10, 0xa, 0x9b, 0x3, 0x9c, 0x3, + 0x9c, 0x3, 0x9c, 0x3, 0x9c, 0x3, 0x9d, 0x3, 0x9d, 0x3, 0x9d, 0x3, + 0x9d, 0x3, 0x9e, 0x3, 0x9e, 0x3, 0x9f, 0x3, 0x9f, 0x3, 0xa0, 0x3, + 0xa0, 0x3, 0xa0, 0x3, 0xa1, 0x3, 0xa1, 0x3, 0xa2, 0x3, 0xa2, 0x3, + 0xa3, 0x3, 0xa3, 0x3, 0xa3, 0x3, 0xa3, 0x6, 0xa3, 0xa29, 0xa, 0xa3, + 0xd, 0xa3, 0xe, 0xa3, 0xa2a, 0x3, 0xa3, 0x3, 0xa3, 0x5, 0xa3, 0xa2f, + 0xa, 0xa3, 0x3, 0xa4, 0x3, 0xa4, 0x7, 0xa4, 0xa33, 0xa, 0xa4, 0xc, + 0xa4, 0xe, 0xa4, 0xa36, 0xb, 0xa4, 0x3, 0xa5, 0x3, 0xa5, 0x3, 0xa6, + 0x3, 0xa6, 0x3, 0xa7, 0x3, 0xa7, 0x3, 0xa7, 0x6, 0xa7, 0xa3f, 0xa, + 0xa7, 0xd, 0xa7, 0xe, 0xa7, 0xa40, 0x3, 0xa8, 0x3, 0xa8, 0x3, 0xa8, + 0x7, 0xa8, 0xa46, 0xa, 0xa8, 0xc, 0xa8, 0xe, 0xa8, 0xa49, 0xb, 0xa8, + 0x5, 0xa8, 0xa4b, 0xa, 0xa8, 0x3, 0xa9, 0x3, 0xa9, 0x7, 0xa9, 0xa4f, + 0xa, 0xa9, 0xc, 0xa9, 0xe, 0xa9, 0xa52, 0xb, 0xa9, 0x3, 0xa9, 0x3, + 0xa9, 0x3, 0xa9, 0x7, 0xa9, 0xa57, 0xa, 0xa9, 0xc, 0xa9, 0xe, 0xa9, + 0xa5a, 0xb, 0xa9, 0x3, 0xa9, 0x5, 0xa9, 0xa5d, 0xa, 0xa9, 0x3, 0xaa, + 0x6, 0xaa, 0xa60, 0xa, 0xaa, 0xd, 0xaa, 0xe, 0xaa, 0xa61, 0x3, 0xaa, + 0x3, 0xaa, 0x3, 0xab, 0x3, 0xab, 0x3, 0xab, 0x3, 0xab, 0x7, 0xab, + 0xa6a, 0xa, 0xab, 0xc, 0xab, 0xe, 0xab, 0xa6d, 0xb, 0xab, 0x3, 0xab, + 0x3, 0xab, 0x3, 0xab, 0x3, 0xab, 0x3, 0xab, 0x3, 0xac, 0x3, 0xac, + 0x3, 0xac, 0x3, 0xac, 0x7, 0xac, 0xa78, 0xa, 0xac, 0xc, 0xac, 0xe, + 0xac, 0xa7b, 0xb, 0xac, 0x3, 0xac, 0x3, 0xac, 0x3, 0xad, 0x6, 0xad, + 0xa80, 0xa, 0xad, 0xd, 0xad, 0xe, 0xad, 0xa81, 0x3, 0xae, 0x3, 0xae, + 0x3, 0xae, 0x3, 0xae, 0x3, 0xaf, 0x6, 0xaf, 0xa89, 0xa, 0xaf, 0xd, + 0xaf, 0xe, 0xaf, 0xa8a, 0x3, 0xaf, 0x3, 0xaf, 0x3, 0xb0, 0x3, 0xb0, + 0x3, 0xb0, 0x3, 0xb0, 0x7, 0xb0, 0xa93, 0xa, 0xb0, 0xc, 0xb0, 0xe, + 0xb0, 0xa96, 0xb, 0xb0, 0x3, 0xb0, 0x3, 0xb0, 0x3, 0xb0, 0x3, 0xb0, + 0x3, 0xb0, 0x3, 0xb1, 0x3, 0xb1, 0x3, 0xb1, 0x3, 0xb1, 0x7, 0xb1, + 0xaa1, 0xa, 0xb1, 0xc, 0xb1, 0xe, 0xb1, 0xaa4, 0xb, 0xb1, 0x3, 0xb1, + 0x3, 0xb1, 0x6, 0x7c5, 0x7f3, 0xa6b, 0xa94, 0x2, 0xb2, 0x6, 0x3, + 0x8, 0x4, 0xa, 0x5, 0xc, 0x6, 0xe, 0x7, 0x10, 0x8, 0x12, 0x9, 0x14, + 0xa, 0x16, 0xb, 0x18, 0xc, 0x1a, 0xd, 0x1c, 0xe, 0x1e, 0xf, 0x20, + 0x10, 0x22, 0x11, 0x24, 0x12, 0x26, 0x13, 0x28, 0x14, 0x2a, 0x15, + 0x2c, 0x16, 0x2e, 0x17, 0x30, 0x18, 0x32, 0x19, 0x34, 0x1a, 0x36, + 0x1b, 0x38, 0x1c, 0x3a, 0x1d, 0x3c, 0x1e, 0x3e, 0x1f, 0x40, 0x20, + 0x42, 0x21, 0x44, 0x22, 0x46, 0x23, 0x48, 0x24, 0x4a, 0x25, 0x4c, + 0x26, 0x4e, 0x27, 0x50, 0x28, 0x52, 0x29, 0x54, 0x2a, 0x56, 0x2b, + 0x58, 0x2c, 0x5a, 0x2d, 0x5c, 0x2e, 0x5e, 0x2f, 0x60, 0x30, 0x62, + 0x31, 0x64, 0x32, 0x66, 0x33, 0x68, 0x34, 0x6a, 0x35, 0x6c, 0x36, + 0x6e, 0x37, 0x70, 0x38, 0x72, 0x39, 0x74, 0x3a, 0x76, 0x3b, 0x78, + 0x3c, 0x7a, 0x3d, 0x7c, 0x3e, 0x7e, 0x3f, 0x80, 0x40, 0x82, 0x41, + 0x84, 0x42, 0x86, 0x43, 0x88, 0x44, 0x8a, 0x45, 0x8c, 0x46, 0x8e, + 0x47, 0x90, 0x48, 0x92, 0x49, 0x94, 0x4a, 0x96, 0x4b, 0x98, 0x4c, + 0x9a, 0x4d, 0x9c, 0x4e, 0x9e, 0x4f, 0xa0, 0x50, 0xa2, 0x51, 0xa4, + 0x52, 0xa6, 0x53, 0xa8, 0x54, 0xaa, 0x55, 0xac, 0x56, 0xae, 0x57, + 0xb0, 0x58, 0xb2, 0x59, 0xb4, 0x5a, 0xb6, 0x5b, 0xb8, 0x5c, 0xba, + 0x5d, 0xbc, 0x5e, 0xbe, 0x5f, 0xc0, 0x60, 0xc2, 0x61, 0xc4, 0x62, + 0xc6, 0x63, 0xc8, 0x64, 0xca, 0x65, 0xcc, 0x66, 0xce, 0x67, 0xd0, + 0x68, 0xd2, 0x69, 0xd4, 0x6a, 0xd6, 0x6b, 0xd8, 0x6c, 0xda, 0x6d, + 0xdc, 0x6e, 0xde, 0x6f, 0xe0, 0x70, 0xe2, 0x71, 0xe4, 0x72, 0xe6, + 0x73, 0xe8, 0x74, 0xea, 0x75, 0xec, 0x2, 0xee, 0x2, 0xf0, 0x2, 0xf2, + 0x2, 0xf4, 0x2, 0xf6, 0x76, 0xf8, 0x2, 0xfa, 0x2, 0xfc, 0x77, 0xfe, + 0x78, 0x100, 0x2, 0x102, 0x2, 0x104, 0x2, 0x106, 0x79, 0x108, 0x2, + 0x10a, 0x7a, 0x10c, 0x2, 0x10e, 0x2, 0x110, 0x7b, 0x112, 0x7c, 0x114, + 0x7d, 0x116, 0x7e, 0x118, 0x7f, 0x11a, 0x80, 0x11c, 0x81, 0x11e, + 0x82, 0x120, 0x83, 0x122, 0x84, 0x124, 0x85, 0x126, 0x86, 0x128, + 0x87, 0x12a, 0x88, 0x12c, 0x89, 0x12e, 0x8a, 0x130, 0x8b, 0x132, + 0x8c, 0x134, 0x8d, 0x136, 0x8e, 0x138, 0x8f, 0x13a, 0x90, 0x13c, + 0x91, 0x13e, 0x92, 0x140, 0x93, 0x142, 0x94, 0x144, 0x95, 0x146, + 0x96, 0x148, 0x97, 0x14a, 0x98, 0x14c, 0x2, 0x14e, 0x2, 0x150, 0x99, + 0x152, 0x9a, 0x154, 0x9b, 0x156, 0x9c, 0x158, 0x9d, 0x15a, 0x9e, + 0x15c, 0x9f, 0x15e, 0xa0, 0x160, 0xa1, 0x162, 0xa2, 0x164, 0xa3, + 0x6, 0x2, 0x3, 0x4, 0x5, 0x10, 0x3, 0x2, 0x32, 0x3b, 0x5, 0x2, 0x22, + 0x28, 0x2a, 0x5d, 0x5f, 0x80, 0x5, 0x2, 0x22, 0x23, 0x25, 0x5d, 0x5f, + 0x80, 0xd, 0x2, 0xc, 0xc, 0xf, 0xf, 0x24, 0x24, 0x29, 0x29, 0x5e, + 0x5e, 0x64, 0x64, 0x68, 0x68, 0x70, 0x70, 0x74, 0x74, 0x76, 0x76, + 0x78, 0x78, 0x6, 0x2, 0xc, 0xc, 0xf, 0xf, 0x24, 0x24, 0x5e, 0x5e, + 0x6, 0x2, 0xc, 0xc, 0xf, 0xf, 0x29, 0x29, 0x5e, 0x5e, 0x5, 0x2, 0x32, + 0x3b, 0x43, 0x48, 0x63, 0x68, 0x4, 0x2, 0x47, 0x47, 0x67, 0x67, 0x6, + 0x2, 0x26, 0x26, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0x7, 0x2, 0x26, + 0x26, 0x32, 0x3b, 0x43, 0x5c, 0x61, 0x61, 0x63, 0x7c, 0x5, 0x2, 0xb, + 0xc, 0xe, 0xf, 0x22, 0x22, 0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 0x3, 0x2, + 0x33, 0x3b, 0x3, 0x2, 0x3d, 0x3d, 0x2, 0xb9a, 0x2, 0x6, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x8, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa, 0x3, 0x2, 0x2, + 0x2, 0x2, 0xc, 0x3, 0x2, 0x2, 0x2, 0x2, 0xe, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x10, 0x3, 0x2, 0x2, 0x2, 0x2, 0x12, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x14, 0x3, 0x2, 0x2, 0x2, 0x2, 0x16, 0x3, 0x2, 0x2, 0x2, 0x2, 0x18, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x1a, 0x3, 0x2, 0x2, 0x2, 0x2, 0x1c, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x1e, 0x3, 0x2, 0x2, 0x2, 0x2, 0x20, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x22, 0x3, 0x2, 0x2, 0x2, 0x2, 0x24, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x26, 0x3, 0x2, 0x2, 0x2, 0x2, 0x28, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x2, 0x2c, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x2e, 0x3, 0x2, 0x2, 0x2, 0x2, 0x30, 0x3, 0x2, 0x2, 0x2, 0x2, 0x32, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x34, 0x3, 0x2, 0x2, 0x2, 0x2, 0x36, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x38, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3a, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x3c, 0x3, 0x2, 0x2, 0x2, 0x2, 0x3e, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x40, 0x3, 0x2, 0x2, 0x2, 0x2, 0x42, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x44, 0x3, 0x2, 0x2, 0x2, 0x2, 0x46, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x48, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x2, 0x4c, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x4e, 0x3, 0x2, 0x2, 0x2, 0x2, 0x50, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x52, 0x3, 0x2, 0x2, 0x2, 0x2, 0x54, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x56, 0x3, 0x2, 0x2, 0x2, 0x2, 0x58, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x5a, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5c, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x2, 0x60, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x62, 0x3, 0x2, 0x2, 0x2, 0x2, 0x64, 0x3, 0x2, 0x2, 0x2, 0x2, 0x66, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x68, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6a, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x6c, 0x3, 0x2, 0x2, 0x2, 0x2, 0x6e, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x70, 0x3, 0x2, 0x2, 0x2, 0x2, 0x72, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x74, 0x3, 0x2, 0x2, 0x2, 0x2, 0x76, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x78, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x7c, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x2, 0x80, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x82, 0x3, 0x2, 0x2, 0x2, 0x2, 0x84, 0x3, + 0x2, 0x2, 0x2, 0x2, 0x86, 0x3, 0x2, 0x2, 0x2, 0x2, 0x88, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x2, 0x8c, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x2, 0x90, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x92, 0x3, 0x2, 0x2, 0x2, 0x2, 0x94, 0x3, 0x2, 0x2, 0x2, 0x2, + 0x96, 0x3, 0x2, 0x2, 0x2, 0x2, 0x98, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9a, + 0x3, 0x2, 0x2, 0x2, 0x2, 0x9c, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9e, 0x3, + 0x2, 0x2, 0x2, 0x2, 0xa0, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa2, 0x3, 0x2, + 0x2, 0x2, 0x2, 0xa4, 0x3, 0x2, 0x2, 0x2, 0x2, 0xa6, 0x3, 0x2, 0x2, + 0x2, 0x2, 0xa8, 0x3, 0x2, 0x2, 0x2, 0x2, 0xaa, 0x3, 0x2, 0x2, 0x2, + 0x2, 0xac, 0x3, 0x2, 0x2, 0x2, 0x2, 0xae, 0x3, 0x2, 0x2, 0x2, 0x2, + 0xb0, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb2, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb4, + 0x3, 0x2, 0x2, 0x2, 0x2, 0xb6, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb8, 0x3, + 0x2, 0x2, 0x2, 0x2, 0xba, 0x3, 0x2, 0x2, 0x2, 0x2, 0xbc, 0x3, 0x2, + 0x2, 0x2, 0x2, 0xbe, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc0, 0x3, 0x2, 0x2, + 0x2, 0x2, 0xc2, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc4, 0x3, 0x2, 0x2, 0x2, + 0x2, 0xc6, 0x3, 0x2, 0x2, 0x2, 0x2, 0xc8, 0x3, 0x2, 0x2, 0x2, 0x2, + 0xca, 0x3, 0x2, 0x2, 0x2, 0x2, 0xcc, 0x3, 0x2, 0x2, 0x2, 0x2, 0xce, + 0x3, 0x2, 0x2, 0x2, 0x2, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd2, 0x3, + 0x2, 0x2, 0x2, 0x2, 0xd4, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd6, 0x3, 0x2, + 0x2, 0x2, 0x2, 0xd8, 0x3, 0x2, 0x2, 0x2, 0x2, 0xda, 0x3, 0x2, 0x2, + 0x2, 0x2, 0xdc, 0x3, 0x2, 0x2, 0x2, 0x2, 0xde, 0x3, 0x2, 0x2, 0x2, + 0x2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x2, 0xe2, 0x3, 0x2, 0x2, 0x2, 0x2, + 0xe4, 0x3, 0x2, 0x2, 0x2, 0x2, 0xe6, 0x3, 0x2, 0x2, 0x2, 0x2, 0xe8, + 0x3, 0x2, 0x2, 0x2, 0x2, 0xea, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf6, 0x3, + 0x2, 0x2, 0x2, 0x2, 0xfc, 0x3, 0x2, 0x2, 0x2, 0x2, 0xfe, 0x3, 0x2, + 0x2, 0x2, 0x2, 0x106, 0x3, 0x2, 0x2, 0x2, 0x2, 0x10a, 0x3, 0x2, 0x2, + 0x2, 0x2, 0x110, 0x3, 0x2, 0x2, 0x2, 0x2, 0x112, 0x3, 0x2, 0x2, 0x2, + 0x2, 0x114, 0x3, 0x2, 0x2, 0x2, 0x3, 0x116, 0x3, 0x2, 0x2, 0x2, 0x3, + 0x118, 0x3, 0x2, 0x2, 0x2, 0x3, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x3, 0x11c, + 0x3, 0x2, 0x2, 0x2, 0x3, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x4, 0x120, 0x3, + 0x2, 0x2, 0x2, 0x4, 0x122, 0x3, 0x2, 0x2, 0x2, 0x4, 0x124, 0x3, 0x2, + 0x2, 0x2, 0x4, 0x126, 0x3, 0x2, 0x2, 0x2, 0x4, 0x128, 0x3, 0x2, 0x2, + 0x2, 0x4, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x4, 0x12c, 0x3, 0x2, 0x2, 0x2, + 0x4, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x4, 0x130, 0x3, 0x2, 0x2, 0x2, 0x4, + 0x132, 0x3, 0x2, 0x2, 0x2, 0x4, 0x134, 0x3, 0x2, 0x2, 0x2, 0x4, 0x136, + 0x3, 0x2, 0x2, 0x2, 0x4, 0x138, 0x3, 0x2, 0x2, 0x2, 0x4, 0x13a, 0x3, + 0x2, 0x2, 0x2, 0x4, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x4, 0x13e, 0x3, 0x2, + 0x2, 0x2, 0x4, 0x140, 0x3, 0x2, 0x2, 0x2, 0x4, 0x142, 0x3, 0x2, 0x2, + 0x2, 0x4, 0x144, 0x3, 0x2, 0x2, 0x2, 0x4, 0x146, 0x3, 0x2, 0x2, 0x2, + 0x4, 0x148, 0x3, 0x2, 0x2, 0x2, 0x4, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x4, + 0x150, 0x3, 0x2, 0x2, 0x2, 0x4, 0x152, 0x3, 0x2, 0x2, 0x2, 0x4, 0x154, + 0x3, 0x2, 0x2, 0x2, 0x4, 0x156, 0x3, 0x2, 0x2, 0x2, 0x4, 0x158, 0x3, + 0x2, 0x2, 0x2, 0x4, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x5, 0x15c, 0x3, 0x2, + 0x2, 0x2, 0x5, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x5, 0x160, 0x3, 0x2, 0x2, + 0x2, 0x5, 0x162, 0x3, 0x2, 0x2, 0x2, 0x5, 0x164, 0x3, 0x2, 0x2, 0x2, + 0x6, 0x21c, 0x3, 0x2, 0x2, 0x2, 0x8, 0x21e, 0x3, 0x2, 0x2, 0x2, 0xa, + 0x227, 0x3, 0x2, 0x2, 0x2, 0xc, 0x230, 0x3, 0x2, 0x2, 0x2, 0xe, 0x23a, + 0x3, 0x2, 0x2, 0x2, 0x10, 0x242, 0x3, 0x2, 0x2, 0x2, 0x12, 0x245, + 0x3, 0x2, 0x2, 0x2, 0x14, 0x250, 0x3, 0x2, 0x2, 0x2, 0x16, 0x255, + 0x3, 0x2, 0x2, 0x2, 0x18, 0x25b, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x261, + 0x3, 0x2, 0x2, 0x2, 0x1c, 0x26a, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x270, + 0x3, 0x2, 0x2, 0x2, 0x20, 0x279, 0x3, 0x2, 0x2, 0x2, 0x22, 0x285, + 0x3, 0x2, 0x2, 0x2, 0x24, 0x28e, 0x3, 0x2, 0x2, 0x2, 0x26, 0x297, + 0x3, 0x2, 0x2, 0x2, 0x28, 0x29e, 0x3, 0x2, 0x2, 0x2, 0x2a, 0x2a1, + 0x3, 0x2, 0x2, 0x2, 0x2c, 0x2a6, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x2ab, + 0x3, 0x2, 0x2, 0x2, 0x30, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x32, 0x2b6, + 0x3, 0x2, 0x2, 0x2, 0x34, 0x2bf, 0x3, 0x2, 0x2, 0x2, 0x36, 0x2c8, + 0x3, 0x2, 0x2, 0x2, 0x38, 0x2e4, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x2e6, + 0x3, 0x2, 0x2, 0x2, 0x3c, 0x3c6, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x3c8, + 0x3, 0x2, 0x2, 0x2, 0x40, 0x3cc, 0x3, 0x2, 0x2, 0x2, 0x42, 0x3d5, + 0x3, 0x2, 0x2, 0x2, 0x44, 0x3d9, 0x3, 0x2, 0x2, 0x2, 0x46, 0x3dc, + 0x3, 0x2, 0x2, 0x2, 0x48, 0x3e6, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x3ed, + 0x3, 0x2, 0x2, 0x2, 0x4c, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x3ff, + 0x3, 0x2, 0x2, 0x2, 0x50, 0x408, 0x3, 0x2, 0x2, 0x2, 0x52, 0x40b, + 0x3, 0x2, 0x2, 0x2, 0x54, 0x413, 0x3, 0x2, 0x2, 0x2, 0x56, 0x41b, + 0x3, 0x2, 0x2, 0x2, 0x58, 0x422, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x42b, + 0x3, 0x2, 0x2, 0x2, 0x5c, 0x45c, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x45e, + 0x3, 0x2, 0x2, 0x2, 0x60, 0x467, 0x3, 0x2, 0x2, 0x2, 0x62, 0x46f, + 0x3, 0x2, 0x2, 0x2, 0x64, 0x477, 0x3, 0x2, 0x2, 0x2, 0x66, 0x47e, + 0x3, 0x2, 0x2, 0x2, 0x68, 0x483, 0x3, 0x2, 0x2, 0x2, 0x6a, 0x48b, + 0x3, 0x2, 0x2, 0x2, 0x6c, 0x492, 0x3, 0x2, 0x2, 0x2, 0x6e, 0x550, + 0x3, 0x2, 0x2, 0x2, 0x70, 0x552, 0x3, 0x2, 0x2, 0x2, 0x72, 0x55a, + 0x3, 0x2, 0x2, 0x2, 0x74, 0x561, 0x3, 0x2, 0x2, 0x2, 0x76, 0x568, + 0x3, 0x2, 0x2, 0x2, 0x78, 0x56d, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x571, + 0x3, 0x2, 0x2, 0x2, 0x7c, 0x58e, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x667, + 0x3, 0x2, 0x2, 0x2, 0x80, 0x669, 0x3, 0x2, 0x2, 0x2, 0x82, 0x66f, + 0x3, 0x2, 0x2, 0x2, 0x84, 0x674, 0x3, 0x2, 0x2, 0x2, 0x86, 0x67c, + 0x3, 0x2, 0x2, 0x2, 0x88, 0x682, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x684, + 0x3, 0x2, 0x2, 0x2, 0x8c, 0x686, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x688, + 0x3, 0x2, 0x2, 0x2, 0x90, 0x68a, 0x3, 0x2, 0x2, 0x2, 0x92, 0x68c, + 0x3, 0x2, 0x2, 0x2, 0x94, 0x68e, 0x3, 0x2, 0x2, 0x2, 0x96, 0x690, + 0x3, 0x2, 0x2, 0x2, 0x98, 0x692, 0x3, 0x2, 0x2, 0x2, 0x9a, 0x694, + 0x3, 0x2, 0x2, 0x2, 0x9c, 0x696, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x699, + 0x3, 0x2, 0x2, 0x2, 0xa0, 0x69b, 0x3, 0x2, 0x2, 0x2, 0xa2, 0x69e, + 0x3, 0x2, 0x2, 0x2, 0xa4, 0x6a1, 0x3, 0x2, 0x2, 0x2, 0xa6, 0x6a4, + 0x3, 0x2, 0x2, 0x2, 0xa8, 0x6a8, 0x3, 0x2, 0x2, 0x2, 0xaa, 0x6ac, + 0x3, 0x2, 0x2, 0x2, 0xac, 0x6b1, 0x3, 0x2, 0x2, 0x2, 0xae, 0x6b4, + 0x3, 0x2, 0x2, 0x2, 0xb0, 0x6b7, 0x3, 0x2, 0x2, 0x2, 0xb2, 0x6ba, + 0x3, 0x2, 0x2, 0x2, 0xb4, 0x6bd, 0x3, 0x2, 0x2, 0x2, 0xb6, 0x6c0, + 0x3, 0x2, 0x2, 0x2, 0xb8, 0x6c2, 0x3, 0x2, 0x2, 0x2, 0xba, 0x6c5, + 0x3, 0x2, 0x2, 0x2, 0xbc, 0x6c8, 0x3, 0x2, 0x2, 0x2, 0xbe, 0x6ca, + 0x3, 0x2, 0x2, 0x2, 0xc0, 0x6cc, 0x3, 0x2, 0x2, 0x2, 0xc2, 0x6ce, + 0x3, 0x2, 0x2, 0x2, 0xc4, 0x6d1, 0x3, 0x2, 0x2, 0x2, 0xc6, 0x6d4, + 0x3, 0x2, 0x2, 0x2, 0xc8, 0x6d8, 0x3, 0x2, 0x2, 0x2, 0xca, 0x6da, + 0x3, 0x2, 0x2, 0x2, 0xcc, 0x6dc, 0x3, 0x2, 0x2, 0x2, 0xce, 0x6de, + 0x3, 0x2, 0x2, 0x2, 0xd0, 0x6e0, 0x3, 0x2, 0x2, 0x2, 0xd2, 0x6e2, + 0x3, 0x2, 0x2, 0x2, 0xd4, 0x6e5, 0x3, 0x2, 0x2, 0x2, 0xd6, 0x6e8, + 0x3, 0x2, 0x2, 0x2, 0xd8, 0x6eb, 0x3, 0x2, 0x2, 0x2, 0xda, 0x6ed, + 0x3, 0x2, 0x2, 0x2, 0xdc, 0x6ef, 0x3, 0x2, 0x2, 0x2, 0xde, 0x6f2, + 0x3, 0x2, 0x2, 0x2, 0xe0, 0x6f5, 0x3, 0x2, 0x2, 0x2, 0xe2, 0x6f7, + 0x3, 0x2, 0x2, 0x2, 0xe4, 0x6f9, 0x3, 0x2, 0x2, 0x2, 0xe6, 0x6fc, + 0x3, 0x2, 0x2, 0x2, 0xe8, 0x70f, 0x3, 0x2, 0x2, 0x2, 0xea, 0x721, + 0x3, 0x2, 0x2, 0x2, 0xec, 0x725, 0x3, 0x2, 0x2, 0x2, 0xee, 0x729, + 0x3, 0x2, 0x2, 0x2, 0xf0, 0x72b, 0x3, 0x2, 0x2, 0x2, 0xf2, 0x72d, + 0x3, 0x2, 0x2, 0x2, 0xf4, 0x72f, 0x3, 0x2, 0x2, 0x2, 0xf6, 0x75d, + 0x3, 0x2, 0x2, 0x2, 0xf8, 0x761, 0x3, 0x2, 0x2, 0x2, 0xfa, 0x765, + 0x3, 0x2, 0x2, 0x2, 0xfc, 0x767, 0x3, 0x2, 0x2, 0x2, 0xfe, 0x777, + 0x3, 0x2, 0x2, 0x2, 0x100, 0x77b, 0x3, 0x2, 0x2, 0x2, 0x102, 0x785, + 0x3, 0x2, 0x2, 0x2, 0x104, 0x792, 0x3, 0x2, 0x2, 0x2, 0x106, 0x79a, + 0x3, 0x2, 0x2, 0x2, 0x108, 0x7a3, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x7ad, + 0x3, 0x2, 0x2, 0x2, 0x10c, 0x7b4, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x7b6, + 0x3, 0x2, 0x2, 0x2, 0x110, 0x7b9, 0x3, 0x2, 0x2, 0x2, 0x112, 0x7bf, + 0x3, 0x2, 0x2, 0x2, 0x114, 0x7cd, 0x3, 0x2, 0x2, 0x2, 0x116, 0x7d8, + 0x3, 0x2, 0x2, 0x2, 0x118, 0x7e1, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x7e7, + 0x3, 0x2, 0x2, 0x2, 0x11c, 0x7ed, 0x3, 0x2, 0x2, 0x2, 0x11e, 0x7fb, + 0x3, 0x2, 0x2, 0x2, 0x120, 0x806, 0x3, 0x2, 0x2, 0x2, 0x122, 0x80c, + 0x3, 0x2, 0x2, 0x2, 0x124, 0x811, 0x3, 0x2, 0x2, 0x2, 0x126, 0x81a, + 0x3, 0x2, 0x2, 0x2, 0x128, 0x822, 0x3, 0x2, 0x2, 0x2, 0x12a, 0x828, + 0x3, 0x2, 0x2, 0x2, 0x12c, 0x82c, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x835, + 0x3, 0x2, 0x2, 0x2, 0x130, 0x838, 0x3, 0x2, 0x2, 0x2, 0x132, 0x83e, + 0x3, 0x2, 0x2, 0x2, 0x134, 0x842, 0x3, 0x2, 0x2, 0x2, 0x136, 0x849, + 0x3, 0x2, 0x2, 0x2, 0x138, 0xa0f, 0x3, 0x2, 0x2, 0x2, 0x13a, 0xa11, + 0x3, 0x2, 0x2, 0x2, 0x13c, 0xa15, 0x3, 0x2, 0x2, 0x2, 0x13e, 0xa19, + 0x3, 0x2, 0x2, 0x2, 0x140, 0xa1b, 0x3, 0x2, 0x2, 0x2, 0x142, 0xa1d, + 0x3, 0x2, 0x2, 0x2, 0x144, 0xa20, 0x3, 0x2, 0x2, 0x2, 0x146, 0xa22, + 0x3, 0x2, 0x2, 0x2, 0x148, 0xa2e, 0x3, 0x2, 0x2, 0x2, 0x14a, 0xa30, + 0x3, 0x2, 0x2, 0x2, 0x14c, 0xa37, 0x3, 0x2, 0x2, 0x2, 0x14e, 0xa39, + 0x3, 0x2, 0x2, 0x2, 0x150, 0xa3b, 0x3, 0x2, 0x2, 0x2, 0x152, 0xa4a, + 0x3, 0x2, 0x2, 0x2, 0x154, 0xa5c, 0x3, 0x2, 0x2, 0x2, 0x156, 0xa5f, + 0x3, 0x2, 0x2, 0x2, 0x158, 0xa65, 0x3, 0x2, 0x2, 0x2, 0x15a, 0xa73, + 0x3, 0x2, 0x2, 0x2, 0x15c, 0xa7f, 0x3, 0x2, 0x2, 0x2, 0x15e, 0xa83, + 0x3, 0x2, 0x2, 0x2, 0x160, 0xa88, 0x3, 0x2, 0x2, 0x2, 0x162, 0xa8e, + 0x3, 0x2, 0x2, 0x2, 0x164, 0xa9c, 0x3, 0x2, 0x2, 0x2, 0x166, 0x167, + 0x7, 0x63, 0x2, 0x2, 0x167, 0x168, 0x7, 0x68, 0x2, 0x2, 0x168, 0x169, + 0x7, 0x76, 0x2, 0x2, 0x169, 0x16a, 0x7, 0x67, 0x2, 0x2, 0x16a, 0x21d, + 0x7, 0x74, 0x2, 0x2, 0x16b, 0x16c, 0x7, 0x63, 0x2, 0x2, 0x16c, 0x16d, + 0x7, 0x6e, 0x2, 0x2, 0x16d, 0x16e, 0x7, 0x6b, 0x2, 0x2, 0x16e, 0x16f, + 0x7, 0x63, 0x2, 0x2, 0x16f, 0x21d, 0x7, 0x75, 0x2, 0x2, 0x170, 0x171, + 0x7, 0x63, 0x2, 0x2, 0x171, 0x172, 0x7, 0x72, 0x2, 0x2, 0x172, 0x173, + 0x7, 0x72, 0x2, 0x2, 0x173, 0x174, 0x7, 0x6e, 0x2, 0x2, 0x174, 0x21d, + 0x7, 0x7b, 0x2, 0x2, 0x175, 0x176, 0x7, 0x63, 0x2, 0x2, 0x176, 0x177, + 0x7, 0x77, 0x2, 0x2, 0x177, 0x178, 0x7, 0x76, 0x2, 0x2, 0x178, 0x21d, + 0x7, 0x71, 0x2, 0x2, 0x179, 0x17a, 0x7, 0x65, 0x2, 0x2, 0x17a, 0x17b, + 0x7, 0x63, 0x2, 0x2, 0x17b, 0x17c, 0x7, 0x75, 0x2, 0x2, 0x17c, 0x21d, + 0x7, 0x67, 0x2, 0x2, 0x17d, 0x17e, 0x7, 0x65, 0x2, 0x2, 0x17e, 0x17f, + 0x7, 0x71, 0x2, 0x2, 0x17f, 0x180, 0x7, 0x72, 0x2, 0x2, 0x180, 0x181, + 0x7, 0x7b, 0x2, 0x2, 0x181, 0x182, 0x7, 0x71, 0x2, 0x2, 0x182, 0x21d, + 0x7, 0x68, 0x2, 0x2, 0x183, 0x184, 0x7, 0x66, 0x2, 0x2, 0x184, 0x185, + 0x7, 0x67, 0x2, 0x2, 0x185, 0x186, 0x7, 0x68, 0x2, 0x2, 0x186, 0x187, + 0x7, 0x63, 0x2, 0x2, 0x187, 0x188, 0x7, 0x77, 0x2, 0x2, 0x188, 0x189, + 0x7, 0x6e, 0x2, 0x2, 0x189, 0x21d, 0x7, 0x76, 0x2, 0x2, 0x18a, 0x18b, + 0x7, 0x66, 0x2, 0x2, 0x18b, 0x18c, 0x7, 0x67, 0x2, 0x2, 0x18c, 0x18d, + 0x7, 0x68, 0x2, 0x2, 0x18d, 0x18e, 0x7, 0x6b, 0x2, 0x2, 0x18e, 0x18f, + 0x7, 0x70, 0x2, 0x2, 0x18f, 0x21d, 0x7, 0x67, 0x2, 0x2, 0x190, 0x191, + 0x7, 0x68, 0x2, 0x2, 0x191, 0x192, 0x7, 0x6b, 0x2, 0x2, 0x192, 0x193, + 0x7, 0x70, 0x2, 0x2, 0x193, 0x194, 0x7, 0x63, 0x2, 0x2, 0x194, 0x21d, + 0x7, 0x6e, 0x2, 0x2, 0x195, 0x196, 0x7, 0x6b, 0x2, 0x2, 0x196, 0x197, + 0x7, 0x6f, 0x2, 0x2, 0x197, 0x198, 0x7, 0x72, 0x2, 0x2, 0x198, 0x199, + 0x7, 0x6e, 0x2, 0x2, 0x199, 0x19a, 0x7, 0x67, 0x2, 0x2, 0x19a, 0x19b, + 0x7, 0x6f, 0x2, 0x2, 0x19b, 0x19c, 0x7, 0x67, 0x2, 0x2, 0x19c, 0x19d, + 0x7, 0x70, 0x2, 0x2, 0x19d, 0x19e, 0x7, 0x76, 0x2, 0x2, 0x19e, 0x21d, + 0x7, 0x75, 0x2, 0x2, 0x19f, 0x1a0, 0x7, 0x6b, 0x2, 0x2, 0x1a0, 0x21d, + 0x7, 0x70, 0x2, 0x2, 0x1a1, 0x1a2, 0x7, 0x6b, 0x2, 0x2, 0x1a2, 0x1a3, + 0x7, 0x70, 0x2, 0x2, 0x1a3, 0x1a4, 0x7, 0x6e, 0x2, 0x2, 0x1a4, 0x1a5, + 0x7, 0x6b, 0x2, 0x2, 0x1a5, 0x1a6, 0x7, 0x70, 0x2, 0x2, 0x1a6, 0x21d, + 0x7, 0x67, 0x2, 0x2, 0x1a7, 0x1a8, 0x7, 0x6e, 0x2, 0x2, 0x1a8, 0x1a9, + 0x7, 0x67, 0x2, 0x2, 0x1a9, 0x21d, 0x7, 0x76, 0x2, 0x2, 0x1aa, 0x1ab, + 0x7, 0x6f, 0x2, 0x2, 0x1ab, 0x1ac, 0x7, 0x63, 0x2, 0x2, 0x1ac, 0x1ad, + 0x7, 0x65, 0x2, 0x2, 0x1ad, 0x1ae, 0x7, 0x74, 0x2, 0x2, 0x1ae, 0x21d, + 0x7, 0x71, 0x2, 0x2, 0x1af, 0x1b0, 0x7, 0x6f, 0x2, 0x2, 0x1b0, 0x1b1, + 0x7, 0x63, 0x2, 0x2, 0x1b1, 0x1b2, 0x7, 0x76, 0x2, 0x2, 0x1b2, 0x1b3, + 0x7, 0x65, 0x2, 0x2, 0x1b3, 0x21d, 0x7, 0x6a, 0x2, 0x2, 0x1b4, 0x1b5, + 0x7, 0x6f, 0x2, 0x2, 0x1b5, 0x1b6, 0x7, 0x77, 0x2, 0x2, 0x1b6, 0x1b7, + 0x7, 0x76, 0x2, 0x2, 0x1b7, 0x1b8, 0x7, 0x63, 0x2, 0x2, 0x1b8, 0x1b9, + 0x7, 0x64, 0x2, 0x2, 0x1b9, 0x1ba, 0x7, 0x6e, 0x2, 0x2, 0x1ba, 0x21d, + 0x7, 0x67, 0x2, 0x2, 0x1bb, 0x1bc, 0x7, 0x70, 0x2, 0x2, 0x1bc, 0x1bd, + 0x7, 0x77, 0x2, 0x2, 0x1bd, 0x1be, 0x7, 0x6e, 0x2, 0x2, 0x1be, 0x21d, + 0x7, 0x6e, 0x2, 0x2, 0x1bf, 0x1c0, 0x7, 0x71, 0x2, 0x2, 0x1c0, 0x21d, + 0x7, 0x68, 0x2, 0x2, 0x1c1, 0x1c2, 0x7, 0x72, 0x2, 0x2, 0x1c2, 0x1c3, + 0x7, 0x63, 0x2, 0x2, 0x1c3, 0x1c4, 0x7, 0x74, 0x2, 0x2, 0x1c4, 0x1c5, + 0x7, 0x76, 0x2, 0x2, 0x1c5, 0x1c6, 0x7, 0x6b, 0x2, 0x2, 0x1c6, 0x1c7, + 0x7, 0x63, 0x2, 0x2, 0x1c7, 0x21d, 0x7, 0x6e, 0x2, 0x2, 0x1c8, 0x1c9, + 0x7, 0x72, 0x2, 0x2, 0x1c9, 0x1ca, 0x7, 0x74, 0x2, 0x2, 0x1ca, 0x1cb, + 0x7, 0x71, 0x2, 0x2, 0x1cb, 0x1cc, 0x7, 0x6f, 0x2, 0x2, 0x1cc, 0x1cd, + 0x7, 0x6b, 0x2, 0x2, 0x1cd, 0x1ce, 0x7, 0x75, 0x2, 0x2, 0x1ce, 0x21d, + 0x7, 0x67, 0x2, 0x2, 0x1cf, 0x1d0, 0x7, 0x74, 0x2, 0x2, 0x1d0, 0x1d1, + 0x7, 0x67, 0x2, 0x2, 0x1d1, 0x1d2, 0x7, 0x68, 0x2, 0x2, 0x1d2, 0x1d3, + 0x7, 0x67, 0x2, 0x2, 0x1d3, 0x1d4, 0x7, 0x74, 0x2, 0x2, 0x1d4, 0x1d5, + 0x7, 0x67, 0x2, 0x2, 0x1d5, 0x1d6, 0x7, 0x70, 0x2, 0x2, 0x1d6, 0x1d7, + 0x7, 0x65, 0x2, 0x2, 0x1d7, 0x21d, 0x7, 0x67, 0x2, 0x2, 0x1d8, 0x1d9, + 0x7, 0x74, 0x2, 0x2, 0x1d9, 0x1da, 0x7, 0x67, 0x2, 0x2, 0x1da, 0x1db, + 0x7, 0x6e, 0x2, 0x2, 0x1db, 0x1dc, 0x7, 0x71, 0x2, 0x2, 0x1dc, 0x1dd, + 0x7, 0x65, 0x2, 0x2, 0x1dd, 0x1de, 0x7, 0x63, 0x2, 0x2, 0x1de, 0x1df, + 0x7, 0x76, 0x2, 0x2, 0x1df, 0x1e0, 0x7, 0x63, 0x2, 0x2, 0x1e0, 0x1e1, + 0x7, 0x64, 0x2, 0x2, 0x1e1, 0x1e2, 0x7, 0x6e, 0x2, 0x2, 0x1e2, 0x21d, + 0x7, 0x67, 0x2, 0x2, 0x1e3, 0x1e4, 0x7, 0x75, 0x2, 0x2, 0x1e4, 0x1e5, + 0x7, 0x67, 0x2, 0x2, 0x1e5, 0x1e6, 0x7, 0x63, 0x2, 0x2, 0x1e6, 0x1e7, + 0x7, 0x6e, 0x2, 0x2, 0x1e7, 0x1e8, 0x7, 0x67, 0x2, 0x2, 0x1e8, 0x21d, + 0x7, 0x66, 0x2, 0x2, 0x1e9, 0x1ea, 0x7, 0x75, 0x2, 0x2, 0x1ea, 0x1eb, + 0x7, 0x6b, 0x2, 0x2, 0x1eb, 0x1ec, 0x7, 0x7c, 0x2, 0x2, 0x1ec, 0x1ed, + 0x7, 0x67, 0x2, 0x2, 0x1ed, 0x1ee, 0x7, 0x71, 0x2, 0x2, 0x1ee, 0x21d, + 0x7, 0x68, 0x2, 0x2, 0x1ef, 0x1f0, 0x7, 0x75, 0x2, 0x2, 0x1f0, 0x1f1, + 0x7, 0x76, 0x2, 0x2, 0x1f1, 0x1f2, 0x7, 0x63, 0x2, 0x2, 0x1f2, 0x1f3, + 0x7, 0x76, 0x2, 0x2, 0x1f3, 0x1f4, 0x7, 0x6b, 0x2, 0x2, 0x1f4, 0x21d, + 0x7, 0x65, 0x2, 0x2, 0x1f5, 0x1f6, 0x7, 0x75, 0x2, 0x2, 0x1f6, 0x1f7, + 0x7, 0x77, 0x2, 0x2, 0x1f7, 0x1f8, 0x7, 0x72, 0x2, 0x2, 0x1f8, 0x1f9, + 0x7, 0x72, 0x2, 0x2, 0x1f9, 0x1fa, 0x7, 0x71, 0x2, 0x2, 0x1fa, 0x1fb, + 0x7, 0x74, 0x2, 0x2, 0x1fb, 0x1fc, 0x7, 0x76, 0x2, 0x2, 0x1fc, 0x21d, + 0x7, 0x75, 0x2, 0x2, 0x1fd, 0x1fe, 0x7, 0x75, 0x2, 0x2, 0x1fe, 0x1ff, + 0x7, 0x79, 0x2, 0x2, 0x1ff, 0x200, 0x7, 0x6b, 0x2, 0x2, 0x200, 0x201, + 0x7, 0x76, 0x2, 0x2, 0x201, 0x202, 0x7, 0x65, 0x2, 0x2, 0x202, 0x21d, + 0x7, 0x6a, 0x2, 0x2, 0x203, 0x204, 0x7, 0x76, 0x2, 0x2, 0x204, 0x205, + 0x7, 0x7b, 0x2, 0x2, 0x205, 0x206, 0x7, 0x72, 0x2, 0x2, 0x206, 0x207, + 0x7, 0x67, 0x2, 0x2, 0x207, 0x208, 0x7, 0x66, 0x2, 0x2, 0x208, 0x209, + 0x7, 0x67, 0x2, 0x2, 0x209, 0x21d, 0x7, 0x68, 0x2, 0x2, 0x20a, 0x20b, + 0x7, 0x76, 0x2, 0x2, 0x20b, 0x20c, 0x7, 0x7b, 0x2, 0x2, 0x20c, 0x20d, + 0x7, 0x72, 0x2, 0x2, 0x20d, 0x20e, 0x7, 0x67, 0x2, 0x2, 0x20e, 0x20f, + 0x7, 0x71, 0x2, 0x2, 0x20f, 0x21d, 0x7, 0x68, 0x2, 0x2, 0x210, 0x211, + 0x7, 0x77, 0x2, 0x2, 0x211, 0x212, 0x7, 0x70, 0x2, 0x2, 0x212, 0x213, + 0x7, 0x65, 0x2, 0x2, 0x213, 0x214, 0x7, 0x6a, 0x2, 0x2, 0x214, 0x215, + 0x7, 0x67, 0x2, 0x2, 0x215, 0x216, 0x7, 0x65, 0x2, 0x2, 0x216, 0x217, + 0x7, 0x6d, 0x2, 0x2, 0x217, 0x218, 0x7, 0x67, 0x2, 0x2, 0x218, 0x21d, + 0x7, 0x66, 0x2, 0x2, 0x219, 0x21a, 0x7, 0x78, 0x2, 0x2, 0x21a, 0x21b, + 0x7, 0x63, 0x2, 0x2, 0x21b, 0x21d, 0x7, 0x74, 0x2, 0x2, 0x21c, 0x166, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x170, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x175, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x179, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x183, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x190, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x195, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x19f, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1a1, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1a7, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1aa, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1af, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1b4, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1bb, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1bf, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1c1, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1c8, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1cf, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1d8, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1e3, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1e9, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1ef, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1f5, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x1fd, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x203, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x20a, + 0x3, 0x2, 0x2, 0x2, 0x21c, 0x210, 0x3, 0x2, 0x2, 0x2, 0x21c, 0x219, + 0x3, 0x2, 0x2, 0x2, 0x21d, 0x7, 0x3, 0x2, 0x2, 0x2, 0x21e, 0x21f, + 0x7, 0x72, 0x2, 0x2, 0x21f, 0x220, 0x7, 0x74, 0x2, 0x2, 0x220, 0x221, + 0x7, 0x63, 0x2, 0x2, 0x221, 0x222, 0x7, 0x69, 0x2, 0x2, 0x222, 0x223, + 0x7, 0x6f, 0x2, 0x2, 0x223, 0x224, 0x7, 0x63, 0x2, 0x2, 0x224, 0x225, + 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x8, 0x3, 0x2, 0x2, 0x226, 0x9, + 0x3, 0x2, 0x2, 0x2, 0x227, 0x228, 0x7, 0x63, 0x2, 0x2, 0x228, 0x229, + 0x7, 0x64, 0x2, 0x2, 0x229, 0x22a, 0x7, 0x75, 0x2, 0x2, 0x22a, 0x22b, + 0x7, 0x76, 0x2, 0x2, 0x22b, 0x22c, 0x7, 0x74, 0x2, 0x2, 0x22c, 0x22d, + 0x7, 0x63, 0x2, 0x2, 0x22d, 0x22e, 0x7, 0x65, 0x2, 0x2, 0x22e, 0x22f, + 0x7, 0x76, 0x2, 0x2, 0x22f, 0xb, 0x3, 0x2, 0x2, 0x2, 0x230, 0x231, + 0x7, 0x63, 0x2, 0x2, 0x231, 0x232, 0x7, 0x70, 0x2, 0x2, 0x232, 0x233, + 0x7, 0x71, 0x2, 0x2, 0x233, 0x234, 0x7, 0x70, 0x2, 0x2, 0x234, 0x235, + 0x7, 0x7b, 0x2, 0x2, 0x235, 0x236, 0x7, 0x6f, 0x2, 0x2, 0x236, 0x237, + 0x7, 0x71, 0x2, 0x2, 0x237, 0x238, 0x7, 0x77, 0x2, 0x2, 0x238, 0x239, + 0x7, 0x75, 0x2, 0x2, 0x239, 0xd, 0x3, 0x2, 0x2, 0x2, 0x23a, 0x23b, + 0x7, 0x63, 0x2, 0x2, 0x23b, 0x23c, 0x7, 0x66, 0x2, 0x2, 0x23c, 0x23d, + 0x7, 0x66, 0x2, 0x2, 0x23d, 0x23e, 0x7, 0x74, 0x2, 0x2, 0x23e, 0x23f, + 0x7, 0x67, 0x2, 0x2, 0x23f, 0x240, 0x7, 0x75, 0x2, 0x2, 0x240, 0x241, + 0x7, 0x75, 0x2, 0x2, 0x241, 0xf, 0x3, 0x2, 0x2, 0x2, 0x242, 0x243, + 0x7, 0x63, 0x2, 0x2, 0x243, 0x244, 0x7, 0x75, 0x2, 0x2, 0x244, 0x11, + 0x3, 0x2, 0x2, 0x2, 0x245, 0x246, 0x7, 0x63, 0x2, 0x2, 0x246, 0x247, + 0x7, 0x75, 0x2, 0x2, 0x247, 0x248, 0x7, 0x75, 0x2, 0x2, 0x248, 0x249, + 0x7, 0x67, 0x2, 0x2, 0x249, 0x24a, 0x7, 0x6f, 0x2, 0x2, 0x24a, 0x24b, + 0x7, 0x64, 0x2, 0x2, 0x24b, 0x24c, 0x7, 0x6e, 0x2, 0x2, 0x24c, 0x24d, + 0x7, 0x7b, 0x2, 0x2, 0x24d, 0x24e, 0x3, 0x2, 0x2, 0x2, 0x24e, 0x24f, + 0x8, 0x8, 0x3, 0x2, 0x24f, 0x13, 0x3, 0x2, 0x2, 0x2, 0x250, 0x251, + 0x7, 0x64, 0x2, 0x2, 0x251, 0x252, 0x7, 0x71, 0x2, 0x2, 0x252, 0x253, + 0x7, 0x71, 0x2, 0x2, 0x253, 0x254, 0x7, 0x6e, 0x2, 0x2, 0x254, 0x15, + 0x3, 0x2, 0x2, 0x2, 0x255, 0x256, 0x7, 0x64, 0x2, 0x2, 0x256, 0x257, + 0x7, 0x74, 0x2, 0x2, 0x257, 0x258, 0x7, 0x67, 0x2, 0x2, 0x258, 0x259, + 0x7, 0x63, 0x2, 0x2, 0x259, 0x25a, 0x7, 0x6d, 0x2, 0x2, 0x25a, 0x17, + 0x3, 0x2, 0x2, 0x2, 0x25b, 0x25c, 0x7, 0x64, 0x2, 0x2, 0x25c, 0x25d, + 0x7, 0x7b, 0x2, 0x2, 0x25d, 0x25e, 0x7, 0x76, 0x2, 0x2, 0x25e, 0x25f, + 0x7, 0x67, 0x2, 0x2, 0x25f, 0x260, 0x7, 0x75, 0x2, 0x2, 0x260, 0x19, + 0x3, 0x2, 0x2, 0x2, 0x261, 0x262, 0x7, 0x65, 0x2, 0x2, 0x262, 0x263, + 0x7, 0x63, 0x2, 0x2, 0x263, 0x264, 0x7, 0x6e, 0x2, 0x2, 0x264, 0x265, + 0x7, 0x6e, 0x2, 0x2, 0x265, 0x266, 0x7, 0x66, 0x2, 0x2, 0x266, 0x267, + 0x7, 0x63, 0x2, 0x2, 0x267, 0x268, 0x7, 0x76, 0x2, 0x2, 0x268, 0x269, + 0x7, 0x63, 0x2, 0x2, 0x269, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x26a, 0x26b, + 0x7, 0x65, 0x2, 0x2, 0x26b, 0x26c, 0x7, 0x63, 0x2, 0x2, 0x26c, 0x26d, + 0x7, 0x76, 0x2, 0x2, 0x26d, 0x26e, 0x7, 0x65, 0x2, 0x2, 0x26e, 0x26f, + 0x7, 0x6a, 0x2, 0x2, 0x26f, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x270, 0x271, + 0x7, 0x65, 0x2, 0x2, 0x271, 0x272, 0x7, 0x71, 0x2, 0x2, 0x272, 0x273, + 0x7, 0x70, 0x2, 0x2, 0x273, 0x274, 0x7, 0x75, 0x2, 0x2, 0x274, 0x275, + 0x7, 0x76, 0x2, 0x2, 0x275, 0x276, 0x7, 0x63, 0x2, 0x2, 0x276, 0x277, + 0x7, 0x70, 0x2, 0x2, 0x277, 0x278, 0x7, 0x76, 0x2, 0x2, 0x278, 0x1f, + 0x3, 0x2, 0x2, 0x2, 0x279, 0x27a, 0x7, 0x65, 0x2, 0x2, 0x27a, 0x27b, + 0x7, 0x71, 0x2, 0x2, 0x27b, 0x27c, 0x7, 0x70, 0x2, 0x2, 0x27c, 0x27d, + 0x7, 0x75, 0x2, 0x2, 0x27d, 0x27e, 0x7, 0x76, 0x2, 0x2, 0x27e, 0x27f, + 0x7, 0x74, 0x2, 0x2, 0x27f, 0x280, 0x7, 0x77, 0x2, 0x2, 0x280, 0x281, + 0x7, 0x65, 0x2, 0x2, 0x281, 0x282, 0x7, 0x76, 0x2, 0x2, 0x282, 0x283, + 0x7, 0x71, 0x2, 0x2, 0x283, 0x284, 0x7, 0x74, 0x2, 0x2, 0x284, 0x21, + 0x3, 0x2, 0x2, 0x2, 0x285, 0x286, 0x7, 0x65, 0x2, 0x2, 0x286, 0x287, + 0x7, 0x71, 0x2, 0x2, 0x287, 0x288, 0x7, 0x70, 0x2, 0x2, 0x288, 0x289, + 0x7, 0x76, 0x2, 0x2, 0x289, 0x28a, 0x7, 0x6b, 0x2, 0x2, 0x28a, 0x28b, + 0x7, 0x70, 0x2, 0x2, 0x28b, 0x28c, 0x7, 0x77, 0x2, 0x2, 0x28c, 0x28d, + 0x7, 0x67, 0x2, 0x2, 0x28d, 0x23, 0x3, 0x2, 0x2, 0x2, 0x28e, 0x28f, + 0x7, 0x65, 0x2, 0x2, 0x28f, 0x290, 0x7, 0x71, 0x2, 0x2, 0x290, 0x291, + 0x7, 0x70, 0x2, 0x2, 0x291, 0x292, 0x7, 0x76, 0x2, 0x2, 0x292, 0x293, + 0x7, 0x74, 0x2, 0x2, 0x293, 0x294, 0x7, 0x63, 0x2, 0x2, 0x294, 0x295, + 0x7, 0x65, 0x2, 0x2, 0x295, 0x296, 0x7, 0x76, 0x2, 0x2, 0x296, 0x25, + 0x3, 0x2, 0x2, 0x2, 0x297, 0x298, 0x7, 0x66, 0x2, 0x2, 0x298, 0x299, + 0x7, 0x67, 0x2, 0x2, 0x299, 0x29a, 0x7, 0x6e, 0x2, 0x2, 0x29a, 0x29b, + 0x7, 0x67, 0x2, 0x2, 0x29b, 0x29c, 0x7, 0x76, 0x2, 0x2, 0x29c, 0x29d, + 0x7, 0x67, 0x2, 0x2, 0x29d, 0x27, 0x3, 0x2, 0x2, 0x2, 0x29e, 0x29f, + 0x7, 0x66, 0x2, 0x2, 0x29f, 0x2a0, 0x7, 0x71, 0x2, 0x2, 0x2a0, 0x29, + 0x3, 0x2, 0x2, 0x2, 0x2a1, 0x2a2, 0x7, 0x67, 0x2, 0x2, 0x2a2, 0x2a3, + 0x7, 0x6e, 0x2, 0x2, 0x2a3, 0x2a4, 0x7, 0x75, 0x2, 0x2, 0x2a4, 0x2a5, + 0x7, 0x67, 0x2, 0x2, 0x2a5, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x2a6, 0x2a7, + 0x7, 0x67, 0x2, 0x2, 0x2a7, 0x2a8, 0x7, 0x6f, 0x2, 0x2, 0x2a8, 0x2a9, + 0x7, 0x6b, 0x2, 0x2, 0x2a9, 0x2aa, 0x7, 0x76, 0x2, 0x2, 0x2aa, 0x2d, + 0x3, 0x2, 0x2, 0x2, 0x2ab, 0x2ac, 0x7, 0x67, 0x2, 0x2, 0x2ac, 0x2ad, + 0x7, 0x70, 0x2, 0x2, 0x2ad, 0x2ae, 0x7, 0x77, 0x2, 0x2, 0x2ae, 0x2af, + 0x7, 0x6f, 0x2, 0x2, 0x2af, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x2b0, 0x2b1, + 0x7, 0x67, 0x2, 0x2, 0x2b1, 0x2b2, 0x7, 0x78, 0x2, 0x2, 0x2b2, 0x2b3, + 0x7, 0x67, 0x2, 0x2, 0x2b3, 0x2b4, 0x7, 0x70, 0x2, 0x2, 0x2b4, 0x2b5, + 0x7, 0x76, 0x2, 0x2, 0x2b5, 0x31, 0x3, 0x2, 0x2, 0x2, 0x2b6, 0x2b7, + 0x7, 0x67, 0x2, 0x2, 0x2b7, 0x2b8, 0x7, 0x7a, 0x2, 0x2, 0x2b8, 0x2b9, + 0x7, 0x76, 0x2, 0x2, 0x2b9, 0x2ba, 0x7, 0x67, 0x2, 0x2, 0x2ba, 0x2bb, + 0x7, 0x74, 0x2, 0x2, 0x2bb, 0x2bc, 0x7, 0x70, 0x2, 0x2, 0x2bc, 0x2bd, + 0x7, 0x63, 0x2, 0x2, 0x2bd, 0x2be, 0x7, 0x6e, 0x2, 0x2, 0x2be, 0x33, + 0x3, 0x2, 0x2, 0x2, 0x2bf, 0x2c0, 0x7, 0x68, 0x2, 0x2, 0x2c0, 0x2c1, + 0x7, 0x63, 0x2, 0x2, 0x2c1, 0x2c2, 0x7, 0x6e, 0x2, 0x2, 0x2c2, 0x2c3, + 0x7, 0x6e, 0x2, 0x2, 0x2c3, 0x2c4, 0x7, 0x64, 0x2, 0x2, 0x2c4, 0x2c5, + 0x7, 0x63, 0x2, 0x2, 0x2c5, 0x2c6, 0x7, 0x65, 0x2, 0x2, 0x2c6, 0x2c7, + 0x7, 0x6d, 0x2, 0x2, 0x2c7, 0x35, 0x3, 0x2, 0x2, 0x2, 0x2c8, 0x2c9, + 0x7, 0x68, 0x2, 0x2, 0x2c9, 0x2ca, 0x7, 0x63, 0x2, 0x2, 0x2ca, 0x2cb, + 0x7, 0x6e, 0x2, 0x2, 0x2cb, 0x2cc, 0x7, 0x75, 0x2, 0x2, 0x2cc, 0x2cd, + 0x7, 0x67, 0x2, 0x2, 0x2cd, 0x37, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2cf, + 0x7, 0x68, 0x2, 0x2, 0x2cf, 0x2d0, 0x7, 0x6b, 0x2, 0x2, 0x2d0, 0x2d1, + 0x7, 0x7a, 0x2, 0x2, 0x2d1, 0x2d2, 0x7, 0x67, 0x2, 0x2, 0x2d2, 0x2e5, + 0x7, 0x66, 0x2, 0x2, 0x2d3, 0x2d4, 0x7, 0x68, 0x2, 0x2, 0x2d4, 0x2d5, + 0x7, 0x6b, 0x2, 0x2, 0x2d5, 0x2d6, 0x7, 0x7a, 0x2, 0x2, 0x2d6, 0x2d7, + 0x7, 0x67, 0x2, 0x2, 0x2d7, 0x2d8, 0x7, 0x66, 0x2, 0x2, 0x2d8, 0x2da, + 0x3, 0x2, 0x2, 0x2, 0x2d9, 0x2db, 0x9, 0x2, 0x2, 0x2, 0x2da, 0x2d9, + 0x3, 0x2, 0x2, 0x2, 0x2db, 0x2dc, 0x3, 0x2, 0x2, 0x2, 0x2dc, 0x2da, + 0x3, 0x2, 0x2, 0x2, 0x2dc, 0x2dd, 0x3, 0x2, 0x2, 0x2, 0x2dd, 0x2de, + 0x3, 0x2, 0x2, 0x2, 0x2de, 0x2e0, 0x7, 0x7a, 0x2, 0x2, 0x2df, 0x2e1, + 0x9, 0x2, 0x2, 0x2, 0x2e0, 0x2df, 0x3, 0x2, 0x2, 0x2, 0x2e1, 0x2e2, + 0x3, 0x2, 0x2, 0x2, 0x2e2, 0x2e0, 0x3, 0x2, 0x2, 0x2, 0x2e2, 0x2e3, + 0x3, 0x2, 0x2, 0x2, 0x2e3, 0x2e5, 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2ce, + 0x3, 0x2, 0x2, 0x2, 0x2e4, 0x2d3, 0x3, 0x2, 0x2, 0x2, 0x2e5, 0x39, + 0x3, 0x2, 0x2, 0x2, 0x2e6, 0x2e7, 0x7, 0x68, 0x2, 0x2, 0x2e7, 0x2e8, + 0x7, 0x74, 0x2, 0x2, 0x2e8, 0x2e9, 0x7, 0x71, 0x2, 0x2, 0x2e9, 0x2ea, + 0x7, 0x6f, 0x2, 0x2, 0x2ea, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x2eb, 0x2ec, + 0x7, 0x64, 0x2, 0x2, 0x2ec, 0x2ed, 0x7, 0x7b, 0x2, 0x2, 0x2ed, 0x2ee, + 0x7, 0x76, 0x2, 0x2, 0x2ee, 0x3c7, 0x7, 0x67, 0x2, 0x2, 0x2ef, 0x2f0, + 0x7, 0x64, 0x2, 0x2, 0x2f0, 0x2f1, 0x7, 0x7b, 0x2, 0x2, 0x2f1, 0x2f2, + 0x7, 0x76, 0x2, 0x2, 0x2f2, 0x2f3, 0x7, 0x67, 0x2, 0x2, 0x2f3, 0x2f4, + 0x7, 0x75, 0x2, 0x2, 0x2f4, 0x3c7, 0x7, 0x33, 0x2, 0x2, 0x2f5, 0x2f6, + 0x7, 0x64, 0x2, 0x2, 0x2f6, 0x2f7, 0x7, 0x7b, 0x2, 0x2, 0x2f7, 0x2f8, + 0x7, 0x76, 0x2, 0x2, 0x2f8, 0x2f9, 0x7, 0x67, 0x2, 0x2, 0x2f9, 0x2fa, + 0x7, 0x75, 0x2, 0x2, 0x2fa, 0x3c7, 0x7, 0x34, 0x2, 0x2, 0x2fb, 0x2fc, + 0x7, 0x64, 0x2, 0x2, 0x2fc, 0x2fd, 0x7, 0x7b, 0x2, 0x2, 0x2fd, 0x2fe, + 0x7, 0x76, 0x2, 0x2, 0x2fe, 0x2ff, 0x7, 0x67, 0x2, 0x2, 0x2ff, 0x300, + 0x7, 0x75, 0x2, 0x2, 0x300, 0x3c7, 0x7, 0x35, 0x2, 0x2, 0x301, 0x302, + 0x7, 0x64, 0x2, 0x2, 0x302, 0x303, 0x7, 0x7b, 0x2, 0x2, 0x303, 0x304, + 0x7, 0x76, 0x2, 0x2, 0x304, 0x305, 0x7, 0x67, 0x2, 0x2, 0x305, 0x306, + 0x7, 0x75, 0x2, 0x2, 0x306, 0x3c7, 0x7, 0x36, 0x2, 0x2, 0x307, 0x308, + 0x7, 0x64, 0x2, 0x2, 0x308, 0x309, 0x7, 0x7b, 0x2, 0x2, 0x309, 0x30a, + 0x7, 0x76, 0x2, 0x2, 0x30a, 0x30b, 0x7, 0x67, 0x2, 0x2, 0x30b, 0x30c, + 0x7, 0x75, 0x2, 0x2, 0x30c, 0x3c7, 0x7, 0x37, 0x2, 0x2, 0x30d, 0x30e, + 0x7, 0x64, 0x2, 0x2, 0x30e, 0x30f, 0x7, 0x7b, 0x2, 0x2, 0x30f, 0x310, + 0x7, 0x76, 0x2, 0x2, 0x310, 0x311, 0x7, 0x67, 0x2, 0x2, 0x311, 0x312, + 0x7, 0x75, 0x2, 0x2, 0x312, 0x3c7, 0x7, 0x38, 0x2, 0x2, 0x313, 0x314, + 0x7, 0x64, 0x2, 0x2, 0x314, 0x315, 0x7, 0x7b, 0x2, 0x2, 0x315, 0x316, + 0x7, 0x76, 0x2, 0x2, 0x316, 0x317, 0x7, 0x67, 0x2, 0x2, 0x317, 0x318, + 0x7, 0x75, 0x2, 0x2, 0x318, 0x3c7, 0x7, 0x39, 0x2, 0x2, 0x319, 0x31a, + 0x7, 0x64, 0x2, 0x2, 0x31a, 0x31b, 0x7, 0x7b, 0x2, 0x2, 0x31b, 0x31c, + 0x7, 0x76, 0x2, 0x2, 0x31c, 0x31d, 0x7, 0x67, 0x2, 0x2, 0x31d, 0x31e, + 0x7, 0x75, 0x2, 0x2, 0x31e, 0x3c7, 0x7, 0x3a, 0x2, 0x2, 0x31f, 0x320, + 0x7, 0x64, 0x2, 0x2, 0x320, 0x321, 0x7, 0x7b, 0x2, 0x2, 0x321, 0x322, + 0x7, 0x76, 0x2, 0x2, 0x322, 0x323, 0x7, 0x67, 0x2, 0x2, 0x323, 0x324, + 0x7, 0x75, 0x2, 0x2, 0x324, 0x3c7, 0x7, 0x3b, 0x2, 0x2, 0x325, 0x326, + 0x7, 0x64, 0x2, 0x2, 0x326, 0x327, 0x7, 0x7b, 0x2, 0x2, 0x327, 0x328, + 0x7, 0x76, 0x2, 0x2, 0x328, 0x329, 0x7, 0x67, 0x2, 0x2, 0x329, 0x32a, + 0x7, 0x75, 0x2, 0x2, 0x32a, 0x32b, 0x7, 0x33, 0x2, 0x2, 0x32b, 0x3c7, + 0x7, 0x32, 0x2, 0x2, 0x32c, 0x32d, 0x7, 0x64, 0x2, 0x2, 0x32d, 0x32e, + 0x7, 0x7b, 0x2, 0x2, 0x32e, 0x32f, 0x7, 0x76, 0x2, 0x2, 0x32f, 0x330, + 0x7, 0x67, 0x2, 0x2, 0x330, 0x331, 0x7, 0x75, 0x2, 0x2, 0x331, 0x332, + 0x7, 0x33, 0x2, 0x2, 0x332, 0x3c7, 0x7, 0x33, 0x2, 0x2, 0x333, 0x334, + 0x7, 0x64, 0x2, 0x2, 0x334, 0x335, 0x7, 0x7b, 0x2, 0x2, 0x335, 0x336, + 0x7, 0x76, 0x2, 0x2, 0x336, 0x337, 0x7, 0x67, 0x2, 0x2, 0x337, 0x338, + 0x7, 0x75, 0x2, 0x2, 0x338, 0x339, 0x7, 0x33, 0x2, 0x2, 0x339, 0x3c7, + 0x7, 0x34, 0x2, 0x2, 0x33a, 0x33b, 0x7, 0x64, 0x2, 0x2, 0x33b, 0x33c, + 0x7, 0x7b, 0x2, 0x2, 0x33c, 0x33d, 0x7, 0x76, 0x2, 0x2, 0x33d, 0x33e, + 0x7, 0x67, 0x2, 0x2, 0x33e, 0x33f, 0x7, 0x75, 0x2, 0x2, 0x33f, 0x340, + 0x7, 0x33, 0x2, 0x2, 0x340, 0x3c7, 0x7, 0x35, 0x2, 0x2, 0x341, 0x342, + 0x7, 0x64, 0x2, 0x2, 0x342, 0x343, 0x7, 0x7b, 0x2, 0x2, 0x343, 0x344, + 0x7, 0x76, 0x2, 0x2, 0x344, 0x345, 0x7, 0x67, 0x2, 0x2, 0x345, 0x346, + 0x7, 0x75, 0x2, 0x2, 0x346, 0x347, 0x7, 0x33, 0x2, 0x2, 0x347, 0x3c7, + 0x7, 0x36, 0x2, 0x2, 0x348, 0x349, 0x7, 0x64, 0x2, 0x2, 0x349, 0x34a, + 0x7, 0x7b, 0x2, 0x2, 0x34a, 0x34b, 0x7, 0x76, 0x2, 0x2, 0x34b, 0x34c, + 0x7, 0x67, 0x2, 0x2, 0x34c, 0x34d, 0x7, 0x75, 0x2, 0x2, 0x34d, 0x34e, + 0x7, 0x33, 0x2, 0x2, 0x34e, 0x3c7, 0x7, 0x37, 0x2, 0x2, 0x34f, 0x350, + 0x7, 0x64, 0x2, 0x2, 0x350, 0x351, 0x7, 0x7b, 0x2, 0x2, 0x351, 0x352, + 0x7, 0x76, 0x2, 0x2, 0x352, 0x353, 0x7, 0x67, 0x2, 0x2, 0x353, 0x354, + 0x7, 0x75, 0x2, 0x2, 0x354, 0x355, 0x7, 0x33, 0x2, 0x2, 0x355, 0x3c7, + 0x7, 0x38, 0x2, 0x2, 0x356, 0x357, 0x7, 0x64, 0x2, 0x2, 0x357, 0x358, + 0x7, 0x7b, 0x2, 0x2, 0x358, 0x359, 0x7, 0x76, 0x2, 0x2, 0x359, 0x35a, + 0x7, 0x67, 0x2, 0x2, 0x35a, 0x35b, 0x7, 0x75, 0x2, 0x2, 0x35b, 0x35c, + 0x7, 0x33, 0x2, 0x2, 0x35c, 0x3c7, 0x7, 0x39, 0x2, 0x2, 0x35d, 0x35e, + 0x7, 0x64, 0x2, 0x2, 0x35e, 0x35f, 0x7, 0x7b, 0x2, 0x2, 0x35f, 0x360, + 0x7, 0x76, 0x2, 0x2, 0x360, 0x361, 0x7, 0x67, 0x2, 0x2, 0x361, 0x362, + 0x7, 0x75, 0x2, 0x2, 0x362, 0x363, 0x7, 0x33, 0x2, 0x2, 0x363, 0x3c7, + 0x7, 0x3a, 0x2, 0x2, 0x364, 0x365, 0x7, 0x64, 0x2, 0x2, 0x365, 0x366, + 0x7, 0x7b, 0x2, 0x2, 0x366, 0x367, 0x7, 0x76, 0x2, 0x2, 0x367, 0x368, + 0x7, 0x67, 0x2, 0x2, 0x368, 0x369, 0x7, 0x75, 0x2, 0x2, 0x369, 0x36a, + 0x7, 0x33, 0x2, 0x2, 0x36a, 0x3c7, 0x7, 0x3b, 0x2, 0x2, 0x36b, 0x36c, + 0x7, 0x64, 0x2, 0x2, 0x36c, 0x36d, 0x7, 0x7b, 0x2, 0x2, 0x36d, 0x36e, + 0x7, 0x76, 0x2, 0x2, 0x36e, 0x36f, 0x7, 0x67, 0x2, 0x2, 0x36f, 0x370, + 0x7, 0x75, 0x2, 0x2, 0x370, 0x371, 0x7, 0x34, 0x2, 0x2, 0x371, 0x3c7, + 0x7, 0x32, 0x2, 0x2, 0x372, 0x373, 0x7, 0x64, 0x2, 0x2, 0x373, 0x374, + 0x7, 0x7b, 0x2, 0x2, 0x374, 0x375, 0x7, 0x76, 0x2, 0x2, 0x375, 0x376, + 0x7, 0x67, 0x2, 0x2, 0x376, 0x377, 0x7, 0x75, 0x2, 0x2, 0x377, 0x378, + 0x7, 0x34, 0x2, 0x2, 0x378, 0x3c7, 0x7, 0x33, 0x2, 0x2, 0x379, 0x37a, + 0x7, 0x64, 0x2, 0x2, 0x37a, 0x37b, 0x7, 0x7b, 0x2, 0x2, 0x37b, 0x37c, + 0x7, 0x76, 0x2, 0x2, 0x37c, 0x37d, 0x7, 0x67, 0x2, 0x2, 0x37d, 0x37e, + 0x7, 0x75, 0x2, 0x2, 0x37e, 0x37f, 0x7, 0x34, 0x2, 0x2, 0x37f, 0x3c7, + 0x7, 0x34, 0x2, 0x2, 0x380, 0x381, 0x7, 0x64, 0x2, 0x2, 0x381, 0x382, + 0x7, 0x7b, 0x2, 0x2, 0x382, 0x383, 0x7, 0x76, 0x2, 0x2, 0x383, 0x384, + 0x7, 0x67, 0x2, 0x2, 0x384, 0x385, 0x7, 0x75, 0x2, 0x2, 0x385, 0x386, + 0x7, 0x34, 0x2, 0x2, 0x386, 0x3c7, 0x7, 0x35, 0x2, 0x2, 0x387, 0x388, + 0x7, 0x64, 0x2, 0x2, 0x388, 0x389, 0x7, 0x7b, 0x2, 0x2, 0x389, 0x38a, + 0x7, 0x76, 0x2, 0x2, 0x38a, 0x38b, 0x7, 0x67, 0x2, 0x2, 0x38b, 0x38c, + 0x7, 0x75, 0x2, 0x2, 0x38c, 0x38d, 0x7, 0x34, 0x2, 0x2, 0x38d, 0x3c7, + 0x7, 0x36, 0x2, 0x2, 0x38e, 0x38f, 0x7, 0x64, 0x2, 0x2, 0x38f, 0x390, + 0x7, 0x7b, 0x2, 0x2, 0x390, 0x391, 0x7, 0x76, 0x2, 0x2, 0x391, 0x392, + 0x7, 0x67, 0x2, 0x2, 0x392, 0x393, 0x7, 0x75, 0x2, 0x2, 0x393, 0x394, + 0x7, 0x34, 0x2, 0x2, 0x394, 0x3c7, 0x7, 0x37, 0x2, 0x2, 0x395, 0x396, + 0x7, 0x64, 0x2, 0x2, 0x396, 0x397, 0x7, 0x7b, 0x2, 0x2, 0x397, 0x398, + 0x7, 0x76, 0x2, 0x2, 0x398, 0x399, 0x7, 0x67, 0x2, 0x2, 0x399, 0x39a, + 0x7, 0x75, 0x2, 0x2, 0x39a, 0x39b, 0x7, 0x34, 0x2, 0x2, 0x39b, 0x3c7, + 0x7, 0x38, 0x2, 0x2, 0x39c, 0x39d, 0x7, 0x64, 0x2, 0x2, 0x39d, 0x39e, + 0x7, 0x7b, 0x2, 0x2, 0x39e, 0x39f, 0x7, 0x76, 0x2, 0x2, 0x39f, 0x3a0, + 0x7, 0x67, 0x2, 0x2, 0x3a0, 0x3a1, 0x7, 0x75, 0x2, 0x2, 0x3a1, 0x3a2, + 0x7, 0x34, 0x2, 0x2, 0x3a2, 0x3c7, 0x7, 0x39, 0x2, 0x2, 0x3a3, 0x3a4, + 0x7, 0x64, 0x2, 0x2, 0x3a4, 0x3a5, 0x7, 0x7b, 0x2, 0x2, 0x3a5, 0x3a6, + 0x7, 0x76, 0x2, 0x2, 0x3a6, 0x3a7, 0x7, 0x67, 0x2, 0x2, 0x3a7, 0x3a8, + 0x7, 0x75, 0x2, 0x2, 0x3a8, 0x3a9, 0x7, 0x34, 0x2, 0x2, 0x3a9, 0x3c7, + 0x7, 0x3a, 0x2, 0x2, 0x3aa, 0x3ab, 0x7, 0x64, 0x2, 0x2, 0x3ab, 0x3ac, + 0x7, 0x7b, 0x2, 0x2, 0x3ac, 0x3ad, 0x7, 0x76, 0x2, 0x2, 0x3ad, 0x3ae, + 0x7, 0x67, 0x2, 0x2, 0x3ae, 0x3af, 0x7, 0x75, 0x2, 0x2, 0x3af, 0x3b0, + 0x7, 0x34, 0x2, 0x2, 0x3b0, 0x3c7, 0x7, 0x3b, 0x2, 0x2, 0x3b1, 0x3b2, + 0x7, 0x64, 0x2, 0x2, 0x3b2, 0x3b3, 0x7, 0x7b, 0x2, 0x2, 0x3b3, 0x3b4, + 0x7, 0x76, 0x2, 0x2, 0x3b4, 0x3b5, 0x7, 0x67, 0x2, 0x2, 0x3b5, 0x3b6, + 0x7, 0x75, 0x2, 0x2, 0x3b6, 0x3b7, 0x7, 0x35, 0x2, 0x2, 0x3b7, 0x3c7, + 0x7, 0x32, 0x2, 0x2, 0x3b8, 0x3b9, 0x7, 0x64, 0x2, 0x2, 0x3b9, 0x3ba, + 0x7, 0x7b, 0x2, 0x2, 0x3ba, 0x3bb, 0x7, 0x76, 0x2, 0x2, 0x3bb, 0x3bc, + 0x7, 0x67, 0x2, 0x2, 0x3bc, 0x3bd, 0x7, 0x75, 0x2, 0x2, 0x3bd, 0x3be, + 0x7, 0x35, 0x2, 0x2, 0x3be, 0x3c7, 0x7, 0x33, 0x2, 0x2, 0x3bf, 0x3c0, + 0x7, 0x64, 0x2, 0x2, 0x3c0, 0x3c1, 0x7, 0x7b, 0x2, 0x2, 0x3c1, 0x3c2, + 0x7, 0x76, 0x2, 0x2, 0x3c2, 0x3c3, 0x7, 0x67, 0x2, 0x2, 0x3c3, 0x3c4, + 0x7, 0x75, 0x2, 0x2, 0x3c4, 0x3c5, 0x7, 0x35, 0x2, 0x2, 0x3c5, 0x3c7, + 0x7, 0x34, 0x2, 0x2, 0x3c6, 0x2eb, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x2ef, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x2f5, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x2fb, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x301, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x307, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x30d, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x313, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x319, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x31f, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x325, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x32c, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x333, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x33a, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x341, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x348, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x356, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x35d, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x364, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x36b, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x372, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x379, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x380, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x387, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x38e, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x395, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x39c, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3a3, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3aa, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3b1, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3b8, + 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3bf, 0x3, 0x2, 0x2, 0x2, 0x3c7, 0x3d, + 0x3, 0x2, 0x2, 0x2, 0x3c8, 0x3c9, 0x7, 0x68, 0x2, 0x2, 0x3c9, 0x3ca, + 0x7, 0x71, 0x2, 0x2, 0x3ca, 0x3cb, 0x7, 0x74, 0x2, 0x2, 0x3cb, 0x3f, + 0x3, 0x2, 0x2, 0x2, 0x3cc, 0x3cd, 0x7, 0x68, 0x2, 0x2, 0x3cd, 0x3ce, + 0x7, 0x77, 0x2, 0x2, 0x3ce, 0x3cf, 0x7, 0x70, 0x2, 0x2, 0x3cf, 0x3d0, + 0x7, 0x65, 0x2, 0x2, 0x3d0, 0x3d1, 0x7, 0x76, 0x2, 0x2, 0x3d1, 0x3d2, + 0x7, 0x6b, 0x2, 0x2, 0x3d2, 0x3d3, 0x7, 0x71, 0x2, 0x2, 0x3d3, 0x3d4, + 0x7, 0x70, 0x2, 0x2, 0x3d4, 0x41, 0x3, 0x2, 0x2, 0x2, 0x3d5, 0x3d6, + 0x7, 0x6a, 0x2, 0x2, 0x3d6, 0x3d7, 0x7, 0x67, 0x2, 0x2, 0x3d7, 0x3d8, + 0x7, 0x7a, 0x2, 0x2, 0x3d8, 0x43, 0x3, 0x2, 0x2, 0x2, 0x3d9, 0x3da, + 0x7, 0x6b, 0x2, 0x2, 0x3da, 0x3db, 0x7, 0x68, 0x2, 0x2, 0x3db, 0x45, + 0x3, 0x2, 0x2, 0x2, 0x3dc, 0x3dd, 0x7, 0x6b, 0x2, 0x2, 0x3dd, 0x3de, + 0x7, 0x6f, 0x2, 0x2, 0x3de, 0x3df, 0x7, 0x6f, 0x2, 0x2, 0x3df, 0x3e0, + 0x7, 0x77, 0x2, 0x2, 0x3e0, 0x3e1, 0x7, 0x76, 0x2, 0x2, 0x3e1, 0x3e2, + 0x7, 0x63, 0x2, 0x2, 0x3e2, 0x3e3, 0x7, 0x64, 0x2, 0x2, 0x3e3, 0x3e4, + 0x7, 0x6e, 0x2, 0x2, 0x3e4, 0x3e5, 0x7, 0x67, 0x2, 0x2, 0x3e5, 0x47, + 0x3, 0x2, 0x2, 0x2, 0x3e6, 0x3e7, 0x7, 0x6b, 0x2, 0x2, 0x3e7, 0x3e8, + 0x7, 0x6f, 0x2, 0x2, 0x3e8, 0x3e9, 0x7, 0x72, 0x2, 0x2, 0x3e9, 0x3ea, + 0x7, 0x71, 0x2, 0x2, 0x3ea, 0x3eb, 0x7, 0x74, 0x2, 0x2, 0x3eb, 0x3ec, + 0x7, 0x76, 0x2, 0x2, 0x3ec, 0x49, 0x3, 0x2, 0x2, 0x2, 0x3ed, 0x3ee, + 0x7, 0x6b, 0x2, 0x2, 0x3ee, 0x3ef, 0x7, 0x70, 0x2, 0x2, 0x3ef, 0x3f0, + 0x7, 0x66, 0x2, 0x2, 0x3f0, 0x3f1, 0x7, 0x67, 0x2, 0x2, 0x3f1, 0x3f2, + 0x7, 0x7a, 0x2, 0x2, 0x3f2, 0x3f3, 0x7, 0x67, 0x2, 0x2, 0x3f3, 0x3f4, + 0x7, 0x66, 0x2, 0x2, 0x3f4, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x3f5, 0x3f6, + 0x7, 0x6b, 0x2, 0x2, 0x3f6, 0x3f7, 0x7, 0x70, 0x2, 0x2, 0x3f7, 0x3f8, + 0x7, 0x76, 0x2, 0x2, 0x3f8, 0x3f9, 0x7, 0x67, 0x2, 0x2, 0x3f9, 0x3fa, + 0x7, 0x74, 0x2, 0x2, 0x3fa, 0x3fb, 0x7, 0x68, 0x2, 0x2, 0x3fb, 0x3fc, + 0x7, 0x63, 0x2, 0x2, 0x3fc, 0x3fd, 0x7, 0x65, 0x2, 0x2, 0x3fd, 0x3fe, + 0x7, 0x67, 0x2, 0x2, 0x3fe, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x3ff, 0x400, + 0x7, 0x6b, 0x2, 0x2, 0x400, 0x401, 0x7, 0x70, 0x2, 0x2, 0x401, 0x402, + 0x7, 0x76, 0x2, 0x2, 0x402, 0x403, 0x7, 0x67, 0x2, 0x2, 0x403, 0x404, + 0x7, 0x74, 0x2, 0x2, 0x404, 0x405, 0x7, 0x70, 0x2, 0x2, 0x405, 0x406, + 0x7, 0x63, 0x2, 0x2, 0x406, 0x407, 0x7, 0x6e, 0x2, 0x2, 0x407, 0x4f, + 0x3, 0x2, 0x2, 0x2, 0x408, 0x409, 0x7, 0x6b, 0x2, 0x2, 0x409, 0x40a, + 0x7, 0x75, 0x2, 0x2, 0x40a, 0x51, 0x3, 0x2, 0x2, 0x2, 0x40b, 0x40c, + 0x7, 0x6e, 0x2, 0x2, 0x40c, 0x40d, 0x7, 0x6b, 0x2, 0x2, 0x40d, 0x40e, + 0x7, 0x64, 0x2, 0x2, 0x40e, 0x40f, 0x7, 0x74, 0x2, 0x2, 0x40f, 0x410, + 0x7, 0x63, 0x2, 0x2, 0x410, 0x411, 0x7, 0x74, 0x2, 0x2, 0x411, 0x412, + 0x7, 0x7b, 0x2, 0x2, 0x412, 0x53, 0x3, 0x2, 0x2, 0x2, 0x413, 0x414, + 0x7, 0x6f, 0x2, 0x2, 0x414, 0x415, 0x7, 0x63, 0x2, 0x2, 0x415, 0x416, + 0x7, 0x72, 0x2, 0x2, 0x416, 0x417, 0x7, 0x72, 0x2, 0x2, 0x417, 0x418, + 0x7, 0x6b, 0x2, 0x2, 0x418, 0x419, 0x7, 0x70, 0x2, 0x2, 0x419, 0x41a, + 0x7, 0x69, 0x2, 0x2, 0x41a, 0x55, 0x3, 0x2, 0x2, 0x2, 0x41b, 0x41c, + 0x7, 0x6f, 0x2, 0x2, 0x41c, 0x41d, 0x7, 0x67, 0x2, 0x2, 0x41d, 0x41e, + 0x7, 0x6f, 0x2, 0x2, 0x41e, 0x41f, 0x7, 0x71, 0x2, 0x2, 0x41f, 0x420, + 0x7, 0x74, 0x2, 0x2, 0x420, 0x421, 0x7, 0x7b, 0x2, 0x2, 0x421, 0x57, + 0x3, 0x2, 0x2, 0x2, 0x422, 0x423, 0x7, 0x6f, 0x2, 0x2, 0x423, 0x424, + 0x7, 0x71, 0x2, 0x2, 0x424, 0x425, 0x7, 0x66, 0x2, 0x2, 0x425, 0x426, + 0x7, 0x6b, 0x2, 0x2, 0x426, 0x427, 0x7, 0x68, 0x2, 0x2, 0x427, 0x428, + 0x7, 0x6b, 0x2, 0x2, 0x428, 0x429, 0x7, 0x67, 0x2, 0x2, 0x429, 0x42a, + 0x7, 0x74, 0x2, 0x2, 0x42a, 0x59, 0x3, 0x2, 0x2, 0x2, 0x42b, 0x42c, + 0x7, 0x70, 0x2, 0x2, 0x42c, 0x42d, 0x7, 0x67, 0x2, 0x2, 0x42d, 0x42e, + 0x7, 0x79, 0x2, 0x2, 0x42e, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x42f, 0x430, + 0x7, 0x79, 0x2, 0x2, 0x430, 0x431, 0x7, 0x67, 0x2, 0x2, 0x431, 0x45d, + 0x7, 0x6b, 0x2, 0x2, 0x432, 0x433, 0x7, 0x69, 0x2, 0x2, 0x433, 0x434, + 0x7, 0x79, 0x2, 0x2, 0x434, 0x435, 0x7, 0x67, 0x2, 0x2, 0x435, 0x45d, + 0x7, 0x6b, 0x2, 0x2, 0x436, 0x437, 0x7, 0x67, 0x2, 0x2, 0x437, 0x438, + 0x7, 0x76, 0x2, 0x2, 0x438, 0x439, 0x7, 0x6a, 0x2, 0x2, 0x439, 0x43a, + 0x7, 0x67, 0x2, 0x2, 0x43a, 0x45d, 0x7, 0x74, 0x2, 0x2, 0x43b, 0x43c, + 0x7, 0x75, 0x2, 0x2, 0x43c, 0x43d, 0x7, 0x67, 0x2, 0x2, 0x43d, 0x43e, + 0x7, 0x65, 0x2, 0x2, 0x43e, 0x43f, 0x7, 0x71, 0x2, 0x2, 0x43f, 0x440, + 0x7, 0x70, 0x2, 0x2, 0x440, 0x441, 0x7, 0x66, 0x2, 0x2, 0x441, 0x45d, + 0x7, 0x75, 0x2, 0x2, 0x442, 0x443, 0x7, 0x6f, 0x2, 0x2, 0x443, 0x444, + 0x7, 0x6b, 0x2, 0x2, 0x444, 0x445, 0x7, 0x70, 0x2, 0x2, 0x445, 0x446, + 0x7, 0x77, 0x2, 0x2, 0x446, 0x447, 0x7, 0x76, 0x2, 0x2, 0x447, 0x448, + 0x7, 0x67, 0x2, 0x2, 0x448, 0x45d, 0x7, 0x75, 0x2, 0x2, 0x449, 0x44a, + 0x7, 0x6a, 0x2, 0x2, 0x44a, 0x44b, 0x7, 0x71, 0x2, 0x2, 0x44b, 0x44c, + 0x7, 0x77, 0x2, 0x2, 0x44c, 0x44d, 0x7, 0x74, 0x2, 0x2, 0x44d, 0x45d, + 0x7, 0x75, 0x2, 0x2, 0x44e, 0x44f, 0x7, 0x66, 0x2, 0x2, 0x44f, 0x450, + 0x7, 0x63, 0x2, 0x2, 0x450, 0x451, 0x7, 0x7b, 0x2, 0x2, 0x451, 0x45d, + 0x7, 0x75, 0x2, 0x2, 0x452, 0x453, 0x7, 0x79, 0x2, 0x2, 0x453, 0x454, + 0x7, 0x67, 0x2, 0x2, 0x454, 0x455, 0x7, 0x67, 0x2, 0x2, 0x455, 0x456, + 0x7, 0x6d, 0x2, 0x2, 0x456, 0x45d, 0x7, 0x75, 0x2, 0x2, 0x457, 0x458, + 0x7, 0x7b, 0x2, 0x2, 0x458, 0x459, 0x7, 0x67, 0x2, 0x2, 0x459, 0x45a, + 0x7, 0x63, 0x2, 0x2, 0x45a, 0x45b, 0x7, 0x74, 0x2, 0x2, 0x45b, 0x45d, + 0x7, 0x75, 0x2, 0x2, 0x45c, 0x42f, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x432, + 0x3, 0x2, 0x2, 0x2, 0x45c, 0x436, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x43b, + 0x3, 0x2, 0x2, 0x2, 0x45c, 0x442, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x449, + 0x3, 0x2, 0x2, 0x2, 0x45c, 0x44e, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x452, + 0x3, 0x2, 0x2, 0x2, 0x45c, 0x457, 0x3, 0x2, 0x2, 0x2, 0x45d, 0x5d, + 0x3, 0x2, 0x2, 0x2, 0x45e, 0x45f, 0x7, 0x71, 0x2, 0x2, 0x45f, 0x460, + 0x7, 0x78, 0x2, 0x2, 0x460, 0x461, 0x7, 0x67, 0x2, 0x2, 0x461, 0x462, + 0x7, 0x74, 0x2, 0x2, 0x462, 0x463, 0x7, 0x74, 0x2, 0x2, 0x463, 0x464, + 0x7, 0x6b, 0x2, 0x2, 0x464, 0x465, 0x7, 0x66, 0x2, 0x2, 0x465, 0x466, + 0x7, 0x67, 0x2, 0x2, 0x466, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x467, 0x468, + 0x7, 0x72, 0x2, 0x2, 0x468, 0x469, 0x7, 0x63, 0x2, 0x2, 0x469, 0x46a, + 0x7, 0x7b, 0x2, 0x2, 0x46a, 0x46b, 0x7, 0x63, 0x2, 0x2, 0x46b, 0x46c, + 0x7, 0x64, 0x2, 0x2, 0x46c, 0x46d, 0x7, 0x6e, 0x2, 0x2, 0x46d, 0x46e, + 0x7, 0x67, 0x2, 0x2, 0x46e, 0x61, 0x3, 0x2, 0x2, 0x2, 0x46f, 0x470, + 0x7, 0x72, 0x2, 0x2, 0x470, 0x471, 0x7, 0x74, 0x2, 0x2, 0x471, 0x472, + 0x7, 0x6b, 0x2, 0x2, 0x472, 0x473, 0x7, 0x78, 0x2, 0x2, 0x473, 0x474, + 0x7, 0x63, 0x2, 0x2, 0x474, 0x475, 0x7, 0x76, 0x2, 0x2, 0x475, 0x476, + 0x7, 0x67, 0x2, 0x2, 0x476, 0x63, 0x3, 0x2, 0x2, 0x2, 0x477, 0x478, + 0x7, 0x72, 0x2, 0x2, 0x478, 0x479, 0x7, 0x77, 0x2, 0x2, 0x479, 0x47a, + 0x7, 0x64, 0x2, 0x2, 0x47a, 0x47b, 0x7, 0x6e, 0x2, 0x2, 0x47b, 0x47c, + 0x7, 0x6b, 0x2, 0x2, 0x47c, 0x47d, 0x7, 0x65, 0x2, 0x2, 0x47d, 0x65, + 0x3, 0x2, 0x2, 0x2, 0x47e, 0x47f, 0x7, 0x72, 0x2, 0x2, 0x47f, 0x480, + 0x7, 0x77, 0x2, 0x2, 0x480, 0x481, 0x7, 0x74, 0x2, 0x2, 0x481, 0x482, + 0x7, 0x67, 0x2, 0x2, 0x482, 0x67, 0x3, 0x2, 0x2, 0x2, 0x483, 0x484, + 0x7, 0x74, 0x2, 0x2, 0x484, 0x485, 0x7, 0x67, 0x2, 0x2, 0x485, 0x486, + 0x7, 0x65, 0x2, 0x2, 0x486, 0x487, 0x7, 0x67, 0x2, 0x2, 0x487, 0x488, + 0x7, 0x6b, 0x2, 0x2, 0x488, 0x489, 0x7, 0x78, 0x2, 0x2, 0x489, 0x48a, + 0x7, 0x67, 0x2, 0x2, 0x48a, 0x69, 0x3, 0x2, 0x2, 0x2, 0x48b, 0x48c, + 0x7, 0x74, 0x2, 0x2, 0x48c, 0x48d, 0x7, 0x67, 0x2, 0x2, 0x48d, 0x48e, + 0x7, 0x76, 0x2, 0x2, 0x48e, 0x48f, 0x7, 0x77, 0x2, 0x2, 0x48f, 0x490, + 0x7, 0x74, 0x2, 0x2, 0x490, 0x491, 0x7, 0x70, 0x2, 0x2, 0x491, 0x6b, + 0x3, 0x2, 0x2, 0x2, 0x492, 0x493, 0x7, 0x74, 0x2, 0x2, 0x493, 0x494, + 0x7, 0x67, 0x2, 0x2, 0x494, 0x495, 0x7, 0x76, 0x2, 0x2, 0x495, 0x496, + 0x7, 0x77, 0x2, 0x2, 0x496, 0x497, 0x7, 0x74, 0x2, 0x2, 0x497, 0x498, + 0x7, 0x70, 0x2, 0x2, 0x498, 0x499, 0x7, 0x75, 0x2, 0x2, 0x499, 0x6d, + 0x3, 0x2, 0x2, 0x2, 0x49a, 0x49b, 0x7, 0x6b, 0x2, 0x2, 0x49b, 0x49c, + 0x7, 0x70, 0x2, 0x2, 0x49c, 0x551, 0x7, 0x76, 0x2, 0x2, 0x49d, 0x49e, + 0x7, 0x6b, 0x2, 0x2, 0x49e, 0x49f, 0x7, 0x70, 0x2, 0x2, 0x49f, 0x4a0, + 0x7, 0x76, 0x2, 0x2, 0x4a0, 0x551, 0x7, 0x3a, 0x2, 0x2, 0x4a1, 0x4a2, + 0x7, 0x6b, 0x2, 0x2, 0x4a2, 0x4a3, 0x7, 0x70, 0x2, 0x2, 0x4a3, 0x4a4, + 0x7, 0x76, 0x2, 0x2, 0x4a4, 0x4a5, 0x7, 0x33, 0x2, 0x2, 0x4a5, 0x551, + 0x7, 0x38, 0x2, 0x2, 0x4a6, 0x4a7, 0x7, 0x6b, 0x2, 0x2, 0x4a7, 0x4a8, + 0x7, 0x70, 0x2, 0x2, 0x4a8, 0x4a9, 0x7, 0x76, 0x2, 0x2, 0x4a9, 0x4aa, + 0x7, 0x34, 0x2, 0x2, 0x4aa, 0x551, 0x7, 0x36, 0x2, 0x2, 0x4ab, 0x4ac, + 0x7, 0x6b, 0x2, 0x2, 0x4ac, 0x4ad, 0x7, 0x70, 0x2, 0x2, 0x4ad, 0x4ae, + 0x7, 0x76, 0x2, 0x2, 0x4ae, 0x4af, 0x7, 0x35, 0x2, 0x2, 0x4af, 0x551, + 0x7, 0x34, 0x2, 0x2, 0x4b0, 0x4b1, 0x7, 0x6b, 0x2, 0x2, 0x4b1, 0x4b2, + 0x7, 0x70, 0x2, 0x2, 0x4b2, 0x4b3, 0x7, 0x76, 0x2, 0x2, 0x4b3, 0x4b4, + 0x7, 0x36, 0x2, 0x2, 0x4b4, 0x551, 0x7, 0x32, 0x2, 0x2, 0x4b5, 0x4b6, + 0x7, 0x6b, 0x2, 0x2, 0x4b6, 0x4b7, 0x7, 0x70, 0x2, 0x2, 0x4b7, 0x4b8, + 0x7, 0x76, 0x2, 0x2, 0x4b8, 0x4b9, 0x7, 0x36, 0x2, 0x2, 0x4b9, 0x551, + 0x7, 0x3a, 0x2, 0x2, 0x4ba, 0x4bb, 0x7, 0x6b, 0x2, 0x2, 0x4bb, 0x4bc, + 0x7, 0x70, 0x2, 0x2, 0x4bc, 0x4bd, 0x7, 0x76, 0x2, 0x2, 0x4bd, 0x4be, + 0x7, 0x37, 0x2, 0x2, 0x4be, 0x551, 0x7, 0x38, 0x2, 0x2, 0x4bf, 0x4c0, + 0x7, 0x6b, 0x2, 0x2, 0x4c0, 0x4c1, 0x7, 0x70, 0x2, 0x2, 0x4c1, 0x4c2, + 0x7, 0x76, 0x2, 0x2, 0x4c2, 0x4c3, 0x7, 0x38, 0x2, 0x2, 0x4c3, 0x551, + 0x7, 0x36, 0x2, 0x2, 0x4c4, 0x4c5, 0x7, 0x6b, 0x2, 0x2, 0x4c5, 0x4c6, + 0x7, 0x70, 0x2, 0x2, 0x4c6, 0x4c7, 0x7, 0x76, 0x2, 0x2, 0x4c7, 0x4c8, + 0x7, 0x39, 0x2, 0x2, 0x4c8, 0x551, 0x7, 0x34, 0x2, 0x2, 0x4c9, 0x4ca, + 0x7, 0x6b, 0x2, 0x2, 0x4ca, 0x4cb, 0x7, 0x70, 0x2, 0x2, 0x4cb, 0x4cc, + 0x7, 0x76, 0x2, 0x2, 0x4cc, 0x4cd, 0x7, 0x3a, 0x2, 0x2, 0x4cd, 0x551, + 0x7, 0x32, 0x2, 0x2, 0x4ce, 0x4cf, 0x7, 0x6b, 0x2, 0x2, 0x4cf, 0x4d0, + 0x7, 0x70, 0x2, 0x2, 0x4d0, 0x4d1, 0x7, 0x76, 0x2, 0x2, 0x4d1, 0x4d2, + 0x7, 0x3a, 0x2, 0x2, 0x4d2, 0x551, 0x7, 0x3a, 0x2, 0x2, 0x4d3, 0x4d4, + 0x7, 0x6b, 0x2, 0x2, 0x4d4, 0x4d5, 0x7, 0x70, 0x2, 0x2, 0x4d5, 0x4d6, + 0x7, 0x76, 0x2, 0x2, 0x4d6, 0x4d7, 0x7, 0x3b, 0x2, 0x2, 0x4d7, 0x551, + 0x7, 0x38, 0x2, 0x2, 0x4d8, 0x4d9, 0x7, 0x6b, 0x2, 0x2, 0x4d9, 0x4da, + 0x7, 0x70, 0x2, 0x2, 0x4da, 0x4db, 0x7, 0x76, 0x2, 0x2, 0x4db, 0x4dc, + 0x7, 0x33, 0x2, 0x2, 0x4dc, 0x4dd, 0x7, 0x32, 0x2, 0x2, 0x4dd, 0x551, + 0x7, 0x36, 0x2, 0x2, 0x4de, 0x4df, 0x7, 0x6b, 0x2, 0x2, 0x4df, 0x4e0, + 0x7, 0x70, 0x2, 0x2, 0x4e0, 0x4e1, 0x7, 0x76, 0x2, 0x2, 0x4e1, 0x4e2, + 0x7, 0x33, 0x2, 0x2, 0x4e2, 0x4e3, 0x7, 0x33, 0x2, 0x2, 0x4e3, 0x551, + 0x7, 0x34, 0x2, 0x2, 0x4e4, 0x4e5, 0x7, 0x6b, 0x2, 0x2, 0x4e5, 0x4e6, + 0x7, 0x70, 0x2, 0x2, 0x4e6, 0x4e7, 0x7, 0x76, 0x2, 0x2, 0x4e7, 0x4e8, + 0x7, 0x33, 0x2, 0x2, 0x4e8, 0x4e9, 0x7, 0x34, 0x2, 0x2, 0x4e9, 0x551, + 0x7, 0x32, 0x2, 0x2, 0x4ea, 0x4eb, 0x7, 0x6b, 0x2, 0x2, 0x4eb, 0x4ec, + 0x7, 0x70, 0x2, 0x2, 0x4ec, 0x4ed, 0x7, 0x76, 0x2, 0x2, 0x4ed, 0x4ee, + 0x7, 0x33, 0x2, 0x2, 0x4ee, 0x4ef, 0x7, 0x34, 0x2, 0x2, 0x4ef, 0x551, + 0x7, 0x3a, 0x2, 0x2, 0x4f0, 0x4f1, 0x7, 0x6b, 0x2, 0x2, 0x4f1, 0x4f2, + 0x7, 0x70, 0x2, 0x2, 0x4f2, 0x4f3, 0x7, 0x76, 0x2, 0x2, 0x4f3, 0x4f4, + 0x7, 0x33, 0x2, 0x2, 0x4f4, 0x4f5, 0x7, 0x35, 0x2, 0x2, 0x4f5, 0x551, + 0x7, 0x38, 0x2, 0x2, 0x4f6, 0x4f7, 0x7, 0x6b, 0x2, 0x2, 0x4f7, 0x4f8, + 0x7, 0x70, 0x2, 0x2, 0x4f8, 0x4f9, 0x7, 0x76, 0x2, 0x2, 0x4f9, 0x4fa, + 0x7, 0x33, 0x2, 0x2, 0x4fa, 0x4fb, 0x7, 0x36, 0x2, 0x2, 0x4fb, 0x551, + 0x7, 0x36, 0x2, 0x2, 0x4fc, 0x4fd, 0x7, 0x6b, 0x2, 0x2, 0x4fd, 0x4fe, + 0x7, 0x70, 0x2, 0x2, 0x4fe, 0x4ff, 0x7, 0x76, 0x2, 0x2, 0x4ff, 0x500, + 0x7, 0x33, 0x2, 0x2, 0x500, 0x501, 0x7, 0x37, 0x2, 0x2, 0x501, 0x551, + 0x7, 0x34, 0x2, 0x2, 0x502, 0x503, 0x7, 0x6b, 0x2, 0x2, 0x503, 0x504, + 0x7, 0x70, 0x2, 0x2, 0x504, 0x505, 0x7, 0x76, 0x2, 0x2, 0x505, 0x506, + 0x7, 0x33, 0x2, 0x2, 0x506, 0x507, 0x7, 0x38, 0x2, 0x2, 0x507, 0x551, + 0x7, 0x32, 0x2, 0x2, 0x508, 0x509, 0x7, 0x6b, 0x2, 0x2, 0x509, 0x50a, + 0x7, 0x70, 0x2, 0x2, 0x50a, 0x50b, 0x7, 0x76, 0x2, 0x2, 0x50b, 0x50c, + 0x7, 0x33, 0x2, 0x2, 0x50c, 0x50d, 0x7, 0x38, 0x2, 0x2, 0x50d, 0x551, + 0x7, 0x3a, 0x2, 0x2, 0x50e, 0x50f, 0x7, 0x6b, 0x2, 0x2, 0x50f, 0x510, + 0x7, 0x70, 0x2, 0x2, 0x510, 0x511, 0x7, 0x76, 0x2, 0x2, 0x511, 0x512, + 0x7, 0x33, 0x2, 0x2, 0x512, 0x513, 0x7, 0x39, 0x2, 0x2, 0x513, 0x551, + 0x7, 0x38, 0x2, 0x2, 0x514, 0x515, 0x7, 0x6b, 0x2, 0x2, 0x515, 0x516, + 0x7, 0x70, 0x2, 0x2, 0x516, 0x517, 0x7, 0x76, 0x2, 0x2, 0x517, 0x518, + 0x7, 0x33, 0x2, 0x2, 0x518, 0x519, 0x7, 0x3a, 0x2, 0x2, 0x519, 0x551, + 0x7, 0x36, 0x2, 0x2, 0x51a, 0x51b, 0x7, 0x6b, 0x2, 0x2, 0x51b, 0x51c, + 0x7, 0x70, 0x2, 0x2, 0x51c, 0x51d, 0x7, 0x76, 0x2, 0x2, 0x51d, 0x51e, + 0x7, 0x33, 0x2, 0x2, 0x51e, 0x51f, 0x7, 0x3b, 0x2, 0x2, 0x51f, 0x551, + 0x7, 0x34, 0x2, 0x2, 0x520, 0x521, 0x7, 0x6b, 0x2, 0x2, 0x521, 0x522, + 0x7, 0x70, 0x2, 0x2, 0x522, 0x523, 0x7, 0x76, 0x2, 0x2, 0x523, 0x524, + 0x7, 0x34, 0x2, 0x2, 0x524, 0x525, 0x7, 0x32, 0x2, 0x2, 0x525, 0x551, + 0x7, 0x32, 0x2, 0x2, 0x526, 0x527, 0x7, 0x6b, 0x2, 0x2, 0x527, 0x528, + 0x7, 0x70, 0x2, 0x2, 0x528, 0x529, 0x7, 0x76, 0x2, 0x2, 0x529, 0x52a, + 0x7, 0x34, 0x2, 0x2, 0x52a, 0x52b, 0x7, 0x32, 0x2, 0x2, 0x52b, 0x551, + 0x7, 0x3a, 0x2, 0x2, 0x52c, 0x52d, 0x7, 0x6b, 0x2, 0x2, 0x52d, 0x52e, + 0x7, 0x70, 0x2, 0x2, 0x52e, 0x52f, 0x7, 0x76, 0x2, 0x2, 0x52f, 0x530, + 0x7, 0x34, 0x2, 0x2, 0x530, 0x531, 0x7, 0x33, 0x2, 0x2, 0x531, 0x551, + 0x7, 0x38, 0x2, 0x2, 0x532, 0x533, 0x7, 0x6b, 0x2, 0x2, 0x533, 0x534, + 0x7, 0x70, 0x2, 0x2, 0x534, 0x535, 0x7, 0x76, 0x2, 0x2, 0x535, 0x536, + 0x7, 0x34, 0x2, 0x2, 0x536, 0x537, 0x7, 0x34, 0x2, 0x2, 0x537, 0x551, + 0x7, 0x36, 0x2, 0x2, 0x538, 0x539, 0x7, 0x6b, 0x2, 0x2, 0x539, 0x53a, + 0x7, 0x70, 0x2, 0x2, 0x53a, 0x53b, 0x7, 0x76, 0x2, 0x2, 0x53b, 0x53c, + 0x7, 0x34, 0x2, 0x2, 0x53c, 0x53d, 0x7, 0x35, 0x2, 0x2, 0x53d, 0x551, + 0x7, 0x34, 0x2, 0x2, 0x53e, 0x53f, 0x7, 0x6b, 0x2, 0x2, 0x53f, 0x540, + 0x7, 0x70, 0x2, 0x2, 0x540, 0x541, 0x7, 0x76, 0x2, 0x2, 0x541, 0x542, + 0x7, 0x34, 0x2, 0x2, 0x542, 0x543, 0x7, 0x36, 0x2, 0x2, 0x543, 0x551, + 0x7, 0x32, 0x2, 0x2, 0x544, 0x545, 0x7, 0x6b, 0x2, 0x2, 0x545, 0x546, + 0x7, 0x70, 0x2, 0x2, 0x546, 0x547, 0x7, 0x76, 0x2, 0x2, 0x547, 0x548, + 0x7, 0x34, 0x2, 0x2, 0x548, 0x549, 0x7, 0x36, 0x2, 0x2, 0x549, 0x551, + 0x7, 0x3a, 0x2, 0x2, 0x54a, 0x54b, 0x7, 0x6b, 0x2, 0x2, 0x54b, 0x54c, + 0x7, 0x70, 0x2, 0x2, 0x54c, 0x54d, 0x7, 0x76, 0x2, 0x2, 0x54d, 0x54e, + 0x7, 0x34, 0x2, 0x2, 0x54e, 0x54f, 0x7, 0x37, 0x2, 0x2, 0x54f, 0x551, + 0x7, 0x38, 0x2, 0x2, 0x550, 0x49a, 0x3, 0x2, 0x2, 0x2, 0x550, 0x49d, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4a1, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4a6, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4ab, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4b0, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4b5, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4ba, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4bf, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4c4, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4c9, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4ce, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4d3, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4d8, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4de, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4e4, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4ea, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4f0, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x4f6, 0x3, 0x2, 0x2, 0x2, 0x550, 0x4fc, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x502, 0x3, 0x2, 0x2, 0x2, 0x550, 0x508, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x50e, 0x3, 0x2, 0x2, 0x2, 0x550, 0x514, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x51a, 0x3, 0x2, 0x2, 0x2, 0x550, 0x520, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x526, 0x3, 0x2, 0x2, 0x2, 0x550, 0x52c, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x532, 0x3, 0x2, 0x2, 0x2, 0x550, 0x538, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x53e, 0x3, 0x2, 0x2, 0x2, 0x550, 0x544, + 0x3, 0x2, 0x2, 0x2, 0x550, 0x54a, 0x3, 0x2, 0x2, 0x2, 0x551, 0x6f, + 0x3, 0x2, 0x2, 0x2, 0x552, 0x553, 0x7, 0x75, 0x2, 0x2, 0x553, 0x554, + 0x7, 0x76, 0x2, 0x2, 0x554, 0x555, 0x7, 0x71, 0x2, 0x2, 0x555, 0x556, + 0x7, 0x74, 0x2, 0x2, 0x556, 0x557, 0x7, 0x63, 0x2, 0x2, 0x557, 0x558, + 0x7, 0x69, 0x2, 0x2, 0x558, 0x559, 0x7, 0x67, 0x2, 0x2, 0x559, 0x71, + 0x3, 0x2, 0x2, 0x2, 0x55a, 0x55b, 0x7, 0x75, 0x2, 0x2, 0x55b, 0x55c, + 0x7, 0x76, 0x2, 0x2, 0x55c, 0x55d, 0x7, 0x74, 0x2, 0x2, 0x55d, 0x55e, + 0x7, 0x6b, 0x2, 0x2, 0x55e, 0x55f, 0x7, 0x70, 0x2, 0x2, 0x55f, 0x560, + 0x7, 0x69, 0x2, 0x2, 0x560, 0x73, 0x3, 0x2, 0x2, 0x2, 0x561, 0x562, + 0x7, 0x75, 0x2, 0x2, 0x562, 0x563, 0x7, 0x76, 0x2, 0x2, 0x563, 0x564, + 0x7, 0x74, 0x2, 0x2, 0x564, 0x565, 0x7, 0x77, 0x2, 0x2, 0x565, 0x566, + 0x7, 0x65, 0x2, 0x2, 0x566, 0x567, 0x7, 0x76, 0x2, 0x2, 0x567, 0x75, + 0x3, 0x2, 0x2, 0x2, 0x568, 0x569, 0x7, 0x76, 0x2, 0x2, 0x569, 0x56a, + 0x7, 0x74, 0x2, 0x2, 0x56a, 0x56b, 0x7, 0x77, 0x2, 0x2, 0x56b, 0x56c, + 0x7, 0x67, 0x2, 0x2, 0x56c, 0x77, 0x3, 0x2, 0x2, 0x2, 0x56d, 0x56e, + 0x7, 0x76, 0x2, 0x2, 0x56e, 0x56f, 0x7, 0x74, 0x2, 0x2, 0x56f, 0x570, + 0x7, 0x7b, 0x2, 0x2, 0x570, 0x79, 0x3, 0x2, 0x2, 0x2, 0x571, 0x572, + 0x7, 0x76, 0x2, 0x2, 0x572, 0x573, 0x7, 0x7b, 0x2, 0x2, 0x573, 0x574, + 0x7, 0x72, 0x2, 0x2, 0x574, 0x575, 0x7, 0x67, 0x2, 0x2, 0x575, 0x7b, + 0x3, 0x2, 0x2, 0x2, 0x576, 0x577, 0x7, 0x77, 0x2, 0x2, 0x577, 0x578, + 0x7, 0x68, 0x2, 0x2, 0x578, 0x579, 0x7, 0x6b, 0x2, 0x2, 0x579, 0x57a, + 0x7, 0x7a, 0x2, 0x2, 0x57a, 0x57b, 0x7, 0x67, 0x2, 0x2, 0x57b, 0x58f, + 0x7, 0x66, 0x2, 0x2, 0x57c, 0x57d, 0x7, 0x77, 0x2, 0x2, 0x57d, 0x57e, + 0x7, 0x68, 0x2, 0x2, 0x57e, 0x57f, 0x7, 0x6b, 0x2, 0x2, 0x57f, 0x580, + 0x7, 0x7a, 0x2, 0x2, 0x580, 0x581, 0x7, 0x67, 0x2, 0x2, 0x581, 0x582, + 0x7, 0x66, 0x2, 0x2, 0x582, 0x584, 0x3, 0x2, 0x2, 0x2, 0x583, 0x585, + 0x9, 0x2, 0x2, 0x2, 0x584, 0x583, 0x3, 0x2, 0x2, 0x2, 0x585, 0x586, + 0x3, 0x2, 0x2, 0x2, 0x586, 0x584, 0x3, 0x2, 0x2, 0x2, 0x586, 0x587, + 0x3, 0x2, 0x2, 0x2, 0x587, 0x588, 0x3, 0x2, 0x2, 0x2, 0x588, 0x58a, + 0x7, 0x7a, 0x2, 0x2, 0x589, 0x58b, 0x9, 0x2, 0x2, 0x2, 0x58a, 0x589, + 0x3, 0x2, 0x2, 0x2, 0x58b, 0x58c, 0x3, 0x2, 0x2, 0x2, 0x58c, 0x58a, + 0x3, 0x2, 0x2, 0x2, 0x58c, 0x58d, 0x3, 0x2, 0x2, 0x2, 0x58d, 0x58f, + 0x3, 0x2, 0x2, 0x2, 0x58e, 0x576, 0x3, 0x2, 0x2, 0x2, 0x58e, 0x57c, + 0x3, 0x2, 0x2, 0x2, 0x58f, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x590, 0x591, + 0x7, 0x77, 0x2, 0x2, 0x591, 0x592, 0x7, 0x6b, 0x2, 0x2, 0x592, 0x593, + 0x7, 0x70, 0x2, 0x2, 0x593, 0x668, 0x7, 0x76, 0x2, 0x2, 0x594, 0x595, + 0x7, 0x77, 0x2, 0x2, 0x595, 0x596, 0x7, 0x6b, 0x2, 0x2, 0x596, 0x597, + 0x7, 0x70, 0x2, 0x2, 0x597, 0x598, 0x7, 0x76, 0x2, 0x2, 0x598, 0x668, + 0x7, 0x3a, 0x2, 0x2, 0x599, 0x59a, 0x7, 0x77, 0x2, 0x2, 0x59a, 0x59b, + 0x7, 0x6b, 0x2, 0x2, 0x59b, 0x59c, 0x7, 0x70, 0x2, 0x2, 0x59c, 0x59d, + 0x7, 0x76, 0x2, 0x2, 0x59d, 0x59e, 0x7, 0x33, 0x2, 0x2, 0x59e, 0x668, + 0x7, 0x38, 0x2, 0x2, 0x59f, 0x5a0, 0x7, 0x77, 0x2, 0x2, 0x5a0, 0x5a1, + 0x7, 0x6b, 0x2, 0x2, 0x5a1, 0x5a2, 0x7, 0x70, 0x2, 0x2, 0x5a2, 0x5a3, + 0x7, 0x76, 0x2, 0x2, 0x5a3, 0x5a4, 0x7, 0x34, 0x2, 0x2, 0x5a4, 0x668, + 0x7, 0x36, 0x2, 0x2, 0x5a5, 0x5a6, 0x7, 0x77, 0x2, 0x2, 0x5a6, 0x5a7, + 0x7, 0x6b, 0x2, 0x2, 0x5a7, 0x5a8, 0x7, 0x70, 0x2, 0x2, 0x5a8, 0x5a9, + 0x7, 0x76, 0x2, 0x2, 0x5a9, 0x5aa, 0x7, 0x35, 0x2, 0x2, 0x5aa, 0x668, + 0x7, 0x34, 0x2, 0x2, 0x5ab, 0x5ac, 0x7, 0x77, 0x2, 0x2, 0x5ac, 0x5ad, + 0x7, 0x6b, 0x2, 0x2, 0x5ad, 0x5ae, 0x7, 0x70, 0x2, 0x2, 0x5ae, 0x5af, + 0x7, 0x76, 0x2, 0x2, 0x5af, 0x5b0, 0x7, 0x36, 0x2, 0x2, 0x5b0, 0x668, + 0x7, 0x32, 0x2, 0x2, 0x5b1, 0x5b2, 0x7, 0x77, 0x2, 0x2, 0x5b2, 0x5b3, + 0x7, 0x6b, 0x2, 0x2, 0x5b3, 0x5b4, 0x7, 0x70, 0x2, 0x2, 0x5b4, 0x5b5, + 0x7, 0x76, 0x2, 0x2, 0x5b5, 0x5b6, 0x7, 0x36, 0x2, 0x2, 0x5b6, 0x668, + 0x7, 0x3a, 0x2, 0x2, 0x5b7, 0x5b8, 0x7, 0x77, 0x2, 0x2, 0x5b8, 0x5b9, + 0x7, 0x6b, 0x2, 0x2, 0x5b9, 0x5ba, 0x7, 0x70, 0x2, 0x2, 0x5ba, 0x5bb, + 0x7, 0x76, 0x2, 0x2, 0x5bb, 0x5bc, 0x7, 0x37, 0x2, 0x2, 0x5bc, 0x668, + 0x7, 0x38, 0x2, 0x2, 0x5bd, 0x5be, 0x7, 0x77, 0x2, 0x2, 0x5be, 0x5bf, + 0x7, 0x6b, 0x2, 0x2, 0x5bf, 0x5c0, 0x7, 0x70, 0x2, 0x2, 0x5c0, 0x5c1, + 0x7, 0x76, 0x2, 0x2, 0x5c1, 0x5c2, 0x7, 0x38, 0x2, 0x2, 0x5c2, 0x668, + 0x7, 0x36, 0x2, 0x2, 0x5c3, 0x5c4, 0x7, 0x77, 0x2, 0x2, 0x5c4, 0x5c5, + 0x7, 0x6b, 0x2, 0x2, 0x5c5, 0x5c6, 0x7, 0x70, 0x2, 0x2, 0x5c6, 0x5c7, + 0x7, 0x76, 0x2, 0x2, 0x5c7, 0x5c8, 0x7, 0x39, 0x2, 0x2, 0x5c8, 0x668, + 0x7, 0x34, 0x2, 0x2, 0x5c9, 0x5ca, 0x7, 0x77, 0x2, 0x2, 0x5ca, 0x5cb, + 0x7, 0x6b, 0x2, 0x2, 0x5cb, 0x5cc, 0x7, 0x70, 0x2, 0x2, 0x5cc, 0x5cd, + 0x7, 0x76, 0x2, 0x2, 0x5cd, 0x5ce, 0x7, 0x3a, 0x2, 0x2, 0x5ce, 0x668, + 0x7, 0x32, 0x2, 0x2, 0x5cf, 0x5d0, 0x7, 0x77, 0x2, 0x2, 0x5d0, 0x5d1, + 0x7, 0x6b, 0x2, 0x2, 0x5d1, 0x5d2, 0x7, 0x70, 0x2, 0x2, 0x5d2, 0x5d3, + 0x7, 0x76, 0x2, 0x2, 0x5d3, 0x5d4, 0x7, 0x3a, 0x2, 0x2, 0x5d4, 0x668, + 0x7, 0x3a, 0x2, 0x2, 0x5d5, 0x5d6, 0x7, 0x77, 0x2, 0x2, 0x5d6, 0x5d7, + 0x7, 0x6b, 0x2, 0x2, 0x5d7, 0x5d8, 0x7, 0x70, 0x2, 0x2, 0x5d8, 0x5d9, + 0x7, 0x76, 0x2, 0x2, 0x5d9, 0x5da, 0x7, 0x3b, 0x2, 0x2, 0x5da, 0x668, + 0x7, 0x38, 0x2, 0x2, 0x5db, 0x5dc, 0x7, 0x77, 0x2, 0x2, 0x5dc, 0x5dd, + 0x7, 0x6b, 0x2, 0x2, 0x5dd, 0x5de, 0x7, 0x70, 0x2, 0x2, 0x5de, 0x5df, + 0x7, 0x76, 0x2, 0x2, 0x5df, 0x5e0, 0x7, 0x33, 0x2, 0x2, 0x5e0, 0x5e1, + 0x7, 0x32, 0x2, 0x2, 0x5e1, 0x668, 0x7, 0x36, 0x2, 0x2, 0x5e2, 0x5e3, + 0x7, 0x77, 0x2, 0x2, 0x5e3, 0x5e4, 0x7, 0x6b, 0x2, 0x2, 0x5e4, 0x5e5, + 0x7, 0x70, 0x2, 0x2, 0x5e5, 0x5e6, 0x7, 0x76, 0x2, 0x2, 0x5e6, 0x5e7, + 0x7, 0x33, 0x2, 0x2, 0x5e7, 0x5e8, 0x7, 0x33, 0x2, 0x2, 0x5e8, 0x668, + 0x7, 0x34, 0x2, 0x2, 0x5e9, 0x5ea, 0x7, 0x77, 0x2, 0x2, 0x5ea, 0x5eb, + 0x7, 0x6b, 0x2, 0x2, 0x5eb, 0x5ec, 0x7, 0x70, 0x2, 0x2, 0x5ec, 0x5ed, + 0x7, 0x76, 0x2, 0x2, 0x5ed, 0x5ee, 0x7, 0x33, 0x2, 0x2, 0x5ee, 0x5ef, + 0x7, 0x34, 0x2, 0x2, 0x5ef, 0x668, 0x7, 0x32, 0x2, 0x2, 0x5f0, 0x5f1, + 0x7, 0x77, 0x2, 0x2, 0x5f1, 0x5f2, 0x7, 0x6b, 0x2, 0x2, 0x5f2, 0x5f3, + 0x7, 0x70, 0x2, 0x2, 0x5f3, 0x5f4, 0x7, 0x76, 0x2, 0x2, 0x5f4, 0x5f5, + 0x7, 0x33, 0x2, 0x2, 0x5f5, 0x5f6, 0x7, 0x34, 0x2, 0x2, 0x5f6, 0x668, + 0x7, 0x3a, 0x2, 0x2, 0x5f7, 0x5f8, 0x7, 0x77, 0x2, 0x2, 0x5f8, 0x5f9, + 0x7, 0x6b, 0x2, 0x2, 0x5f9, 0x5fa, 0x7, 0x70, 0x2, 0x2, 0x5fa, 0x5fb, + 0x7, 0x76, 0x2, 0x2, 0x5fb, 0x5fc, 0x7, 0x33, 0x2, 0x2, 0x5fc, 0x5fd, + 0x7, 0x35, 0x2, 0x2, 0x5fd, 0x668, 0x7, 0x38, 0x2, 0x2, 0x5fe, 0x5ff, + 0x7, 0x77, 0x2, 0x2, 0x5ff, 0x600, 0x7, 0x6b, 0x2, 0x2, 0x600, 0x601, + 0x7, 0x70, 0x2, 0x2, 0x601, 0x602, 0x7, 0x76, 0x2, 0x2, 0x602, 0x603, + 0x7, 0x33, 0x2, 0x2, 0x603, 0x604, 0x7, 0x36, 0x2, 0x2, 0x604, 0x668, + 0x7, 0x36, 0x2, 0x2, 0x605, 0x606, 0x7, 0x77, 0x2, 0x2, 0x606, 0x607, + 0x7, 0x6b, 0x2, 0x2, 0x607, 0x608, 0x7, 0x70, 0x2, 0x2, 0x608, 0x609, + 0x7, 0x76, 0x2, 0x2, 0x609, 0x60a, 0x7, 0x33, 0x2, 0x2, 0x60a, 0x60b, + 0x7, 0x37, 0x2, 0x2, 0x60b, 0x668, 0x7, 0x34, 0x2, 0x2, 0x60c, 0x60d, + 0x7, 0x77, 0x2, 0x2, 0x60d, 0x60e, 0x7, 0x6b, 0x2, 0x2, 0x60e, 0x60f, + 0x7, 0x70, 0x2, 0x2, 0x60f, 0x610, 0x7, 0x76, 0x2, 0x2, 0x610, 0x611, + 0x7, 0x33, 0x2, 0x2, 0x611, 0x612, 0x7, 0x38, 0x2, 0x2, 0x612, 0x668, + 0x7, 0x32, 0x2, 0x2, 0x613, 0x614, 0x7, 0x77, 0x2, 0x2, 0x614, 0x615, + 0x7, 0x6b, 0x2, 0x2, 0x615, 0x616, 0x7, 0x70, 0x2, 0x2, 0x616, 0x617, + 0x7, 0x76, 0x2, 0x2, 0x617, 0x618, 0x7, 0x33, 0x2, 0x2, 0x618, 0x619, + 0x7, 0x38, 0x2, 0x2, 0x619, 0x668, 0x7, 0x3a, 0x2, 0x2, 0x61a, 0x61b, + 0x7, 0x77, 0x2, 0x2, 0x61b, 0x61c, 0x7, 0x6b, 0x2, 0x2, 0x61c, 0x61d, + 0x7, 0x70, 0x2, 0x2, 0x61d, 0x61e, 0x7, 0x76, 0x2, 0x2, 0x61e, 0x61f, + 0x7, 0x33, 0x2, 0x2, 0x61f, 0x620, 0x7, 0x39, 0x2, 0x2, 0x620, 0x668, + 0x7, 0x38, 0x2, 0x2, 0x621, 0x622, 0x7, 0x77, 0x2, 0x2, 0x622, 0x623, + 0x7, 0x6b, 0x2, 0x2, 0x623, 0x624, 0x7, 0x70, 0x2, 0x2, 0x624, 0x625, + 0x7, 0x76, 0x2, 0x2, 0x625, 0x626, 0x7, 0x33, 0x2, 0x2, 0x626, 0x627, + 0x7, 0x3a, 0x2, 0x2, 0x627, 0x668, 0x7, 0x36, 0x2, 0x2, 0x628, 0x629, + 0x7, 0x77, 0x2, 0x2, 0x629, 0x62a, 0x7, 0x6b, 0x2, 0x2, 0x62a, 0x62b, + 0x7, 0x70, 0x2, 0x2, 0x62b, 0x62c, 0x7, 0x76, 0x2, 0x2, 0x62c, 0x62d, + 0x7, 0x33, 0x2, 0x2, 0x62d, 0x62e, 0x7, 0x3b, 0x2, 0x2, 0x62e, 0x668, + 0x7, 0x34, 0x2, 0x2, 0x62f, 0x630, 0x7, 0x77, 0x2, 0x2, 0x630, 0x631, + 0x7, 0x6b, 0x2, 0x2, 0x631, 0x632, 0x7, 0x70, 0x2, 0x2, 0x632, 0x633, + 0x7, 0x76, 0x2, 0x2, 0x633, 0x634, 0x7, 0x34, 0x2, 0x2, 0x634, 0x635, + 0x7, 0x32, 0x2, 0x2, 0x635, 0x668, 0x7, 0x32, 0x2, 0x2, 0x636, 0x637, + 0x7, 0x77, 0x2, 0x2, 0x637, 0x638, 0x7, 0x6b, 0x2, 0x2, 0x638, 0x639, + 0x7, 0x70, 0x2, 0x2, 0x639, 0x63a, 0x7, 0x76, 0x2, 0x2, 0x63a, 0x63b, + 0x7, 0x34, 0x2, 0x2, 0x63b, 0x63c, 0x7, 0x32, 0x2, 0x2, 0x63c, 0x668, + 0x7, 0x3a, 0x2, 0x2, 0x63d, 0x63e, 0x7, 0x77, 0x2, 0x2, 0x63e, 0x63f, + 0x7, 0x6b, 0x2, 0x2, 0x63f, 0x640, 0x7, 0x70, 0x2, 0x2, 0x640, 0x641, + 0x7, 0x76, 0x2, 0x2, 0x641, 0x642, 0x7, 0x34, 0x2, 0x2, 0x642, 0x643, + 0x7, 0x33, 0x2, 0x2, 0x643, 0x668, 0x7, 0x38, 0x2, 0x2, 0x644, 0x645, + 0x7, 0x77, 0x2, 0x2, 0x645, 0x646, 0x7, 0x6b, 0x2, 0x2, 0x646, 0x647, + 0x7, 0x70, 0x2, 0x2, 0x647, 0x648, 0x7, 0x76, 0x2, 0x2, 0x648, 0x649, + 0x7, 0x34, 0x2, 0x2, 0x649, 0x64a, 0x7, 0x34, 0x2, 0x2, 0x64a, 0x668, + 0x7, 0x36, 0x2, 0x2, 0x64b, 0x64c, 0x7, 0x77, 0x2, 0x2, 0x64c, 0x64d, + 0x7, 0x6b, 0x2, 0x2, 0x64d, 0x64e, 0x7, 0x70, 0x2, 0x2, 0x64e, 0x64f, + 0x7, 0x76, 0x2, 0x2, 0x64f, 0x650, 0x7, 0x34, 0x2, 0x2, 0x650, 0x651, + 0x7, 0x35, 0x2, 0x2, 0x651, 0x668, 0x7, 0x34, 0x2, 0x2, 0x652, 0x653, + 0x7, 0x77, 0x2, 0x2, 0x653, 0x654, 0x7, 0x6b, 0x2, 0x2, 0x654, 0x655, + 0x7, 0x70, 0x2, 0x2, 0x655, 0x656, 0x7, 0x76, 0x2, 0x2, 0x656, 0x657, + 0x7, 0x34, 0x2, 0x2, 0x657, 0x658, 0x7, 0x36, 0x2, 0x2, 0x658, 0x668, + 0x7, 0x32, 0x2, 0x2, 0x659, 0x65a, 0x7, 0x77, 0x2, 0x2, 0x65a, 0x65b, + 0x7, 0x6b, 0x2, 0x2, 0x65b, 0x65c, 0x7, 0x70, 0x2, 0x2, 0x65c, 0x65d, + 0x7, 0x76, 0x2, 0x2, 0x65d, 0x65e, 0x7, 0x34, 0x2, 0x2, 0x65e, 0x65f, + 0x7, 0x36, 0x2, 0x2, 0x65f, 0x668, 0x7, 0x3a, 0x2, 0x2, 0x660, 0x661, + 0x7, 0x77, 0x2, 0x2, 0x661, 0x662, 0x7, 0x6b, 0x2, 0x2, 0x662, 0x663, + 0x7, 0x70, 0x2, 0x2, 0x663, 0x664, 0x7, 0x76, 0x2, 0x2, 0x664, 0x665, + 0x7, 0x34, 0x2, 0x2, 0x665, 0x666, 0x7, 0x37, 0x2, 0x2, 0x666, 0x668, + 0x7, 0x38, 0x2, 0x2, 0x667, 0x590, 0x3, 0x2, 0x2, 0x2, 0x667, 0x594, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x599, 0x3, 0x2, 0x2, 0x2, 0x667, 0x59f, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5a5, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5ab, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5b1, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5b7, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5bd, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5c3, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5c9, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5cf, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5d5, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5db, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5e2, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5e9, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5f0, 0x3, 0x2, 0x2, 0x2, 0x667, 0x5f7, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x5fe, 0x3, 0x2, 0x2, 0x2, 0x667, 0x605, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x60c, 0x3, 0x2, 0x2, 0x2, 0x667, 0x613, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x61a, 0x3, 0x2, 0x2, 0x2, 0x667, 0x621, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x628, 0x3, 0x2, 0x2, 0x2, 0x667, 0x62f, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x636, 0x3, 0x2, 0x2, 0x2, 0x667, 0x63d, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x644, 0x3, 0x2, 0x2, 0x2, 0x667, 0x64b, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x652, 0x3, 0x2, 0x2, 0x2, 0x667, 0x659, + 0x3, 0x2, 0x2, 0x2, 0x667, 0x660, 0x3, 0x2, 0x2, 0x2, 0x668, 0x7f, + 0x3, 0x2, 0x2, 0x2, 0x669, 0x66a, 0x7, 0x77, 0x2, 0x2, 0x66a, 0x66b, + 0x7, 0x75, 0x2, 0x2, 0x66b, 0x66c, 0x7, 0x6b, 0x2, 0x2, 0x66c, 0x66d, + 0x7, 0x70, 0x2, 0x2, 0x66d, 0x66e, 0x7, 0x69, 0x2, 0x2, 0x66e, 0x81, + 0x3, 0x2, 0x2, 0x2, 0x66f, 0x670, 0x7, 0x78, 0x2, 0x2, 0x670, 0x671, + 0x7, 0x6b, 0x2, 0x2, 0x671, 0x672, 0x7, 0x67, 0x2, 0x2, 0x672, 0x673, + 0x7, 0x79, 0x2, 0x2, 0x673, 0x83, 0x3, 0x2, 0x2, 0x2, 0x674, 0x675, + 0x7, 0x78, 0x2, 0x2, 0x675, 0x676, 0x7, 0x6b, 0x2, 0x2, 0x676, 0x677, + 0x7, 0x74, 0x2, 0x2, 0x677, 0x678, 0x7, 0x76, 0x2, 0x2, 0x678, 0x679, + 0x7, 0x77, 0x2, 0x2, 0x679, 0x67a, 0x7, 0x63, 0x2, 0x2, 0x67a, 0x67b, + 0x7, 0x6e, 0x2, 0x2, 0x67b, 0x85, 0x3, 0x2, 0x2, 0x2, 0x67c, 0x67d, + 0x7, 0x79, 0x2, 0x2, 0x67d, 0x67e, 0x7, 0x6a, 0x2, 0x2, 0x67e, 0x67f, + 0x7, 0x6b, 0x2, 0x2, 0x67f, 0x680, 0x7, 0x6e, 0x2, 0x2, 0x680, 0x681, + 0x7, 0x67, 0x2, 0x2, 0x681, 0x87, 0x3, 0x2, 0x2, 0x2, 0x682, 0x683, + 0x7, 0x2a, 0x2, 0x2, 0x683, 0x89, 0x3, 0x2, 0x2, 0x2, 0x684, 0x685, + 0x7, 0x2b, 0x2, 0x2, 0x685, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x686, 0x687, + 0x7, 0x5d, 0x2, 0x2, 0x687, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x688, 0x689, + 0x7, 0x5f, 0x2, 0x2, 0x689, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x68a, 0x68b, + 0x7, 0x7d, 0x2, 0x2, 0x68b, 0x91, 0x3, 0x2, 0x2, 0x2, 0x68c, 0x68d, + 0x7, 0x7f, 0x2, 0x2, 0x68d, 0x93, 0x3, 0x2, 0x2, 0x2, 0x68e, 0x68f, + 0x7, 0x3c, 0x2, 0x2, 0x68f, 0x95, 0x3, 0x2, 0x2, 0x2, 0x690, 0x691, + 0x7, 0x3d, 0x2, 0x2, 0x691, 0x97, 0x3, 0x2, 0x2, 0x2, 0x692, 0x693, + 0x7, 0x30, 0x2, 0x2, 0x693, 0x99, 0x3, 0x2, 0x2, 0x2, 0x694, 0x695, + 0x7, 0x41, 0x2, 0x2, 0x695, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x696, 0x697, + 0x7, 0x3f, 0x2, 0x2, 0x697, 0x698, 0x7, 0x40, 0x2, 0x2, 0x698, 0x9d, + 0x3, 0x2, 0x2, 0x2, 0x699, 0x69a, 0x7, 0x3f, 0x2, 0x2, 0x69a, 0x9f, + 0x3, 0x2, 0x2, 0x2, 0x69b, 0x69c, 0x7, 0x7e, 0x2, 0x2, 0x69c, 0x69d, + 0x7, 0x3f, 0x2, 0x2, 0x69d, 0xa1, 0x3, 0x2, 0x2, 0x2, 0x69e, 0x69f, + 0x7, 0x60, 0x2, 0x2, 0x69f, 0x6a0, 0x7, 0x3f, 0x2, 0x2, 0x6a0, 0xa3, + 0x3, 0x2, 0x2, 0x2, 0x6a1, 0x6a2, 0x7, 0x28, 0x2, 0x2, 0x6a2, 0x6a3, + 0x7, 0x3f, 0x2, 0x2, 0x6a3, 0xa5, 0x3, 0x2, 0x2, 0x2, 0x6a4, 0x6a5, + 0x7, 0x3e, 0x2, 0x2, 0x6a5, 0x6a6, 0x7, 0x3e, 0x2, 0x2, 0x6a6, 0x6a7, + 0x7, 0x3f, 0x2, 0x2, 0x6a7, 0xa7, 0x3, 0x2, 0x2, 0x2, 0x6a8, 0x6a9, + 0x7, 0x40, 0x2, 0x2, 0x6a9, 0x6aa, 0x7, 0x40, 0x2, 0x2, 0x6aa, 0x6ab, + 0x7, 0x3f, 0x2, 0x2, 0x6ab, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x6ac, 0x6ad, + 0x7, 0x40, 0x2, 0x2, 0x6ad, 0x6ae, 0x7, 0x40, 0x2, 0x2, 0x6ae, 0x6af, + 0x7, 0x40, 0x2, 0x2, 0x6af, 0x6b0, 0x7, 0x3f, 0x2, 0x2, 0x6b0, 0xab, + 0x3, 0x2, 0x2, 0x2, 0x6b1, 0x6b2, 0x7, 0x2d, 0x2, 0x2, 0x6b2, 0x6b3, + 0x7, 0x3f, 0x2, 0x2, 0x6b3, 0xad, 0x3, 0x2, 0x2, 0x2, 0x6b4, 0x6b5, + 0x7, 0x2f, 0x2, 0x2, 0x6b5, 0x6b6, 0x7, 0x3f, 0x2, 0x2, 0x6b6, 0xaf, + 0x3, 0x2, 0x2, 0x2, 0x6b7, 0x6b8, 0x7, 0x2c, 0x2, 0x2, 0x6b8, 0x6b9, + 0x7, 0x3f, 0x2, 0x2, 0x6b9, 0xb1, 0x3, 0x2, 0x2, 0x2, 0x6ba, 0x6bb, + 0x7, 0x31, 0x2, 0x2, 0x6bb, 0x6bc, 0x7, 0x3f, 0x2, 0x2, 0x6bc, 0xb3, + 0x3, 0x2, 0x2, 0x2, 0x6bd, 0x6be, 0x7, 0x27, 0x2, 0x2, 0x6be, 0x6bf, + 0x7, 0x3f, 0x2, 0x2, 0x6bf, 0xb5, 0x3, 0x2, 0x2, 0x2, 0x6c0, 0x6c1, + 0x7, 0x2e, 0x2, 0x2, 0x6c1, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x6c2, 0x6c3, + 0x7, 0x7e, 0x2, 0x2, 0x6c3, 0x6c4, 0x7, 0x7e, 0x2, 0x2, 0x6c4, 0xb9, + 0x3, 0x2, 0x2, 0x2, 0x6c5, 0x6c6, 0x7, 0x28, 0x2, 0x2, 0x6c6, 0x6c7, + 0x7, 0x28, 0x2, 0x2, 0x6c7, 0xbb, 0x3, 0x2, 0x2, 0x2, 0x6c8, 0x6c9, + 0x7, 0x7e, 0x2, 0x2, 0x6c9, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x6ca, 0x6cb, + 0x7, 0x60, 0x2, 0x2, 0x6cb, 0xbf, 0x3, 0x2, 0x2, 0x2, 0x6cc, 0x6cd, + 0x7, 0x28, 0x2, 0x2, 0x6cd, 0xc1, 0x3, 0x2, 0x2, 0x2, 0x6ce, 0x6cf, + 0x7, 0x3e, 0x2, 0x2, 0x6cf, 0x6d0, 0x7, 0x3e, 0x2, 0x2, 0x6d0, 0xc3, + 0x3, 0x2, 0x2, 0x2, 0x6d1, 0x6d2, 0x7, 0x40, 0x2, 0x2, 0x6d2, 0x6d3, + 0x7, 0x40, 0x2, 0x2, 0x6d3, 0xc5, 0x3, 0x2, 0x2, 0x2, 0x6d4, 0x6d5, + 0x7, 0x40, 0x2, 0x2, 0x6d5, 0x6d6, 0x7, 0x40, 0x2, 0x2, 0x6d6, 0x6d7, + 0x7, 0x40, 0x2, 0x2, 0x6d7, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x6d8, 0x6d9, + 0x7, 0x2d, 0x2, 0x2, 0x6d9, 0xc9, 0x3, 0x2, 0x2, 0x2, 0x6da, 0x6db, + 0x7, 0x2f, 0x2, 0x2, 0x6db, 0xcb, 0x3, 0x2, 0x2, 0x2, 0x6dc, 0x6dd, + 0x7, 0x2c, 0x2, 0x2, 0x6dd, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x6de, 0x6df, + 0x7, 0x31, 0x2, 0x2, 0x6df, 0xcf, 0x3, 0x2, 0x2, 0x2, 0x6e0, 0x6e1, + 0x7, 0x27, 0x2, 0x2, 0x6e1, 0xd1, 0x3, 0x2, 0x2, 0x2, 0x6e2, 0x6e3, + 0x7, 0x2c, 0x2, 0x2, 0x6e3, 0x6e4, 0x7, 0x2c, 0x2, 0x2, 0x6e4, 0xd3, + 0x3, 0x2, 0x2, 0x2, 0x6e5, 0x6e6, 0x7, 0x3f, 0x2, 0x2, 0x6e6, 0x6e7, + 0x7, 0x3f, 0x2, 0x2, 0x6e7, 0xd5, 0x3, 0x2, 0x2, 0x2, 0x6e8, 0x6e9, + 0x7, 0x23, 0x2, 0x2, 0x6e9, 0x6ea, 0x7, 0x3f, 0x2, 0x2, 0x6ea, 0xd7, + 0x3, 0x2, 0x2, 0x2, 0x6eb, 0x6ec, 0x7, 0x3e, 0x2, 0x2, 0x6ec, 0xd9, + 0x3, 0x2, 0x2, 0x2, 0x6ed, 0x6ee, 0x7, 0x40, 0x2, 0x2, 0x6ee, 0xdb, + 0x3, 0x2, 0x2, 0x2, 0x6ef, 0x6f0, 0x7, 0x3e, 0x2, 0x2, 0x6f0, 0x6f1, + 0x7, 0x3f, 0x2, 0x2, 0x6f1, 0xdd, 0x3, 0x2, 0x2, 0x2, 0x6f2, 0x6f3, + 0x7, 0x40, 0x2, 0x2, 0x6f3, 0x6f4, 0x7, 0x3f, 0x2, 0x2, 0x6f4, 0xdf, + 0x3, 0x2, 0x2, 0x2, 0x6f5, 0x6f6, 0x7, 0x23, 0x2, 0x2, 0x6f6, 0xe1, + 0x3, 0x2, 0x2, 0x2, 0x6f7, 0x6f8, 0x7, 0x80, 0x2, 0x2, 0x6f8, 0xe3, + 0x3, 0x2, 0x2, 0x2, 0x6f9, 0x6fa, 0x7, 0x2d, 0x2, 0x2, 0x6fa, 0x6fb, + 0x7, 0x2d, 0x2, 0x2, 0x6fb, 0xe5, 0x3, 0x2, 0x2, 0x2, 0x6fc, 0x6fd, + 0x7, 0x2f, 0x2, 0x2, 0x6fd, 0x6fe, 0x7, 0x2f, 0x2, 0x2, 0x6fe, 0xe7, + 0x3, 0x2, 0x2, 0x2, 0x6ff, 0x703, 0x7, 0x24, 0x2, 0x2, 0x700, 0x702, + 0x5, 0xec, 0x75, 0x2, 0x701, 0x700, 0x3, 0x2, 0x2, 0x2, 0x702, 0x705, + 0x3, 0x2, 0x2, 0x2, 0x703, 0x701, 0x3, 0x2, 0x2, 0x2, 0x703, 0x704, + 0x3, 0x2, 0x2, 0x2, 0x704, 0x706, 0x3, 0x2, 0x2, 0x2, 0x705, 0x703, + 0x3, 0x2, 0x2, 0x2, 0x706, 0x710, 0x7, 0x24, 0x2, 0x2, 0x707, 0x70b, + 0x7, 0x29, 0x2, 0x2, 0x708, 0x70a, 0x5, 0xee, 0x76, 0x2, 0x709, 0x708, + 0x3, 0x2, 0x2, 0x2, 0x70a, 0x70d, 0x3, 0x2, 0x2, 0x2, 0x70b, 0x709, + 0x3, 0x2, 0x2, 0x2, 0x70b, 0x70c, 0x3, 0x2, 0x2, 0x2, 0x70c, 0x70e, + 0x3, 0x2, 0x2, 0x2, 0x70d, 0x70b, 0x3, 0x2, 0x2, 0x2, 0x70e, 0x710, + 0x7, 0x29, 0x2, 0x2, 0x70f, 0x6ff, 0x3, 0x2, 0x2, 0x2, 0x70f, 0x707, + 0x3, 0x2, 0x2, 0x2, 0x710, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x711, 0x713, + 0x7, 0x24, 0x2, 0x2, 0x712, 0x714, 0x5, 0xec, 0x75, 0x2, 0x713, 0x712, + 0x3, 0x2, 0x2, 0x2, 0x714, 0x715, 0x3, 0x2, 0x2, 0x2, 0x715, 0x713, + 0x3, 0x2, 0x2, 0x2, 0x715, 0x716, 0x3, 0x2, 0x2, 0x2, 0x716, 0x717, + 0x3, 0x2, 0x2, 0x2, 0x717, 0x718, 0x7, 0x24, 0x2, 0x2, 0x718, 0x722, + 0x3, 0x2, 0x2, 0x2, 0x719, 0x71b, 0x7, 0x29, 0x2, 0x2, 0x71a, 0x71c, + 0x5, 0xee, 0x76, 0x2, 0x71b, 0x71a, 0x3, 0x2, 0x2, 0x2, 0x71c, 0x71d, + 0x3, 0x2, 0x2, 0x2, 0x71d, 0x71b, 0x3, 0x2, 0x2, 0x2, 0x71d, 0x71e, + 0x3, 0x2, 0x2, 0x2, 0x71e, 0x71f, 0x3, 0x2, 0x2, 0x2, 0x71f, 0x720, + 0x7, 0x29, 0x2, 0x2, 0x720, 0x722, 0x3, 0x2, 0x2, 0x2, 0x721, 0x711, + 0x3, 0x2, 0x2, 0x2, 0x721, 0x719, 0x3, 0x2, 0x2, 0x2, 0x722, 0xeb, + 0x3, 0x2, 0x2, 0x2, 0x723, 0x726, 0x5, 0xf2, 0x78, 0x2, 0x724, 0x726, + 0x5, 0xf4, 0x79, 0x2, 0x725, 0x723, 0x3, 0x2, 0x2, 0x2, 0x725, 0x724, + 0x3, 0x2, 0x2, 0x2, 0x726, 0xed, 0x3, 0x2, 0x2, 0x2, 0x727, 0x72a, + 0x5, 0xf0, 0x77, 0x2, 0x728, 0x72a, 0x5, 0xf4, 0x79, 0x2, 0x729, + 0x727, 0x3, 0x2, 0x2, 0x2, 0x729, 0x728, 0x3, 0x2, 0x2, 0x2, 0x72a, + 0xef, 0x3, 0x2, 0x2, 0x2, 0x72b, 0x72c, 0x9, 0x3, 0x2, 0x2, 0x72c, + 0xf1, 0x3, 0x2, 0x2, 0x2, 0x72d, 0x72e, 0x9, 0x4, 0x2, 0x2, 0x72e, + 0xf3, 0x3, 0x2, 0x2, 0x2, 0x72f, 0x73b, 0x7, 0x5e, 0x2, 0x2, 0x730, + 0x73c, 0x9, 0x5, 0x2, 0x2, 0x731, 0x732, 0x7, 0x77, 0x2, 0x2, 0x732, + 0x733, 0x5, 0x104, 0x81, 0x2, 0x733, 0x734, 0x5, 0x104, 0x81, 0x2, + 0x734, 0x735, 0x5, 0x104, 0x81, 0x2, 0x735, 0x736, 0x5, 0x104, 0x81, + 0x2, 0x736, 0x73c, 0x3, 0x2, 0x2, 0x2, 0x737, 0x738, 0x7, 0x7a, 0x2, + 0x2, 0x738, 0x739, 0x5, 0x104, 0x81, 0x2, 0x739, 0x73a, 0x5, 0x104, + 0x81, 0x2, 0x73a, 0x73c, 0x3, 0x2, 0x2, 0x2, 0x73b, 0x730, 0x3, 0x2, + 0x2, 0x2, 0x73b, 0x731, 0x3, 0x2, 0x2, 0x2, 0x73b, 0x737, 0x3, 0x2, + 0x2, 0x2, 0x73c, 0xf5, 0x3, 0x2, 0x2, 0x2, 0x73d, 0x73e, 0x7, 0x77, + 0x2, 0x2, 0x73e, 0x73f, 0x7, 0x70, 0x2, 0x2, 0x73f, 0x740, 0x7, 0x6b, + 0x2, 0x2, 0x740, 0x741, 0x7, 0x65, 0x2, 0x2, 0x741, 0x742, 0x7, 0x71, + 0x2, 0x2, 0x742, 0x743, 0x7, 0x66, 0x2, 0x2, 0x743, 0x744, 0x7, 0x67, + 0x2, 0x2, 0x744, 0x745, 0x7, 0x24, 0x2, 0x2, 0x745, 0x749, 0x3, 0x2, + 0x2, 0x2, 0x746, 0x748, 0x5, 0xf8, 0x7b, 0x2, 0x747, 0x746, 0x3, + 0x2, 0x2, 0x2, 0x748, 0x74b, 0x3, 0x2, 0x2, 0x2, 0x749, 0x747, 0x3, + 0x2, 0x2, 0x2, 0x749, 0x74a, 0x3, 0x2, 0x2, 0x2, 0x74a, 0x74c, 0x3, + 0x2, 0x2, 0x2, 0x74b, 0x749, 0x3, 0x2, 0x2, 0x2, 0x74c, 0x75e, 0x7, + 0x24, 0x2, 0x2, 0x74d, 0x74e, 0x7, 0x77, 0x2, 0x2, 0x74e, 0x74f, + 0x7, 0x70, 0x2, 0x2, 0x74f, 0x750, 0x7, 0x6b, 0x2, 0x2, 0x750, 0x751, + 0x7, 0x65, 0x2, 0x2, 0x751, 0x752, 0x7, 0x71, 0x2, 0x2, 0x752, 0x753, + 0x7, 0x66, 0x2, 0x2, 0x753, 0x754, 0x7, 0x67, 0x2, 0x2, 0x754, 0x755, + 0x7, 0x29, 0x2, 0x2, 0x755, 0x759, 0x3, 0x2, 0x2, 0x2, 0x756, 0x758, + 0x5, 0xfa, 0x7c, 0x2, 0x757, 0x756, 0x3, 0x2, 0x2, 0x2, 0x758, 0x75b, + 0x3, 0x2, 0x2, 0x2, 0x759, 0x757, 0x3, 0x2, 0x2, 0x2, 0x759, 0x75a, + 0x3, 0x2, 0x2, 0x2, 0x75a, 0x75c, 0x3, 0x2, 0x2, 0x2, 0x75b, 0x759, + 0x3, 0x2, 0x2, 0x2, 0x75c, 0x75e, 0x7, 0x29, 0x2, 0x2, 0x75d, 0x73d, + 0x3, 0x2, 0x2, 0x2, 0x75d, 0x74d, 0x3, 0x2, 0x2, 0x2, 0x75e, 0xf7, + 0x3, 0x2, 0x2, 0x2, 0x75f, 0x762, 0xa, 0x6, 0x2, 0x2, 0x760, 0x762, + 0x5, 0xf4, 0x79, 0x2, 0x761, 0x75f, 0x3, 0x2, 0x2, 0x2, 0x761, 0x760, + 0x3, 0x2, 0x2, 0x2, 0x762, 0xf9, 0x3, 0x2, 0x2, 0x2, 0x763, 0x766, + 0xa, 0x7, 0x2, 0x2, 0x764, 0x766, 0x5, 0xf4, 0x79, 0x2, 0x765, 0x763, + 0x3, 0x2, 0x2, 0x2, 0x765, 0x764, 0x3, 0x2, 0x2, 0x2, 0x766, 0xfb, + 0x3, 0x2, 0x2, 0x2, 0x767, 0x768, 0x7, 0x6a, 0x2, 0x2, 0x768, 0x769, + 0x7, 0x67, 0x2, 0x2, 0x769, 0x76a, 0x7, 0x7a, 0x2, 0x2, 0x76a, 0x775, + 0x3, 0x2, 0x2, 0x2, 0x76b, 0x76d, 0x7, 0x24, 0x2, 0x2, 0x76c, 0x76e, + 0x5, 0x102, 0x80, 0x2, 0x76d, 0x76c, 0x3, 0x2, 0x2, 0x2, 0x76d, 0x76e, + 0x3, 0x2, 0x2, 0x2, 0x76e, 0x76f, 0x3, 0x2, 0x2, 0x2, 0x76f, 0x776, + 0x7, 0x24, 0x2, 0x2, 0x770, 0x772, 0x7, 0x29, 0x2, 0x2, 0x771, 0x773, + 0x5, 0x102, 0x80, 0x2, 0x772, 0x771, 0x3, 0x2, 0x2, 0x2, 0x772, 0x773, + 0x3, 0x2, 0x2, 0x2, 0x773, 0x774, 0x3, 0x2, 0x2, 0x2, 0x774, 0x776, + 0x7, 0x29, 0x2, 0x2, 0x775, 0x76b, 0x3, 0x2, 0x2, 0x2, 0x775, 0x770, + 0x3, 0x2, 0x2, 0x2, 0x776, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x777, 0x778, + 0x7, 0x32, 0x2, 0x2, 0x778, 0x779, 0x7, 0x7a, 0x2, 0x2, 0x779, 0x77a, + 0x5, 0x100, 0x7f, 0x2, 0x77a, 0xff, 0x3, 0x2, 0x2, 0x2, 0x77b, 0x782, + 0x5, 0x104, 0x81, 0x2, 0x77c, 0x77e, 0x7, 0x61, 0x2, 0x2, 0x77d, + 0x77c, 0x3, 0x2, 0x2, 0x2, 0x77d, 0x77e, 0x3, 0x2, 0x2, 0x2, 0x77e, + 0x77f, 0x3, 0x2, 0x2, 0x2, 0x77f, 0x781, 0x5, 0x104, 0x81, 0x2, 0x780, + 0x77d, 0x3, 0x2, 0x2, 0x2, 0x781, 0x784, 0x3, 0x2, 0x2, 0x2, 0x782, + 0x780, 0x3, 0x2, 0x2, 0x2, 0x782, 0x783, 0x3, 0x2, 0x2, 0x2, 0x783, + 0x101, 0x3, 0x2, 0x2, 0x2, 0x784, 0x782, 0x3, 0x2, 0x2, 0x2, 0x785, + 0x786, 0x5, 0x104, 0x81, 0x2, 0x786, 0x78f, 0x5, 0x104, 0x81, 0x2, + 0x787, 0x789, 0x7, 0x61, 0x2, 0x2, 0x788, 0x787, 0x3, 0x2, 0x2, 0x2, + 0x788, 0x789, 0x3, 0x2, 0x2, 0x2, 0x789, 0x78a, 0x3, 0x2, 0x2, 0x2, + 0x78a, 0x78b, 0x5, 0x104, 0x81, 0x2, 0x78b, 0x78c, 0x5, 0x104, 0x81, + 0x2, 0x78c, 0x78e, 0x3, 0x2, 0x2, 0x2, 0x78d, 0x788, 0x3, 0x2, 0x2, + 0x2, 0x78e, 0x791, 0x3, 0x2, 0x2, 0x2, 0x78f, 0x78d, 0x3, 0x2, 0x2, + 0x2, 0x78f, 0x790, 0x3, 0x2, 0x2, 0x2, 0x790, 0x103, 0x3, 0x2, 0x2, + 0x2, 0x791, 0x78f, 0x3, 0x2, 0x2, 0x2, 0x792, 0x793, 0x9, 0x8, 0x2, + 0x2, 0x793, 0x105, 0x3, 0x2, 0x2, 0x2, 0x794, 0x79b, 0x5, 0x108, + 0x83, 0x2, 0x795, 0x797, 0x5, 0x108, 0x83, 0x2, 0x796, 0x795, 0x3, + 0x2, 0x2, 0x2, 0x796, 0x797, 0x3, 0x2, 0x2, 0x2, 0x797, 0x798, 0x3, + 0x2, 0x2, 0x2, 0x798, 0x799, 0x7, 0x30, 0x2, 0x2, 0x799, 0x79b, 0x5, + 0x108, 0x83, 0x2, 0x79a, 0x794, 0x3, 0x2, 0x2, 0x2, 0x79a, 0x796, + 0x3, 0x2, 0x2, 0x2, 0x79b, 0x7a1, 0x3, 0x2, 0x2, 0x2, 0x79c, 0x79e, + 0x9, 0x9, 0x2, 0x2, 0x79d, 0x79f, 0x7, 0x2f, 0x2, 0x2, 0x79e, 0x79d, + 0x3, 0x2, 0x2, 0x2, 0x79e, 0x79f, 0x3, 0x2, 0x2, 0x2, 0x79f, 0x7a0, + 0x3, 0x2, 0x2, 0x2, 0x7a0, 0x7a2, 0x5, 0x108, 0x83, 0x2, 0x7a1, 0x79c, + 0x3, 0x2, 0x2, 0x2, 0x7a1, 0x7a2, 0x3, 0x2, 0x2, 0x2, 0x7a2, 0x107, + 0x3, 0x2, 0x2, 0x2, 0x7a3, 0x7aa, 0x9, 0x2, 0x2, 0x2, 0x7a4, 0x7a6, + 0x7, 0x61, 0x2, 0x2, 0x7a5, 0x7a4, 0x3, 0x2, 0x2, 0x2, 0x7a5, 0x7a6, + 0x3, 0x2, 0x2, 0x2, 0x7a6, 0x7a7, 0x3, 0x2, 0x2, 0x2, 0x7a7, 0x7a9, + 0x9, 0x2, 0x2, 0x2, 0x7a8, 0x7a5, 0x3, 0x2, 0x2, 0x2, 0x7a9, 0x7ac, + 0x3, 0x2, 0x2, 0x2, 0x7aa, 0x7a8, 0x3, 0x2, 0x2, 0x2, 0x7aa, 0x7ab, + 0x3, 0x2, 0x2, 0x2, 0x7ab, 0x109, 0x3, 0x2, 0x2, 0x2, 0x7ac, 0x7aa, + 0x3, 0x2, 0x2, 0x2, 0x7ad, 0x7b1, 0x5, 0x10c, 0x85, 0x2, 0x7ae, 0x7b0, + 0x5, 0x10e, 0x86, 0x2, 0x7af, 0x7ae, 0x3, 0x2, 0x2, 0x2, 0x7b0, 0x7b3, + 0x3, 0x2, 0x2, 0x2, 0x7b1, 0x7af, 0x3, 0x2, 0x2, 0x2, 0x7b1, 0x7b2, + 0x3, 0x2, 0x2, 0x2, 0x7b2, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x7b3, 0x7b1, + 0x3, 0x2, 0x2, 0x2, 0x7b4, 0x7b5, 0x9, 0xa, 0x2, 0x2, 0x7b5, 0x10d, + 0x3, 0x2, 0x2, 0x2, 0x7b6, 0x7b7, 0x9, 0xb, 0x2, 0x2, 0x7b7, 0x10f, + 0x3, 0x2, 0x2, 0x2, 0x7b8, 0x7ba, 0x9, 0xc, 0x2, 0x2, 0x7b9, 0x7b8, + 0x3, 0x2, 0x2, 0x2, 0x7ba, 0x7bb, 0x3, 0x2, 0x2, 0x2, 0x7bb, 0x7b9, + 0x3, 0x2, 0x2, 0x2, 0x7bb, 0x7bc, 0x3, 0x2, 0x2, 0x2, 0x7bc, 0x7bd, + 0x3, 0x2, 0x2, 0x2, 0x7bd, 0x7be, 0x8, 0x87, 0x4, 0x2, 0x7be, 0x111, + 0x3, 0x2, 0x2, 0x2, 0x7bf, 0x7c0, 0x7, 0x31, 0x2, 0x2, 0x7c0, 0x7c1, + 0x7, 0x2c, 0x2, 0x2, 0x7c1, 0x7c5, 0x3, 0x2, 0x2, 0x2, 0x7c2, 0x7c4, + 0xb, 0x2, 0x2, 0x2, 0x7c3, 0x7c2, 0x3, 0x2, 0x2, 0x2, 0x7c4, 0x7c7, + 0x3, 0x2, 0x2, 0x2, 0x7c5, 0x7c6, 0x3, 0x2, 0x2, 0x2, 0x7c5, 0x7c3, + 0x3, 0x2, 0x2, 0x2, 0x7c6, 0x7c8, 0x3, 0x2, 0x2, 0x2, 0x7c7, 0x7c5, + 0x3, 0x2, 0x2, 0x2, 0x7c8, 0x7c9, 0x7, 0x2c, 0x2, 0x2, 0x7c9, 0x7ca, + 0x7, 0x31, 0x2, 0x2, 0x7ca, 0x7cb, 0x3, 0x2, 0x2, 0x2, 0x7cb, 0x7cc, + 0x8, 0x88, 0x5, 0x2, 0x7cc, 0x113, 0x3, 0x2, 0x2, 0x2, 0x7cd, 0x7ce, + 0x7, 0x31, 0x2, 0x2, 0x7ce, 0x7cf, 0x7, 0x31, 0x2, 0x2, 0x7cf, 0x7d3, + 0x3, 0x2, 0x2, 0x2, 0x7d0, 0x7d2, 0xa, 0xd, 0x2, 0x2, 0x7d1, 0x7d0, + 0x3, 0x2, 0x2, 0x2, 0x7d2, 0x7d5, 0x3, 0x2, 0x2, 0x2, 0x7d3, 0x7d1, + 0x3, 0x2, 0x2, 0x2, 0x7d3, 0x7d4, 0x3, 0x2, 0x2, 0x2, 0x7d4, 0x7d6, + 0x3, 0x2, 0x2, 0x2, 0x7d5, 0x7d3, 0x3, 0x2, 0x2, 0x2, 0x7d6, 0x7d7, + 0x8, 0x89, 0x5, 0x2, 0x7d7, 0x115, 0x3, 0x2, 0x2, 0x2, 0x7d8, 0x7d9, + 0x7, 0x24, 0x2, 0x2, 0x7d9, 0x7da, 0x7, 0x67, 0x2, 0x2, 0x7da, 0x7db, + 0x7, 0x78, 0x2, 0x2, 0x7db, 0x7dc, 0x7, 0x6f, 0x2, 0x2, 0x7dc, 0x7dd, + 0x7, 0x63, 0x2, 0x2, 0x7dd, 0x7de, 0x7, 0x75, 0x2, 0x2, 0x7de, 0x7df, + 0x7, 0x6f, 0x2, 0x2, 0x7df, 0x7e0, 0x7, 0x24, 0x2, 0x2, 0x7e0, 0x117, + 0x3, 0x2, 0x2, 0x2, 0x7e1, 0x7e2, 0x7, 0x7d, 0x2, 0x2, 0x7e2, 0x7e3, + 0x3, 0x2, 0x2, 0x2, 0x7e3, 0x7e4, 0x8, 0x8b, 0x6, 0x2, 0x7e4, 0x7e5, + 0x8, 0x8b, 0x7, 0x2, 0x7e5, 0x119, 0x3, 0x2, 0x2, 0x2, 0x7e6, 0x7e8, + 0x9, 0xc, 0x2, 0x2, 0x7e7, 0x7e6, 0x3, 0x2, 0x2, 0x2, 0x7e8, 0x7e9, + 0x3, 0x2, 0x2, 0x2, 0x7e9, 0x7e7, 0x3, 0x2, 0x2, 0x2, 0x7e9, 0x7ea, + 0x3, 0x2, 0x2, 0x2, 0x7ea, 0x7eb, 0x3, 0x2, 0x2, 0x2, 0x7eb, 0x7ec, + 0x8, 0x8c, 0x4, 0x2, 0x7ec, 0x11b, 0x3, 0x2, 0x2, 0x2, 0x7ed, 0x7ee, + 0x7, 0x31, 0x2, 0x2, 0x7ee, 0x7ef, 0x7, 0x2c, 0x2, 0x2, 0x7ef, 0x7f3, + 0x3, 0x2, 0x2, 0x2, 0x7f0, 0x7f2, 0xb, 0x2, 0x2, 0x2, 0x7f1, 0x7f0, + 0x3, 0x2, 0x2, 0x2, 0x7f2, 0x7f5, 0x3, 0x2, 0x2, 0x2, 0x7f3, 0x7f4, + 0x3, 0x2, 0x2, 0x2, 0x7f3, 0x7f1, 0x3, 0x2, 0x2, 0x2, 0x7f4, 0x7f6, + 0x3, 0x2, 0x2, 0x2, 0x7f5, 0x7f3, 0x3, 0x2, 0x2, 0x2, 0x7f6, 0x7f7, + 0x7, 0x2c, 0x2, 0x2, 0x7f7, 0x7f8, 0x7, 0x31, 0x2, 0x2, 0x7f8, 0x7f9, + 0x3, 0x2, 0x2, 0x2, 0x7f9, 0x7fa, 0x8, 0x8d, 0x5, 0x2, 0x7fa, 0x11d, + 0x3, 0x2, 0x2, 0x2, 0x7fb, 0x7fc, 0x7, 0x31, 0x2, 0x2, 0x7fc, 0x7fd, + 0x7, 0x31, 0x2, 0x2, 0x7fd, 0x801, 0x3, 0x2, 0x2, 0x2, 0x7fe, 0x800, + 0xa, 0xd, 0x2, 0x2, 0x7ff, 0x7fe, 0x3, 0x2, 0x2, 0x2, 0x800, 0x803, + 0x3, 0x2, 0x2, 0x2, 0x801, 0x7ff, 0x3, 0x2, 0x2, 0x2, 0x801, 0x802, + 0x3, 0x2, 0x2, 0x2, 0x802, 0x804, 0x3, 0x2, 0x2, 0x2, 0x803, 0x801, + 0x3, 0x2, 0x2, 0x2, 0x804, 0x805, 0x8, 0x8e, 0x5, 0x2, 0x805, 0x11f, + 0x3, 0x2, 0x2, 0x2, 0x806, 0x807, 0x7, 0x64, 0x2, 0x2, 0x807, 0x808, + 0x7, 0x74, 0x2, 0x2, 0x808, 0x809, 0x7, 0x67, 0x2, 0x2, 0x809, 0x80a, + 0x7, 0x63, 0x2, 0x2, 0x80a, 0x80b, 0x7, 0x6d, 0x2, 0x2, 0x80b, 0x121, + 0x3, 0x2, 0x2, 0x2, 0x80c, 0x80d, 0x7, 0x65, 0x2, 0x2, 0x80d, 0x80e, + 0x7, 0x63, 0x2, 0x2, 0x80e, 0x80f, 0x7, 0x75, 0x2, 0x2, 0x80f, 0x810, + 0x7, 0x67, 0x2, 0x2, 0x810, 0x123, 0x3, 0x2, 0x2, 0x2, 0x811, 0x812, + 0x7, 0x65, 0x2, 0x2, 0x812, 0x813, 0x7, 0x71, 0x2, 0x2, 0x813, 0x814, + 0x7, 0x70, 0x2, 0x2, 0x814, 0x815, 0x7, 0x76, 0x2, 0x2, 0x815, 0x816, + 0x7, 0x6b, 0x2, 0x2, 0x816, 0x817, 0x7, 0x70, 0x2, 0x2, 0x817, 0x818, + 0x7, 0x77, 0x2, 0x2, 0x818, 0x819, 0x7, 0x67, 0x2, 0x2, 0x819, 0x125, + 0x3, 0x2, 0x2, 0x2, 0x81a, 0x81b, 0x7, 0x66, 0x2, 0x2, 0x81b, 0x81c, + 0x7, 0x67, 0x2, 0x2, 0x81c, 0x81d, 0x7, 0x68, 0x2, 0x2, 0x81d, 0x81e, + 0x7, 0x63, 0x2, 0x2, 0x81e, 0x81f, 0x7, 0x77, 0x2, 0x2, 0x81f, 0x820, + 0x7, 0x6e, 0x2, 0x2, 0x820, 0x821, 0x7, 0x76, 0x2, 0x2, 0x821, 0x127, + 0x3, 0x2, 0x2, 0x2, 0x822, 0x823, 0x7, 0x68, 0x2, 0x2, 0x823, 0x824, + 0x7, 0x63, 0x2, 0x2, 0x824, 0x825, 0x7, 0x6e, 0x2, 0x2, 0x825, 0x826, + 0x7, 0x75, 0x2, 0x2, 0x826, 0x827, 0x7, 0x67, 0x2, 0x2, 0x827, 0x129, + 0x3, 0x2, 0x2, 0x2, 0x828, 0x829, 0x7, 0x68, 0x2, 0x2, 0x829, 0x82a, + 0x7, 0x71, 0x2, 0x2, 0x82a, 0x82b, 0x7, 0x74, 0x2, 0x2, 0x82b, 0x12b, + 0x3, 0x2, 0x2, 0x2, 0x82c, 0x82d, 0x7, 0x68, 0x2, 0x2, 0x82d, 0x82e, + 0x7, 0x77, 0x2, 0x2, 0x82e, 0x82f, 0x7, 0x70, 0x2, 0x2, 0x82f, 0x830, + 0x7, 0x65, 0x2, 0x2, 0x830, 0x831, 0x7, 0x76, 0x2, 0x2, 0x831, 0x832, + 0x7, 0x6b, 0x2, 0x2, 0x832, 0x833, 0x7, 0x71, 0x2, 0x2, 0x833, 0x834, + 0x7, 0x70, 0x2, 0x2, 0x834, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x835, 0x836, + 0x7, 0x6b, 0x2, 0x2, 0x836, 0x837, 0x7, 0x68, 0x2, 0x2, 0x837, 0x12f, + 0x3, 0x2, 0x2, 0x2, 0x838, 0x839, 0x7, 0x6e, 0x2, 0x2, 0x839, 0x83a, + 0x7, 0x67, 0x2, 0x2, 0x83a, 0x83b, 0x7, 0x63, 0x2, 0x2, 0x83b, 0x83c, + 0x7, 0x78, 0x2, 0x2, 0x83c, 0x83d, 0x7, 0x67, 0x2, 0x2, 0x83d, 0x131, + 0x3, 0x2, 0x2, 0x2, 0x83e, 0x83f, 0x7, 0x6e, 0x2, 0x2, 0x83f, 0x840, + 0x7, 0x67, 0x2, 0x2, 0x840, 0x841, 0x7, 0x76, 0x2, 0x2, 0x841, 0x133, + 0x3, 0x2, 0x2, 0x2, 0x842, 0x843, 0x7, 0x75, 0x2, 0x2, 0x843, 0x844, + 0x7, 0x79, 0x2, 0x2, 0x844, 0x845, 0x7, 0x6b, 0x2, 0x2, 0x845, 0x846, + 0x7, 0x76, 0x2, 0x2, 0x846, 0x847, 0x7, 0x65, 0x2, 0x2, 0x847, 0x848, + 0x7, 0x6a, 0x2, 0x2, 0x848, 0x135, 0x3, 0x2, 0x2, 0x2, 0x849, 0x84a, + 0x7, 0x76, 0x2, 0x2, 0x84a, 0x84b, 0x7, 0x74, 0x2, 0x2, 0x84b, 0x84c, + 0x7, 0x77, 0x2, 0x2, 0x84c, 0x84d, 0x7, 0x67, 0x2, 0x2, 0x84d, 0x137, + 0x3, 0x2, 0x2, 0x2, 0x84e, 0x84f, 0x7, 0x75, 0x2, 0x2, 0x84f, 0x850, + 0x7, 0x76, 0x2, 0x2, 0x850, 0x851, 0x7, 0x71, 0x2, 0x2, 0x851, 0xa10, + 0x7, 0x72, 0x2, 0x2, 0x852, 0x853, 0x7, 0x63, 0x2, 0x2, 0x853, 0x854, + 0x7, 0x66, 0x2, 0x2, 0x854, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x855, 0x856, + 0x7, 0x75, 0x2, 0x2, 0x856, 0x857, 0x7, 0x77, 0x2, 0x2, 0x857, 0xa10, + 0x7, 0x64, 0x2, 0x2, 0x858, 0x859, 0x7, 0x6f, 0x2, 0x2, 0x859, 0x85a, + 0x7, 0x77, 0x2, 0x2, 0x85a, 0xa10, 0x7, 0x6e, 0x2, 0x2, 0x85b, 0x85c, + 0x7, 0x66, 0x2, 0x2, 0x85c, 0x85d, 0x7, 0x6b, 0x2, 0x2, 0x85d, 0xa10, + 0x7, 0x78, 0x2, 0x2, 0x85e, 0x85f, 0x7, 0x75, 0x2, 0x2, 0x85f, 0x860, + 0x7, 0x66, 0x2, 0x2, 0x860, 0x861, 0x7, 0x6b, 0x2, 0x2, 0x861, 0xa10, + 0x7, 0x78, 0x2, 0x2, 0x862, 0x863, 0x7, 0x6f, 0x2, 0x2, 0x863, 0x864, + 0x7, 0x71, 0x2, 0x2, 0x864, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x865, 0x866, + 0x7, 0x75, 0x2, 0x2, 0x866, 0x867, 0x7, 0x6f, 0x2, 0x2, 0x867, 0x868, + 0x7, 0x71, 0x2, 0x2, 0x868, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x869, 0x86a, + 0x7, 0x67, 0x2, 0x2, 0x86a, 0x86b, 0x7, 0x7a, 0x2, 0x2, 0x86b, 0xa10, + 0x7, 0x72, 0x2, 0x2, 0x86c, 0x86d, 0x7, 0x70, 0x2, 0x2, 0x86d, 0x86e, + 0x7, 0x71, 0x2, 0x2, 0x86e, 0xa10, 0x7, 0x76, 0x2, 0x2, 0x86f, 0x870, + 0x7, 0x6e, 0x2, 0x2, 0x870, 0xa10, 0x7, 0x76, 0x2, 0x2, 0x871, 0x872, + 0x7, 0x69, 0x2, 0x2, 0x872, 0xa10, 0x7, 0x76, 0x2, 0x2, 0x873, 0x874, + 0x7, 0x75, 0x2, 0x2, 0x874, 0x875, 0x7, 0x6e, 0x2, 0x2, 0x875, 0xa10, + 0x7, 0x76, 0x2, 0x2, 0x876, 0x877, 0x7, 0x75, 0x2, 0x2, 0x877, 0x878, + 0x7, 0x69, 0x2, 0x2, 0x878, 0xa10, 0x7, 0x76, 0x2, 0x2, 0x879, 0x87a, + 0x7, 0x67, 0x2, 0x2, 0x87a, 0xa10, 0x7, 0x73, 0x2, 0x2, 0x87b, 0x87c, + 0x7, 0x6b, 0x2, 0x2, 0x87c, 0x87d, 0x7, 0x75, 0x2, 0x2, 0x87d, 0x87e, + 0x7, 0x7c, 0x2, 0x2, 0x87e, 0x87f, 0x7, 0x67, 0x2, 0x2, 0x87f, 0x880, + 0x7, 0x74, 0x2, 0x2, 0x880, 0xa10, 0x7, 0x71, 0x2, 0x2, 0x881, 0x882, + 0x7, 0x63, 0x2, 0x2, 0x882, 0x883, 0x7, 0x70, 0x2, 0x2, 0x883, 0xa10, + 0x7, 0x66, 0x2, 0x2, 0x884, 0x885, 0x7, 0x71, 0x2, 0x2, 0x885, 0xa10, + 0x7, 0x74, 0x2, 0x2, 0x886, 0x887, 0x7, 0x7a, 0x2, 0x2, 0x887, 0x888, + 0x7, 0x71, 0x2, 0x2, 0x888, 0xa10, 0x7, 0x74, 0x2, 0x2, 0x889, 0x88a, + 0x7, 0x64, 0x2, 0x2, 0x88a, 0x88b, 0x7, 0x7b, 0x2, 0x2, 0x88b, 0x88c, + 0x7, 0x76, 0x2, 0x2, 0x88c, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x88d, 0x88e, + 0x7, 0x75, 0x2, 0x2, 0x88e, 0x88f, 0x7, 0x6a, 0x2, 0x2, 0x88f, 0xa10, + 0x7, 0x6e, 0x2, 0x2, 0x890, 0x891, 0x7, 0x75, 0x2, 0x2, 0x891, 0x892, + 0x7, 0x6a, 0x2, 0x2, 0x892, 0xa10, 0x7, 0x74, 0x2, 0x2, 0x893, 0x894, + 0x7, 0x75, 0x2, 0x2, 0x894, 0x895, 0x7, 0x63, 0x2, 0x2, 0x895, 0xa10, + 0x7, 0x74, 0x2, 0x2, 0x896, 0x897, 0x7, 0x63, 0x2, 0x2, 0x897, 0x898, + 0x7, 0x66, 0x2, 0x2, 0x898, 0x899, 0x7, 0x66, 0x2, 0x2, 0x899, 0x89a, + 0x7, 0x6f, 0x2, 0x2, 0x89a, 0x89b, 0x7, 0x71, 0x2, 0x2, 0x89b, 0xa10, + 0x7, 0x66, 0x2, 0x2, 0x89c, 0x89d, 0x7, 0x6f, 0x2, 0x2, 0x89d, 0x89e, + 0x7, 0x77, 0x2, 0x2, 0x89e, 0x89f, 0x7, 0x6e, 0x2, 0x2, 0x89f, 0x8a0, + 0x7, 0x6f, 0x2, 0x2, 0x8a0, 0x8a1, 0x7, 0x71, 0x2, 0x2, 0x8a1, 0xa10, + 0x7, 0x66, 0x2, 0x2, 0x8a2, 0x8a3, 0x7, 0x75, 0x2, 0x2, 0x8a3, 0x8a4, + 0x7, 0x6b, 0x2, 0x2, 0x8a4, 0x8a5, 0x7, 0x69, 0x2, 0x2, 0x8a5, 0x8a6, + 0x7, 0x70, 0x2, 0x2, 0x8a6, 0x8a7, 0x7, 0x67, 0x2, 0x2, 0x8a7, 0x8a8, + 0x7, 0x7a, 0x2, 0x2, 0x8a8, 0x8a9, 0x7, 0x76, 0x2, 0x2, 0x8a9, 0x8aa, + 0x7, 0x67, 0x2, 0x2, 0x8aa, 0x8ab, 0x7, 0x70, 0x2, 0x2, 0x8ab, 0xa10, + 0x7, 0x66, 0x2, 0x2, 0x8ac, 0x8ad, 0x7, 0x6d, 0x2, 0x2, 0x8ad, 0x8ae, + 0x7, 0x67, 0x2, 0x2, 0x8ae, 0x8af, 0x7, 0x65, 0x2, 0x2, 0x8af, 0x8b0, + 0x7, 0x65, 0x2, 0x2, 0x8b0, 0x8b1, 0x7, 0x63, 0x2, 0x2, 0x8b1, 0x8b2, + 0x7, 0x6d, 0x2, 0x2, 0x8b2, 0x8b3, 0x7, 0x34, 0x2, 0x2, 0x8b3, 0x8b4, + 0x7, 0x37, 0x2, 0x2, 0x8b4, 0xa10, 0x7, 0x38, 0x2, 0x2, 0x8b5, 0x8b6, + 0x7, 0x72, 0x2, 0x2, 0x8b6, 0x8b7, 0x7, 0x71, 0x2, 0x2, 0x8b7, 0xa10, + 0x7, 0x72, 0x2, 0x2, 0x8b8, 0x8b9, 0x7, 0x6f, 0x2, 0x2, 0x8b9, 0x8ba, + 0x7, 0x6e, 0x2, 0x2, 0x8ba, 0x8bb, 0x7, 0x71, 0x2, 0x2, 0x8bb, 0x8bc, + 0x7, 0x63, 0x2, 0x2, 0x8bc, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x8bd, 0x8be, + 0x7, 0x6f, 0x2, 0x2, 0x8be, 0x8bf, 0x7, 0x75, 0x2, 0x2, 0x8bf, 0x8c0, + 0x7, 0x76, 0x2, 0x2, 0x8c0, 0x8c1, 0x7, 0x71, 0x2, 0x2, 0x8c1, 0x8c2, + 0x7, 0x74, 0x2, 0x2, 0x8c2, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x8c3, 0x8c4, + 0x7, 0x6f, 0x2, 0x2, 0x8c4, 0x8c5, 0x7, 0x75, 0x2, 0x2, 0x8c5, 0x8c6, + 0x7, 0x76, 0x2, 0x2, 0x8c6, 0x8c7, 0x7, 0x71, 0x2, 0x2, 0x8c7, 0x8c8, + 0x7, 0x74, 0x2, 0x2, 0x8c8, 0x8c9, 0x7, 0x67, 0x2, 0x2, 0x8c9, 0xa10, + 0x7, 0x3a, 0x2, 0x2, 0x8ca, 0x8cb, 0x7, 0x75, 0x2, 0x2, 0x8cb, 0x8cc, + 0x7, 0x6e, 0x2, 0x2, 0x8cc, 0x8cd, 0x7, 0x71, 0x2, 0x2, 0x8cd, 0x8ce, + 0x7, 0x63, 0x2, 0x2, 0x8ce, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x8cf, 0x8d0, + 0x7, 0x75, 0x2, 0x2, 0x8d0, 0x8d1, 0x7, 0x75, 0x2, 0x2, 0x8d1, 0x8d2, + 0x7, 0x76, 0x2, 0x2, 0x8d2, 0x8d3, 0x7, 0x71, 0x2, 0x2, 0x8d3, 0x8d4, + 0x7, 0x74, 0x2, 0x2, 0x8d4, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x8d5, 0x8d6, + 0x7, 0x6f, 0x2, 0x2, 0x8d6, 0x8d7, 0x7, 0x75, 0x2, 0x2, 0x8d7, 0x8d8, + 0x7, 0x6b, 0x2, 0x2, 0x8d8, 0x8d9, 0x7, 0x7c, 0x2, 0x2, 0x8d9, 0xa10, + 0x7, 0x67, 0x2, 0x2, 0x8da, 0x8db, 0x7, 0x69, 0x2, 0x2, 0x8db, 0x8dc, + 0x7, 0x63, 0x2, 0x2, 0x8dc, 0xa10, 0x7, 0x75, 0x2, 0x2, 0x8dd, 0x8de, + 0x7, 0x63, 0x2, 0x2, 0x8de, 0x8df, 0x7, 0x66, 0x2, 0x2, 0x8df, 0x8e0, + 0x7, 0x66, 0x2, 0x2, 0x8e0, 0x8e1, 0x7, 0x74, 0x2, 0x2, 0x8e1, 0x8e2, + 0x7, 0x67, 0x2, 0x2, 0x8e2, 0x8e3, 0x7, 0x75, 0x2, 0x2, 0x8e3, 0xa10, + 0x7, 0x75, 0x2, 0x2, 0x8e4, 0x8e5, 0x7, 0x64, 0x2, 0x2, 0x8e5, 0x8e6, + 0x7, 0x63, 0x2, 0x2, 0x8e6, 0x8e7, 0x7, 0x6e, 0x2, 0x2, 0x8e7, 0x8e8, + 0x7, 0x63, 0x2, 0x2, 0x8e8, 0x8e9, 0x7, 0x70, 0x2, 0x2, 0x8e9, 0x8ea, + 0x7, 0x65, 0x2, 0x2, 0x8ea, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x8eb, 0x8ec, + 0x7, 0x75, 0x2, 0x2, 0x8ec, 0x8ed, 0x7, 0x67, 0x2, 0x2, 0x8ed, 0x8ee, + 0x7, 0x6e, 0x2, 0x2, 0x8ee, 0x8ef, 0x7, 0x68, 0x2, 0x2, 0x8ef, 0x8f0, + 0x7, 0x64, 0x2, 0x2, 0x8f0, 0x8f1, 0x7, 0x63, 0x2, 0x2, 0x8f1, 0x8f2, + 0x7, 0x6e, 0x2, 0x2, 0x8f2, 0x8f3, 0x7, 0x63, 0x2, 0x2, 0x8f3, 0x8f4, + 0x7, 0x70, 0x2, 0x2, 0x8f4, 0x8f5, 0x7, 0x65, 0x2, 0x2, 0x8f5, 0xa10, + 0x7, 0x67, 0x2, 0x2, 0x8f6, 0x8f7, 0x7, 0x65, 0x2, 0x2, 0x8f7, 0x8f8, + 0x7, 0x63, 0x2, 0x2, 0x8f8, 0x8f9, 0x7, 0x6e, 0x2, 0x2, 0x8f9, 0x8fa, + 0x7, 0x6e, 0x2, 0x2, 0x8fa, 0x8fb, 0x7, 0x67, 0x2, 0x2, 0x8fb, 0xa10, + 0x7, 0x74, 0x2, 0x2, 0x8fc, 0x8fd, 0x7, 0x65, 0x2, 0x2, 0x8fd, 0x8fe, + 0x7, 0x63, 0x2, 0x2, 0x8fe, 0x8ff, 0x7, 0x6e, 0x2, 0x2, 0x8ff, 0x900, + 0x7, 0x6e, 0x2, 0x2, 0x900, 0x901, 0x7, 0x78, 0x2, 0x2, 0x901, 0x902, + 0x7, 0x63, 0x2, 0x2, 0x902, 0x903, 0x7, 0x6e, 0x2, 0x2, 0x903, 0x904, + 0x7, 0x77, 0x2, 0x2, 0x904, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x905, 0x906, + 0x7, 0x65, 0x2, 0x2, 0x906, 0x907, 0x7, 0x63, 0x2, 0x2, 0x907, 0x908, + 0x7, 0x6e, 0x2, 0x2, 0x908, 0x909, 0x7, 0x6e, 0x2, 0x2, 0x909, 0x90a, + 0x7, 0x66, 0x2, 0x2, 0x90a, 0x90b, 0x7, 0x63, 0x2, 0x2, 0x90b, 0x90c, + 0x7, 0x76, 0x2, 0x2, 0x90c, 0x90d, 0x7, 0x63, 0x2, 0x2, 0x90d, 0x90e, + 0x7, 0x6e, 0x2, 0x2, 0x90e, 0x90f, 0x7, 0x71, 0x2, 0x2, 0x90f, 0x910, + 0x7, 0x63, 0x2, 0x2, 0x910, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x911, 0x912, + 0x7, 0x65, 0x2, 0x2, 0x912, 0x913, 0x7, 0x63, 0x2, 0x2, 0x913, 0x914, + 0x7, 0x6e, 0x2, 0x2, 0x914, 0x915, 0x7, 0x6e, 0x2, 0x2, 0x915, 0x916, + 0x7, 0x66, 0x2, 0x2, 0x916, 0x917, 0x7, 0x63, 0x2, 0x2, 0x917, 0x918, + 0x7, 0x76, 0x2, 0x2, 0x918, 0x919, 0x7, 0x63, 0x2, 0x2, 0x919, 0x91a, + 0x7, 0x75, 0x2, 0x2, 0x91a, 0x91b, 0x7, 0x6b, 0x2, 0x2, 0x91b, 0x91c, + 0x7, 0x7c, 0x2, 0x2, 0x91c, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x91d, 0x91e, + 0x7, 0x65, 0x2, 0x2, 0x91e, 0x91f, 0x7, 0x63, 0x2, 0x2, 0x91f, 0x920, + 0x7, 0x6e, 0x2, 0x2, 0x920, 0x921, 0x7, 0x6e, 0x2, 0x2, 0x921, 0x922, + 0x7, 0x66, 0x2, 0x2, 0x922, 0x923, 0x7, 0x63, 0x2, 0x2, 0x923, 0x924, + 0x7, 0x76, 0x2, 0x2, 0x924, 0x925, 0x7, 0x63, 0x2, 0x2, 0x925, 0x926, + 0x7, 0x65, 0x2, 0x2, 0x926, 0x927, 0x7, 0x71, 0x2, 0x2, 0x927, 0x928, + 0x7, 0x72, 0x2, 0x2, 0x928, 0xa10, 0x7, 0x7b, 0x2, 0x2, 0x929, 0x92a, + 0x7, 0x67, 0x2, 0x2, 0x92a, 0x92b, 0x7, 0x7a, 0x2, 0x2, 0x92b, 0x92c, + 0x7, 0x76, 0x2, 0x2, 0x92c, 0x92d, 0x7, 0x65, 0x2, 0x2, 0x92d, 0x92e, + 0x7, 0x71, 0x2, 0x2, 0x92e, 0x92f, 0x7, 0x66, 0x2, 0x2, 0x92f, 0x930, + 0x7, 0x67, 0x2, 0x2, 0x930, 0x931, 0x7, 0x75, 0x2, 0x2, 0x931, 0x932, + 0x7, 0x6b, 0x2, 0x2, 0x932, 0x933, 0x7, 0x7c, 0x2, 0x2, 0x933, 0xa10, + 0x7, 0x67, 0x2, 0x2, 0x934, 0x935, 0x7, 0x67, 0x2, 0x2, 0x935, 0x936, + 0x7, 0x7a, 0x2, 0x2, 0x936, 0x937, 0x7, 0x76, 0x2, 0x2, 0x937, 0x938, + 0x7, 0x65, 0x2, 0x2, 0x938, 0x939, 0x7, 0x71, 0x2, 0x2, 0x939, 0x93a, + 0x7, 0x66, 0x2, 0x2, 0x93a, 0x93b, 0x7, 0x67, 0x2, 0x2, 0x93b, 0x93c, + 0x7, 0x65, 0x2, 0x2, 0x93c, 0x93d, 0x7, 0x71, 0x2, 0x2, 0x93d, 0x93e, + 0x7, 0x72, 0x2, 0x2, 0x93e, 0xa10, 0x7, 0x7b, 0x2, 0x2, 0x93f, 0x940, + 0x7, 0x74, 0x2, 0x2, 0x940, 0x941, 0x7, 0x67, 0x2, 0x2, 0x941, 0x942, + 0x7, 0x76, 0x2, 0x2, 0x942, 0x943, 0x7, 0x77, 0x2, 0x2, 0x943, 0x944, + 0x7, 0x74, 0x2, 0x2, 0x944, 0x945, 0x7, 0x70, 0x2, 0x2, 0x945, 0x946, + 0x7, 0x66, 0x2, 0x2, 0x946, 0x947, 0x7, 0x63, 0x2, 0x2, 0x947, 0x948, + 0x7, 0x76, 0x2, 0x2, 0x948, 0x949, 0x7, 0x63, 0x2, 0x2, 0x949, 0x94a, + 0x7, 0x75, 0x2, 0x2, 0x94a, 0x94b, 0x7, 0x6b, 0x2, 0x2, 0x94b, 0x94c, + 0x7, 0x7c, 0x2, 0x2, 0x94c, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x94d, 0x94e, + 0x7, 0x74, 0x2, 0x2, 0x94e, 0x94f, 0x7, 0x67, 0x2, 0x2, 0x94f, 0x950, + 0x7, 0x76, 0x2, 0x2, 0x950, 0x951, 0x7, 0x77, 0x2, 0x2, 0x951, 0x952, + 0x7, 0x74, 0x2, 0x2, 0x952, 0x953, 0x7, 0x70, 0x2, 0x2, 0x953, 0x954, + 0x7, 0x66, 0x2, 0x2, 0x954, 0x955, 0x7, 0x63, 0x2, 0x2, 0x955, 0x956, + 0x7, 0x76, 0x2, 0x2, 0x956, 0x957, 0x7, 0x63, 0x2, 0x2, 0x957, 0x958, + 0x7, 0x65, 0x2, 0x2, 0x958, 0x959, 0x7, 0x71, 0x2, 0x2, 0x959, 0x95a, + 0x7, 0x72, 0x2, 0x2, 0x95a, 0xa10, 0x7, 0x7b, 0x2, 0x2, 0x95b, 0x95c, + 0x7, 0x67, 0x2, 0x2, 0x95c, 0x95d, 0x7, 0x7a, 0x2, 0x2, 0x95d, 0x95e, + 0x7, 0x76, 0x2, 0x2, 0x95e, 0x95f, 0x7, 0x65, 0x2, 0x2, 0x95f, 0x960, + 0x7, 0x71, 0x2, 0x2, 0x960, 0x961, 0x7, 0x66, 0x2, 0x2, 0x961, 0x962, + 0x7, 0x67, 0x2, 0x2, 0x962, 0x963, 0x7, 0x6a, 0x2, 0x2, 0x963, 0x964, + 0x7, 0x63, 0x2, 0x2, 0x964, 0x965, 0x7, 0x75, 0x2, 0x2, 0x965, 0xa10, + 0x7, 0x6a, 0x2, 0x2, 0x966, 0x967, 0x7, 0x65, 0x2, 0x2, 0x967, 0x968, + 0x7, 0x74, 0x2, 0x2, 0x968, 0x969, 0x7, 0x67, 0x2, 0x2, 0x969, 0x96a, + 0x7, 0x63, 0x2, 0x2, 0x96a, 0x96b, 0x7, 0x76, 0x2, 0x2, 0x96b, 0xa10, + 0x7, 0x67, 0x2, 0x2, 0x96c, 0x96d, 0x7, 0x65, 0x2, 0x2, 0x96d, 0x96e, + 0x7, 0x74, 0x2, 0x2, 0x96e, 0x96f, 0x7, 0x67, 0x2, 0x2, 0x96f, 0x970, + 0x7, 0x63, 0x2, 0x2, 0x970, 0x971, 0x7, 0x76, 0x2, 0x2, 0x971, 0x972, + 0x7, 0x67, 0x2, 0x2, 0x972, 0xa10, 0x7, 0x34, 0x2, 0x2, 0x973, 0x974, + 0x7, 0x65, 0x2, 0x2, 0x974, 0x975, 0x7, 0x63, 0x2, 0x2, 0x975, 0x976, + 0x7, 0x6e, 0x2, 0x2, 0x976, 0xa10, 0x7, 0x6e, 0x2, 0x2, 0x977, 0x978, + 0x7, 0x65, 0x2, 0x2, 0x978, 0x979, 0x7, 0x63, 0x2, 0x2, 0x979, 0x97a, + 0x7, 0x6e, 0x2, 0x2, 0x97a, 0x97b, 0x7, 0x6e, 0x2, 0x2, 0x97b, 0x97c, + 0x7, 0x65, 0x2, 0x2, 0x97c, 0x97d, 0x7, 0x71, 0x2, 0x2, 0x97d, 0x97e, + 0x7, 0x66, 0x2, 0x2, 0x97e, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x97f, 0x980, + 0x7, 0x66, 0x2, 0x2, 0x980, 0x981, 0x7, 0x67, 0x2, 0x2, 0x981, 0x982, + 0x7, 0x6e, 0x2, 0x2, 0x982, 0x983, 0x7, 0x67, 0x2, 0x2, 0x983, 0x984, + 0x7, 0x69, 0x2, 0x2, 0x984, 0x985, 0x7, 0x63, 0x2, 0x2, 0x985, 0x986, + 0x7, 0x76, 0x2, 0x2, 0x986, 0x987, 0x7, 0x67, 0x2, 0x2, 0x987, 0x988, + 0x7, 0x65, 0x2, 0x2, 0x988, 0x989, 0x7, 0x63, 0x2, 0x2, 0x989, 0x98a, + 0x7, 0x6e, 0x2, 0x2, 0x98a, 0xa10, 0x7, 0x6e, 0x2, 0x2, 0x98b, 0x98c, + 0x7, 0x75, 0x2, 0x2, 0x98c, 0x98d, 0x7, 0x76, 0x2, 0x2, 0x98d, 0x98e, + 0x7, 0x63, 0x2, 0x2, 0x98e, 0x98f, 0x7, 0x76, 0x2, 0x2, 0x98f, 0x990, + 0x7, 0x6b, 0x2, 0x2, 0x990, 0x991, 0x7, 0x65, 0x2, 0x2, 0x991, 0x992, + 0x7, 0x65, 0x2, 0x2, 0x992, 0x993, 0x7, 0x63, 0x2, 0x2, 0x993, 0x994, + 0x7, 0x6e, 0x2, 0x2, 0x994, 0xa10, 0x7, 0x6e, 0x2, 0x2, 0x995, 0x996, + 0x7, 0x74, 0x2, 0x2, 0x996, 0x997, 0x7, 0x67, 0x2, 0x2, 0x997, 0x998, + 0x7, 0x76, 0x2, 0x2, 0x998, 0x999, 0x7, 0x77, 0x2, 0x2, 0x999, 0x99a, + 0x7, 0x74, 0x2, 0x2, 0x99a, 0xa10, 0x7, 0x70, 0x2, 0x2, 0x99b, 0x99c, + 0x7, 0x74, 0x2, 0x2, 0x99c, 0x99d, 0x7, 0x67, 0x2, 0x2, 0x99d, 0x99e, + 0x7, 0x78, 0x2, 0x2, 0x99e, 0x99f, 0x7, 0x67, 0x2, 0x2, 0x99f, 0x9a0, + 0x7, 0x74, 0x2, 0x2, 0x9a0, 0xa10, 0x7, 0x76, 0x2, 0x2, 0x9a1, 0x9a2, + 0x7, 0x75, 0x2, 0x2, 0x9a2, 0x9a3, 0x7, 0x67, 0x2, 0x2, 0x9a3, 0x9a4, + 0x7, 0x6e, 0x2, 0x2, 0x9a4, 0x9a5, 0x7, 0x68, 0x2, 0x2, 0x9a5, 0x9a6, + 0x7, 0x66, 0x2, 0x2, 0x9a6, 0x9a7, 0x7, 0x67, 0x2, 0x2, 0x9a7, 0x9a8, + 0x7, 0x75, 0x2, 0x2, 0x9a8, 0x9a9, 0x7, 0x76, 0x2, 0x2, 0x9a9, 0x9aa, + 0x7, 0x74, 0x2, 0x2, 0x9aa, 0x9ab, 0x7, 0x77, 0x2, 0x2, 0x9ab, 0x9ac, + 0x7, 0x65, 0x2, 0x2, 0x9ac, 0xa10, 0x7, 0x76, 0x2, 0x2, 0x9ad, 0x9ae, + 0x7, 0x6b, 0x2, 0x2, 0x9ae, 0x9af, 0x7, 0x70, 0x2, 0x2, 0x9af, + }; + static uint16_t serializedATNSegment1[] = { + 0x9b0, 0x7, 0x78, 0x2, 0x2, 0x9b0, 0x9b1, 0x7, 0x63, 0x2, 0x2, 0x9b1, + 0x9b2, 0x7, 0x6e, 0x2, 0x2, 0x9b2, 0x9b3, 0x7, 0x6b, 0x2, 0x2, 0x9b3, + 0xa10, 0x7, 0x66, 0x2, 0x2, 0x9b4, 0x9b5, 0x7, 0x6e, 0x2, 0x2, 0x9b5, + 0x9b6, 0x7, 0x71, 0x2, 0x2, 0x9b6, 0x9b7, 0x7, 0x69, 0x2, 0x2, 0x9b7, + 0xa10, 0x7, 0x32, 0x2, 0x2, 0x9b8, 0x9b9, 0x7, 0x6e, 0x2, 0x2, 0x9b9, + 0x9ba, 0x7, 0x71, 0x2, 0x2, 0x9ba, 0x9bb, 0x7, 0x69, 0x2, 0x2, 0x9bb, + 0xa10, 0x7, 0x33, 0x2, 0x2, 0x9bc, 0x9bd, 0x7, 0x6e, 0x2, 0x2, 0x9bd, + 0x9be, 0x7, 0x71, 0x2, 0x2, 0x9be, 0x9bf, 0x7, 0x69, 0x2, 0x2, 0x9bf, + 0xa10, 0x7, 0x34, 0x2, 0x2, 0x9c0, 0x9c1, 0x7, 0x6e, 0x2, 0x2, 0x9c1, + 0x9c2, 0x7, 0x71, 0x2, 0x2, 0x9c2, 0x9c3, 0x7, 0x69, 0x2, 0x2, 0x9c3, + 0xa10, 0x7, 0x35, 0x2, 0x2, 0x9c4, 0x9c5, 0x7, 0x6e, 0x2, 0x2, 0x9c5, + 0x9c6, 0x7, 0x71, 0x2, 0x2, 0x9c6, 0x9c7, 0x7, 0x69, 0x2, 0x2, 0x9c7, + 0xa10, 0x7, 0x36, 0x2, 0x2, 0x9c8, 0x9c9, 0x7, 0x65, 0x2, 0x2, 0x9c9, + 0x9ca, 0x7, 0x6a, 0x2, 0x2, 0x9ca, 0x9cb, 0x7, 0x63, 0x2, 0x2, 0x9cb, + 0x9cc, 0x7, 0x6b, 0x2, 0x2, 0x9cc, 0x9cd, 0x7, 0x70, 0x2, 0x2, 0x9cd, + 0x9ce, 0x7, 0x6b, 0x2, 0x2, 0x9ce, 0xa10, 0x7, 0x66, 0x2, 0x2, 0x9cf, + 0x9d0, 0x7, 0x71, 0x2, 0x2, 0x9d0, 0x9d1, 0x7, 0x74, 0x2, 0x2, 0x9d1, + 0x9d2, 0x7, 0x6b, 0x2, 0x2, 0x9d2, 0x9d3, 0x7, 0x69, 0x2, 0x2, 0x9d3, + 0x9d4, 0x7, 0x6b, 0x2, 0x2, 0x9d4, 0xa10, 0x7, 0x70, 0x2, 0x2, 0x9d5, + 0x9d6, 0x7, 0x69, 0x2, 0x2, 0x9d6, 0x9d7, 0x7, 0x63, 0x2, 0x2, 0x9d7, + 0x9d8, 0x7, 0x75, 0x2, 0x2, 0x9d8, 0x9d9, 0x7, 0x72, 0x2, 0x2, 0x9d9, + 0x9da, 0x7, 0x74, 0x2, 0x2, 0x9da, 0x9db, 0x7, 0x6b, 0x2, 0x2, 0x9db, + 0x9dc, 0x7, 0x65, 0x2, 0x2, 0x9dc, 0xa10, 0x7, 0x67, 0x2, 0x2, 0x9dd, + 0x9de, 0x7, 0x64, 0x2, 0x2, 0x9de, 0x9df, 0x7, 0x6e, 0x2, 0x2, 0x9df, + 0x9e0, 0x7, 0x71, 0x2, 0x2, 0x9e0, 0x9e1, 0x7, 0x65, 0x2, 0x2, 0x9e1, + 0x9e2, 0x7, 0x6d, 0x2, 0x2, 0x9e2, 0x9e3, 0x7, 0x6a, 0x2, 0x2, 0x9e3, + 0x9e4, 0x7, 0x63, 0x2, 0x2, 0x9e4, 0x9e5, 0x7, 0x75, 0x2, 0x2, 0x9e5, + 0xa10, 0x7, 0x6a, 0x2, 0x2, 0x9e6, 0x9e7, 0x7, 0x65, 0x2, 0x2, 0x9e7, + 0x9e8, 0x7, 0x71, 0x2, 0x2, 0x9e8, 0x9e9, 0x7, 0x6b, 0x2, 0x2, 0x9e9, + 0x9ea, 0x7, 0x70, 0x2, 0x2, 0x9ea, 0x9eb, 0x7, 0x64, 0x2, 0x2, 0x9eb, + 0x9ec, 0x7, 0x63, 0x2, 0x2, 0x9ec, 0x9ed, 0x7, 0x75, 0x2, 0x2, 0x9ed, + 0xa10, 0x7, 0x67, 0x2, 0x2, 0x9ee, 0x9ef, 0x7, 0x76, 0x2, 0x2, 0x9ef, + 0x9f0, 0x7, 0x6b, 0x2, 0x2, 0x9f0, 0x9f1, 0x7, 0x6f, 0x2, 0x2, 0x9f1, + 0x9f2, 0x7, 0x67, 0x2, 0x2, 0x9f2, 0x9f3, 0x7, 0x75, 0x2, 0x2, 0x9f3, + 0x9f4, 0x7, 0x76, 0x2, 0x2, 0x9f4, 0x9f5, 0x7, 0x63, 0x2, 0x2, 0x9f5, + 0x9f6, 0x7, 0x6f, 0x2, 0x2, 0x9f6, 0xa10, 0x7, 0x72, 0x2, 0x2, 0x9f7, + 0x9f8, 0x7, 0x70, 0x2, 0x2, 0x9f8, 0x9f9, 0x7, 0x77, 0x2, 0x2, 0x9f9, + 0x9fa, 0x7, 0x6f, 0x2, 0x2, 0x9fa, 0x9fb, 0x7, 0x64, 0x2, 0x2, 0x9fb, + 0x9fc, 0x7, 0x67, 0x2, 0x2, 0x9fc, 0xa10, 0x7, 0x74, 0x2, 0x2, 0x9fd, + 0x9fe, 0x7, 0x66, 0x2, 0x2, 0x9fe, 0x9ff, 0x7, 0x6b, 0x2, 0x2, 0x9ff, + 0xa00, 0x7, 0x68, 0x2, 0x2, 0xa00, 0xa01, 0x7, 0x68, 0x2, 0x2, 0xa01, + 0xa02, 0x7, 0x6b, 0x2, 0x2, 0xa02, 0xa03, 0x7, 0x65, 0x2, 0x2, 0xa03, + 0xa04, 0x7, 0x77, 0x2, 0x2, 0xa04, 0xa05, 0x7, 0x6e, 0x2, 0x2, 0xa05, + 0xa06, 0x7, 0x76, 0x2, 0x2, 0xa06, 0xa10, 0x7, 0x7b, 0x2, 0x2, 0xa07, + 0xa08, 0x7, 0x69, 0x2, 0x2, 0xa08, 0xa09, 0x7, 0x63, 0x2, 0x2, 0xa09, + 0xa0a, 0x7, 0x75, 0x2, 0x2, 0xa0a, 0xa0b, 0x7, 0x6e, 0x2, 0x2, 0xa0b, + 0xa0c, 0x7, 0x6b, 0x2, 0x2, 0xa0c, 0xa0d, 0x7, 0x6f, 0x2, 0x2, 0xa0d, + 0xa0e, 0x7, 0x6b, 0x2, 0x2, 0xa0e, 0xa10, 0x7, 0x76, 0x2, 0x2, 0xa0f, + 0x84e, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x852, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x855, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x858, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x85b, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x85e, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x862, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x865, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x869, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x86c, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x86f, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x871, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x873, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x876, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x879, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x87b, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x881, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x884, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x886, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x889, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x88d, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x890, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x893, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x896, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x89c, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8a2, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8ac, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8b5, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8b8, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8bd, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8c3, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8ca, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8cf, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8d5, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8da, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8dd, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8e4, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8eb, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x8f6, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x8fc, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x905, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x911, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x91d, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x929, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x934, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x93f, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x94d, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x95b, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x966, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x96c, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x973, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x977, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x97f, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x98b, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x995, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x99b, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9a1, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9ad, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9b4, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9b8, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9bc, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9c0, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9c4, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9c8, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9cf, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9d5, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9dd, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9e6, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9ee, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0x9f7, 0x3, 0x2, 0x2, 0x2, 0xa0f, + 0x9fd, 0x3, 0x2, 0x2, 0x2, 0xa0f, 0xa07, 0x3, 0x2, 0x2, 0x2, 0xa10, + 0x139, 0x3, 0x2, 0x2, 0x2, 0xa11, 0xa12, 0x7, 0x7d, 0x2, 0x2, 0xa12, + 0xa13, 0x3, 0x2, 0x2, 0x2, 0xa13, 0xa14, 0x8, 0x9c, 0x7, 0x2, 0xa14, + 0x13b, 0x3, 0x2, 0x2, 0x2, 0xa15, 0xa16, 0x7, 0x7f, 0x2, 0x2, 0xa16, + 0xa17, 0x3, 0x2, 0x2, 0x2, 0xa17, 0xa18, 0x8, 0x9d, 0x6, 0x2, 0xa18, + 0x13d, 0x3, 0x2, 0x2, 0x2, 0xa19, 0xa1a, 0x7, 0x2a, 0x2, 0x2, 0xa1a, + 0x13f, 0x3, 0x2, 0x2, 0x2, 0xa1b, 0xa1c, 0x7, 0x2b, 0x2, 0x2, 0xa1c, + 0x141, 0x3, 0x2, 0x2, 0x2, 0xa1d, 0xa1e, 0x7, 0x3c, 0x2, 0x2, 0xa1e, + 0xa1f, 0x7, 0x3f, 0x2, 0x2, 0xa1f, 0x143, 0x3, 0x2, 0x2, 0x2, 0xa20, + 0xa21, 0x7, 0x30, 0x2, 0x2, 0xa21, 0x145, 0x3, 0x2, 0x2, 0x2, 0xa22, + 0xa23, 0x7, 0x2e, 0x2, 0x2, 0xa23, 0x147, 0x3, 0x2, 0x2, 0x2, 0xa24, + 0xa25, 0x7, 0x2f, 0x2, 0x2, 0xa25, 0xa2f, 0x7, 0x40, 0x2, 0x2, 0xa26, + 0xa28, 0x7, 0x2f, 0x2, 0x2, 0xa27, 0xa29, 0x5, 0x156, 0xaa, 0x2, + 0xa28, 0xa27, 0x3, 0x2, 0x2, 0x2, 0xa29, 0xa2a, 0x3, 0x2, 0x2, 0x2, + 0xa2a, 0xa28, 0x3, 0x2, 0x2, 0x2, 0xa2a, 0xa2b, 0x3, 0x2, 0x2, 0x2, + 0xa2b, 0xa2c, 0x3, 0x2, 0x2, 0x2, 0xa2c, 0xa2d, 0x7, 0x40, 0x2, 0x2, + 0xa2d, 0xa2f, 0x3, 0x2, 0x2, 0x2, 0xa2e, 0xa24, 0x3, 0x2, 0x2, 0x2, + 0xa2e, 0xa26, 0x3, 0x2, 0x2, 0x2, 0xa2f, 0x149, 0x3, 0x2, 0x2, 0x2, + 0xa30, 0xa34, 0x5, 0x14c, 0xa5, 0x2, 0xa31, 0xa33, 0x5, 0x14e, 0xa6, + 0x2, 0xa32, 0xa31, 0x3, 0x2, 0x2, 0x2, 0xa33, 0xa36, 0x3, 0x2, 0x2, + 0x2, 0xa34, 0xa32, 0x3, 0x2, 0x2, 0x2, 0xa34, 0xa35, 0x3, 0x2, 0x2, + 0x2, 0xa35, 0x14b, 0x3, 0x2, 0x2, 0x2, 0xa36, 0xa34, 0x3, 0x2, 0x2, + 0x2, 0xa37, 0xa38, 0x9, 0xa, 0x2, 0x2, 0xa38, 0x14d, 0x3, 0x2, 0x2, + 0x2, 0xa39, 0xa3a, 0x9, 0xb, 0x2, 0x2, 0xa3a, 0x14f, 0x3, 0x2, 0x2, + 0x2, 0xa3b, 0xa3c, 0x7, 0x32, 0x2, 0x2, 0xa3c, 0xa3e, 0x7, 0x7a, + 0x2, 0x2, 0xa3d, 0xa3f, 0x9, 0x8, 0x2, 0x2, 0xa3e, 0xa3d, 0x3, 0x2, + 0x2, 0x2, 0xa3f, 0xa40, 0x3, 0x2, 0x2, 0x2, 0xa40, 0xa3e, 0x3, 0x2, + 0x2, 0x2, 0xa40, 0xa41, 0x3, 0x2, 0x2, 0x2, 0xa41, 0x151, 0x3, 0x2, + 0x2, 0x2, 0xa42, 0xa4b, 0x7, 0x32, 0x2, 0x2, 0xa43, 0xa47, 0x9, 0xe, + 0x2, 0x2, 0xa44, 0xa46, 0x9, 0x2, 0x2, 0x2, 0xa45, 0xa44, 0x3, 0x2, + 0x2, 0x2, 0xa46, 0xa49, 0x3, 0x2, 0x2, 0x2, 0xa47, 0xa45, 0x3, 0x2, + 0x2, 0x2, 0xa47, 0xa48, 0x3, 0x2, 0x2, 0x2, 0xa48, 0xa4b, 0x3, 0x2, + 0x2, 0x2, 0xa49, 0xa47, 0x3, 0x2, 0x2, 0x2, 0xa4a, 0xa42, 0x3, 0x2, + 0x2, 0x2, 0xa4a, 0xa43, 0x3, 0x2, 0x2, 0x2, 0xa4b, 0x153, 0x3, 0x2, + 0x2, 0x2, 0xa4c, 0xa50, 0x7, 0x24, 0x2, 0x2, 0xa4d, 0xa4f, 0x5, 0xec, + 0x75, 0x2, 0xa4e, 0xa4d, 0x3, 0x2, 0x2, 0x2, 0xa4f, 0xa52, 0x3, 0x2, + 0x2, 0x2, 0xa50, 0xa4e, 0x3, 0x2, 0x2, 0x2, 0xa50, 0xa51, 0x3, 0x2, + 0x2, 0x2, 0xa51, 0xa53, 0x3, 0x2, 0x2, 0x2, 0xa52, 0xa50, 0x3, 0x2, + 0x2, 0x2, 0xa53, 0xa5d, 0x7, 0x24, 0x2, 0x2, 0xa54, 0xa58, 0x7, 0x29, + 0x2, 0x2, 0xa55, 0xa57, 0x5, 0xee, 0x76, 0x2, 0xa56, 0xa55, 0x3, + 0x2, 0x2, 0x2, 0xa57, 0xa5a, 0x3, 0x2, 0x2, 0x2, 0xa58, 0xa56, 0x3, + 0x2, 0x2, 0x2, 0xa58, 0xa59, 0x3, 0x2, 0x2, 0x2, 0xa59, 0xa5b, 0x3, + 0x2, 0x2, 0x2, 0xa5a, 0xa58, 0x3, 0x2, 0x2, 0x2, 0xa5b, 0xa5d, 0x7, + 0x29, 0x2, 0x2, 0xa5c, 0xa4c, 0x3, 0x2, 0x2, 0x2, 0xa5c, 0xa54, 0x3, + 0x2, 0x2, 0x2, 0xa5d, 0x155, 0x3, 0x2, 0x2, 0x2, 0xa5e, 0xa60, 0x9, + 0xc, 0x2, 0x2, 0xa5f, 0xa5e, 0x3, 0x2, 0x2, 0x2, 0xa60, 0xa61, 0x3, + 0x2, 0x2, 0x2, 0xa61, 0xa5f, 0x3, 0x2, 0x2, 0x2, 0xa61, 0xa62, 0x3, + 0x2, 0x2, 0x2, 0xa62, 0xa63, 0x3, 0x2, 0x2, 0x2, 0xa63, 0xa64, 0x8, + 0xaa, 0x4, 0x2, 0xa64, 0x157, 0x3, 0x2, 0x2, 0x2, 0xa65, 0xa66, 0x7, + 0x31, 0x2, 0x2, 0xa66, 0xa67, 0x7, 0x2c, 0x2, 0x2, 0xa67, 0xa6b, + 0x3, 0x2, 0x2, 0x2, 0xa68, 0xa6a, 0xb, 0x2, 0x2, 0x2, 0xa69, 0xa68, + 0x3, 0x2, 0x2, 0x2, 0xa6a, 0xa6d, 0x3, 0x2, 0x2, 0x2, 0xa6b, 0xa6c, + 0x3, 0x2, 0x2, 0x2, 0xa6b, 0xa69, 0x3, 0x2, 0x2, 0x2, 0xa6c, 0xa6e, + 0x3, 0x2, 0x2, 0x2, 0xa6d, 0xa6b, 0x3, 0x2, 0x2, 0x2, 0xa6e, 0xa6f, + 0x7, 0x2c, 0x2, 0x2, 0xa6f, 0xa70, 0x7, 0x31, 0x2, 0x2, 0xa70, 0xa71, + 0x3, 0x2, 0x2, 0x2, 0xa71, 0xa72, 0x8, 0xab, 0x5, 0x2, 0xa72, 0x159, + 0x3, 0x2, 0x2, 0x2, 0xa73, 0xa74, 0x7, 0x31, 0x2, 0x2, 0xa74, 0xa75, + 0x7, 0x31, 0x2, 0x2, 0xa75, 0xa79, 0x3, 0x2, 0x2, 0x2, 0xa76, 0xa78, + 0xa, 0xd, 0x2, 0x2, 0xa77, 0xa76, 0x3, 0x2, 0x2, 0x2, 0xa78, 0xa7b, + 0x3, 0x2, 0x2, 0x2, 0xa79, 0xa77, 0x3, 0x2, 0x2, 0x2, 0xa79, 0xa7a, + 0x3, 0x2, 0x2, 0x2, 0xa7a, 0xa7c, 0x3, 0x2, 0x2, 0x2, 0xa7b, 0xa79, + 0x3, 0x2, 0x2, 0x2, 0xa7c, 0xa7d, 0x8, 0xac, 0x5, 0x2, 0xa7d, 0x15b, + 0x3, 0x2, 0x2, 0x2, 0xa7e, 0xa80, 0xa, 0xf, 0x2, 0x2, 0xa7f, 0xa7e, + 0x3, 0x2, 0x2, 0x2, 0xa80, 0xa81, 0x3, 0x2, 0x2, 0x2, 0xa81, 0xa7f, + 0x3, 0x2, 0x2, 0x2, 0xa81, 0xa82, 0x3, 0x2, 0x2, 0x2, 0xa82, 0x15d, + 0x3, 0x2, 0x2, 0x2, 0xa83, 0xa84, 0x7, 0x3d, 0x2, 0x2, 0xa84, 0xa85, + 0x3, 0x2, 0x2, 0x2, 0xa85, 0xa86, 0x8, 0xae, 0x6, 0x2, 0xa86, 0x15f, + 0x3, 0x2, 0x2, 0x2, 0xa87, 0xa89, 0x9, 0xc, 0x2, 0x2, 0xa88, 0xa87, + 0x3, 0x2, 0x2, 0x2, 0xa89, 0xa8a, 0x3, 0x2, 0x2, 0x2, 0xa8a, 0xa88, + 0x3, 0x2, 0x2, 0x2, 0xa8a, 0xa8b, 0x3, 0x2, 0x2, 0x2, 0xa8b, 0xa8c, + 0x3, 0x2, 0x2, 0x2, 0xa8c, 0xa8d, 0x8, 0xaf, 0x4, 0x2, 0xa8d, 0x161, + 0x3, 0x2, 0x2, 0x2, 0xa8e, 0xa8f, 0x7, 0x31, 0x2, 0x2, 0xa8f, 0xa90, + 0x7, 0x2c, 0x2, 0x2, 0xa90, 0xa94, 0x3, 0x2, 0x2, 0x2, 0xa91, 0xa93, + 0xb, 0x2, 0x2, 0x2, 0xa92, 0xa91, 0x3, 0x2, 0x2, 0x2, 0xa93, 0xa96, + 0x3, 0x2, 0x2, 0x2, 0xa94, 0xa95, 0x3, 0x2, 0x2, 0x2, 0xa94, 0xa92, + 0x3, 0x2, 0x2, 0x2, 0xa95, 0xa97, 0x3, 0x2, 0x2, 0x2, 0xa96, 0xa94, + 0x3, 0x2, 0x2, 0x2, 0xa97, 0xa98, 0x7, 0x2c, 0x2, 0x2, 0xa98, 0xa99, + 0x7, 0x31, 0x2, 0x2, 0xa99, 0xa9a, 0x3, 0x2, 0x2, 0x2, 0xa9a, 0xa9b, + 0x8, 0xb0, 0x5, 0x2, 0xa9b, 0x163, 0x3, 0x2, 0x2, 0x2, 0xa9c, 0xa9d, + 0x7, 0x31, 0x2, 0x2, 0xa9d, 0xa9e, 0x7, 0x31, 0x2, 0x2, 0xa9e, 0xaa2, + 0x3, 0x2, 0x2, 0x2, 0xa9f, 0xaa1, 0xa, 0xd, 0x2, 0x2, 0xaa0, 0xa9f, + 0x3, 0x2, 0x2, 0x2, 0xaa1, 0xaa4, 0x3, 0x2, 0x2, 0x2, 0xaa2, 0xaa0, + 0x3, 0x2, 0x2, 0x2, 0xaa2, 0xaa3, 0x3, 0x2, 0x2, 0x2, 0xaa3, 0xaa5, + 0x3, 0x2, 0x2, 0x2, 0xaa4, 0xaa2, 0x3, 0x2, 0x2, 0x2, 0xaa5, 0xaa6, + 0x8, 0xb1, 0x5, 0x2, 0xaa6, 0x165, 0x3, 0x2, 0x2, 0x2, 0x44, 0x2, + 0x3, 0x4, 0x5, 0x21c, 0x2dc, 0x2e2, 0x2e4, 0x3c6, 0x45c, 0x550, 0x586, + 0x58c, 0x58e, 0x667, 0x703, 0x70b, 0x70f, 0x715, 0x71d, 0x721, 0x725, + 0x729, 0x73b, 0x749, 0x759, 0x75d, 0x761, 0x765, 0x76d, 0x772, 0x775, + 0x77d, 0x782, 0x788, 0x78f, 0x796, 0x79a, 0x79e, 0x7a1, 0x7a5, 0x7aa, + 0x7b1, 0x7bb, 0x7c5, 0x7d3, 0x7e9, 0x7f3, 0x801, 0xa0f, 0xa2a, 0xa2e, + 0xa34, 0xa40, 0xa47, 0xa4a, 0xa50, 0xa58, 0xa5c, 0xa61, 0xa6b, 0xa79, + 0xa81, 0xa8a, 0xa94, 0xaa2, 0x8, 0x7, 0x5, 0x2, 0x7, 0x3, 0x2, 0x8, + 0x2, 0x2, 0x2, 0x3, 0x2, 0x6, 0x2, 0x2, 0x7, 0x4, 0x2, + }; + + _serializedATN.insert(_serializedATN.end(), serializedATNSegment0, + serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0])); + _serializedATN.insert(_serializedATN.end(), serializedATNSegment1, + serializedATNSegment1 + sizeof(serializedATNSegment1) / sizeof(serializedATNSegment1[0])); + + + atn::ATNDeserializer deserializer; + _atn = deserializer.deserialize(_serializedATN); + + size_t count = _atn.getNumberOfDecisions(); + _decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); + } +} + +SolidityLexer::Initializer SolidityLexer::_init; diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityLexer.h b/test/tools/ossfuzz/antlr4-runtime/SolidityLexer.h new file mode 100644 index 000000000..3c4bb68a8 --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityLexer.h @@ -0,0 +1,92 @@ + +// Generated from docs/grammar/SolidityLexer.g4 by ANTLR 4.8 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class SolidityLexer : public antlr4::Lexer { +public: + enum { + ReservedKeywords = 1, Pragma = 2, Abstract = 3, Anonymous = 4, Address = 5, + As = 6, Assembly = 7, Bool = 8, Break = 9, Bytes = 10, Calldata = 11, + Catch = 12, Constant = 13, Constructor = 14, Continue = 15, Contract = 16, + Delete = 17, Do = 18, Else = 19, Emit = 20, Enum = 21, Event = 22, External = 23, + Fallback = 24, False = 25, Fixed = 26, From = 27, FixedBytes = 28, For = 29, + Function = 30, Hex = 31, If = 32, Immutable = 33, Import = 34, Indexed = 35, + Interface = 36, Internal = 37, Is = 38, Library = 39, Mapping = 40, + Memory = 41, Modifier = 42, New = 43, NumberUnit = 44, Override = 45, + Payable = 46, Private = 47, Public = 48, Pure = 49, Receive = 50, Return = 51, + Returns = 52, SignedIntegerType = 53, Storage = 54, String = 55, Struct = 56, + True = 57, Try = 58, Type = 59, Ufixed = 60, UnsignedIntegerType = 61, + Using = 62, View = 63, Virtual = 64, While = 65, LParen = 66, RParen = 67, + LBrack = 68, RBrack = 69, LBrace = 70, RBrace = 71, Colon = 72, Semicolon = 73, + Period = 74, Conditional = 75, Arrow = 76, Assign = 77, AssignBitOr = 78, + AssignBitXor = 79, AssignBitAnd = 80, AssignShl = 81, AssignSar = 82, + AssignShr = 83, AssignAdd = 84, AssignSub = 85, AssignMul = 86, AssignDiv = 87, + AssignMod = 88, Comma = 89, Or = 90, And = 91, BitOr = 92, BitXor = 93, + BitAnd = 94, Shl = 95, Sar = 96, Shr = 97, Add = 98, Sub = 99, Mul = 100, + Div = 101, Mod = 102, Exp = 103, Equal = 104, NotEqual = 105, LessThan = 106, + GreaterThan = 107, LessThanOrEqual = 108, GreaterThanOrEqual = 109, + Not = 110, BitNot = 111, Inc = 112, Dec = 113, StringLiteral = 114, + NonEmptyStringLiteral = 115, UnicodeStringLiteral = 116, HexString = 117, + HexNumber = 118, DecimalNumber = 119, Identifier = 120, WS = 121, COMMENT = 122, + LINE_COMMENT = 123, AssemblyDialect = 124, AssemblyLBrace = 125, AssemblyBlockWS = 126, + AssemblyBlockCOMMENT = 127, AssemblyBlockLINE_COMMENT = 128, YulBreak = 129, + YulCase = 130, YulContinue = 131, YulDefault = 132, YulFalse = 133, + YulFor = 134, YulFunction = 135, YulIf = 136, YulLeave = 137, YulLet = 138, + YulSwitch = 139, YulTrue = 140, YulEVMBuiltin = 141, YulLBrace = 142, + YulRBrace = 143, YulLParen = 144, YulRParen = 145, YulAssign = 146, + YulPeriod = 147, YulComma = 148, YulArrow = 149, YulIdentifier = 150, + YulHexNumber = 151, YulDecimalNumber = 152, YulStringLiteral = 153, + YulWS = 154, YulCOMMENT = 155, YulLINE_COMMENT = 156, PragmaToken = 157, + PragmaSemicolon = 158, PragmaWS = 159, PragmaCOMMENT = 160, PragmaLINE_COMMENT = 161 + }; + + enum { + AssemblyBlockMode = 1, YulMode = 2, PragmaMode = 3 + }; + + SolidityLexer(antlr4::CharStream *input); + ~SolidityLexer(); + + virtual std::string getGrammarFileName() const override; + virtual const std::vector& getRuleNames() const override; + + virtual const std::vector& getChannelNames() const override; + virtual const std::vector& getModeNames() const override; + virtual const std::vector& getTokenNames() const override; // deprecated, use vocabulary instead + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + virtual const std::vector getSerializedATN() const override; + virtual const antlr4::atn::ATN& getATN() const override; + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + static std::vector _channelNames; + static std::vector _modeNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + + // Individual action functions triggered by action() above. + + // Individual semantic predicate functions triggered by sempred() above. + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityMutator.cpp b/test/tools/ossfuzz/antlr4-runtime/SolidityMutator.cpp new file mode 100644 index 000000000..e6469050a --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityMutator.cpp @@ -0,0 +1,87 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ + +#include + +#include + +#include + +using namespace std; +using namespace solidity::util; + +antlrcpp::Any SolidityMutator::visitPragmaDirective(SolidityParser::PragmaDirectiveContext* _ctx) +{ + auto PickLiteral = [](unsigned const len) -> string + { + // TODO: Add to this list of valid pragmas + static const vector alphanum = { + "solidity >=0.0.0", + "solidity ^0.4.24", + "experimental SMTChecker", + "experimental ABIEncoderV2", + }; + + return alphanum[len % alphanum.size()]; + }; + + string pragma{}; + for (auto &t: _ctx->PragmaToken()) + { + string literal = t->toString(); + boost::algorithm::erase_all(literal, " "); + if (random() % 5 == 0) + pragma += " " + PickLiteral(random()); + else + pragma += " " + literal; + } + + Out << Whiskers(R"(pragma ;)") + ("string", pragma) + ("nl", "\n") + .render(); + + return antlrcpp::Any(); +} + +antlrcpp::Any SolidityMutator::visitImportDirective(SolidityParser::ImportDirectiveContext* _ctx) +{ + if (_ctx->path()) + Out << Whiskers(R"(import as ;)") + ("path", "\"A.sol\"") + ("id", "A") + ("nl", "\n") + .render(); + else if (_ctx->Mul()) + Out << Whiskers(R"(import * as from ;)") + ("id", "A") + ("path", "\"A.sol\"") + ("nl", "\n") + .render(); + else if (_ctx->symbolAliases()) + Out << Whiskers(R"(import {} from ;)") + ("symbolAliases", "C as B, A") + ("path", "\"A.sol\"") + ("nl", "\n") + .render(); + else + Out << Whiskers(R"(import "A.sol";)") + ("nl", "\n") + .render(); + + return antlrcpp::Any(); +} \ No newline at end of file diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityMutator.h b/test/tools/ossfuzz/antlr4-runtime/SolidityMutator.h new file mode 100644 index 000000000..2fd96b43b --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityMutator.h @@ -0,0 +1,34 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ + +#pragma once + +#include + +class SolidityMutator: public SolidityBaseVisitor +{ +public: + std::string toString() + { + return Out.str(); + } + antlrcpp::Any visitPragmaDirective(SolidityParser::PragmaDirectiveContext* _ctx) override; + antlrcpp::Any visitImportDirective(SolidityParser::ImportDirectiveContext* _ctx) override; + +private: + std::ostringstream Out; +}; \ No newline at end of file diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityParser.cpp b/test/tools/ossfuzz/antlr4-runtime/SolidityParser.cpp new file mode 100644 index 000000000..0da130014 --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityParser.cpp @@ -0,0 +1,10074 @@ + +// Generated from Solidity.g4 by ANTLR 4.8 + + +#include +#include + + +using namespace antlrcpp; +using namespace antlr4; + +SolidityParser::SolidityParser(TokenStream *input) : Parser(input) { + _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache); +} + +SolidityParser::~SolidityParser() { + delete _interpreter; +} + +std::string SolidityParser::getGrammarFileName() const { + return "Solidity.g4"; +} + +const std::vector& SolidityParser::getRuleNames() const { + return _ruleNames; +} + +dfa::Vocabulary& SolidityParser::getVocabulary() const { + return _vocabulary; +} + + +//----------------- SourceUnitContext ------------------------------------------------------------------ + +SolidityParser::SourceUnitContext::SourceUnitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::SourceUnitContext::EOF() { + return getToken(SolidityParser::EOF, 0); +} + +std::vector SolidityParser::SourceUnitContext::pragmaDirective() { + return getRuleContexts(); +} + +SolidityParser::PragmaDirectiveContext* SolidityParser::SourceUnitContext::pragmaDirective(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::importDirective() { + return getRuleContexts(); +} + +SolidityParser::ImportDirectiveContext* SolidityParser::SourceUnitContext::importDirective(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::contractDefinition() { + return getRuleContexts(); +} + +SolidityParser::ContractDefinitionContext* SolidityParser::SourceUnitContext::contractDefinition(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::interfaceDefinition() { + return getRuleContexts(); +} + +SolidityParser::InterfaceDefinitionContext* SolidityParser::SourceUnitContext::interfaceDefinition(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::libraryDefinition() { + return getRuleContexts(); +} + +SolidityParser::LibraryDefinitionContext* SolidityParser::SourceUnitContext::libraryDefinition(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::functionDefinition() { + return getRuleContexts(); +} + +SolidityParser::FunctionDefinitionContext* SolidityParser::SourceUnitContext::functionDefinition(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::structDefinition() { + return getRuleContexts(); +} + +SolidityParser::StructDefinitionContext* SolidityParser::SourceUnitContext::structDefinition(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SourceUnitContext::enumDefinition() { + return getRuleContexts(); +} + +SolidityParser::EnumDefinitionContext* SolidityParser::SourceUnitContext::enumDefinition(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::SourceUnitContext::getRuleIndex() const { + return SolidityParser::RuleSourceUnit; +} + + +antlrcpp::Any SolidityParser::SourceUnitContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitSourceUnit(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::SourceUnitContext* SolidityParser::sourceUnit() { + SourceUnitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 0, SolidityParser::RuleSourceUnit); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(174); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SolidityParser::Pragma) + | (1ULL << SolidityParser::Abstract) + | (1ULL << SolidityParser::Contract) + | (1ULL << SolidityParser::Enum) + | (1ULL << SolidityParser::Function) + | (1ULL << SolidityParser::Import) + | (1ULL << SolidityParser::Interface) + | (1ULL << SolidityParser::Library) + | (1ULL << SolidityParser::Struct))) != 0)) { + setState(172); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::Pragma: { + setState(164); + pragmaDirective(); + break; + } + + case SolidityParser::Import: { + setState(165); + importDirective(); + break; + } + + case SolidityParser::Abstract: + case SolidityParser::Contract: { + setState(166); + contractDefinition(); + break; + } + + case SolidityParser::Interface: { + setState(167); + interfaceDefinition(); + break; + } + + case SolidityParser::Library: { + setState(168); + libraryDefinition(); + break; + } + + case SolidityParser::Function: { + setState(169); + functionDefinition(); + break; + } + + case SolidityParser::Struct: { + setState(170); + structDefinition(); + break; + } + + case SolidityParser::Enum: { + setState(171); + enumDefinition(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(176); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(177); + match(SolidityParser::EOF); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PragmaDirectiveContext ------------------------------------------------------------------ + +SolidityParser::PragmaDirectiveContext::PragmaDirectiveContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::PragmaDirectiveContext::Pragma() { + return getToken(SolidityParser::Pragma, 0); +} + +tree::TerminalNode* SolidityParser::PragmaDirectiveContext::PragmaSemicolon() { + return getToken(SolidityParser::PragmaSemicolon, 0); +} + +std::vector SolidityParser::PragmaDirectiveContext::PragmaToken() { + return getTokens(SolidityParser::PragmaToken); +} + +tree::TerminalNode* SolidityParser::PragmaDirectiveContext::PragmaToken(size_t i) { + return getToken(SolidityParser::PragmaToken, i); +} + + +size_t SolidityParser::PragmaDirectiveContext::getRuleIndex() const { + return SolidityParser::RulePragmaDirective; +} + + +antlrcpp::Any SolidityParser::PragmaDirectiveContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPragmaDirective(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::PragmaDirectiveContext* SolidityParser::pragmaDirective() { + PragmaDirectiveContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 2, SolidityParser::RulePragmaDirective); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(179); + match(SolidityParser::Pragma); + setState(181); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(180); + match(SolidityParser::PragmaToken); + setState(183); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == SolidityParser::PragmaToken); + setState(185); + match(SolidityParser::PragmaSemicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ImportDirectiveContext ------------------------------------------------------------------ + +SolidityParser::ImportDirectiveContext::ImportDirectiveContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ImportDirectiveContext::Import() { + return getToken(SolidityParser::Import, 0); +} + +tree::TerminalNode* SolidityParser::ImportDirectiveContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +SolidityParser::PathContext* SolidityParser::ImportDirectiveContext::path() { + return getRuleContext(0); +} + +SolidityParser::SymbolAliasesContext* SolidityParser::ImportDirectiveContext::symbolAliases() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::ImportDirectiveContext::From() { + return getToken(SolidityParser::From, 0); +} + +tree::TerminalNode* SolidityParser::ImportDirectiveContext::Mul() { + return getToken(SolidityParser::Mul, 0); +} + +tree::TerminalNode* SolidityParser::ImportDirectiveContext::As() { + return getToken(SolidityParser::As, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::ImportDirectiveContext::identifier() { + return getRuleContext(0); +} + + +size_t SolidityParser::ImportDirectiveContext::getRuleIndex() const { + return SolidityParser::RuleImportDirective; +} + + +antlrcpp::Any SolidityParser::ImportDirectiveContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitImportDirective(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ImportDirectiveContext* SolidityParser::importDirective() { + ImportDirectiveContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 4, SolidityParser::RuleImportDirective); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(187); + match(SolidityParser::Import); + setState(203); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::NonEmptyStringLiteral: { + setState(188); + path(); + setState(191); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::As) { + setState(189); + match(SolidityParser::As); + setState(190); + dynamic_cast(_localctx)->unitAlias = identifier(); + } + break; + } + + case SolidityParser::LBrace: { + setState(193); + symbolAliases(); + setState(194); + match(SolidityParser::From); + setState(195); + path(); + break; + } + + case SolidityParser::Mul: { + setState(197); + match(SolidityParser::Mul); + setState(198); + match(SolidityParser::As); + setState(199); + dynamic_cast(_localctx)->unitAlias = identifier(); + setState(200); + match(SolidityParser::From); + setState(201); + path(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(205); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ImportAliasesContext ------------------------------------------------------------------ + +SolidityParser::ImportAliasesContext::ImportAliasesContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::ImportAliasesContext::identifier() { + return getRuleContexts(); +} + +SolidityParser::IdentifierContext* SolidityParser::ImportAliasesContext::identifier(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::ImportAliasesContext::As() { + return getToken(SolidityParser::As, 0); +} + + +size_t SolidityParser::ImportAliasesContext::getRuleIndex() const { + return SolidityParser::RuleImportAliases; +} + + +antlrcpp::Any SolidityParser::ImportAliasesContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitImportAliases(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ImportAliasesContext* SolidityParser::importAliases() { + ImportAliasesContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, SolidityParser::RuleImportAliases); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(207); + dynamic_cast(_localctx)->symbol = identifier(); + setState(210); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::As) { + setState(208); + match(SolidityParser::As); + setState(209); + dynamic_cast(_localctx)->alias = identifier(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PathContext ------------------------------------------------------------------ + +SolidityParser::PathContext::PathContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::PathContext::NonEmptyStringLiteral() { + return getToken(SolidityParser::NonEmptyStringLiteral, 0); +} + + +size_t SolidityParser::PathContext::getRuleIndex() const { + return SolidityParser::RulePath; +} + + +antlrcpp::Any SolidityParser::PathContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPath(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::PathContext* SolidityParser::path() { + PathContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, SolidityParser::RulePath); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(212); + match(SolidityParser::NonEmptyStringLiteral); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SymbolAliasesContext ------------------------------------------------------------------ + +SolidityParser::SymbolAliasesContext::SymbolAliasesContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::SymbolAliasesContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::SymbolAliasesContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +std::vector SolidityParser::SymbolAliasesContext::importAliases() { + return getRuleContexts(); +} + +SolidityParser::ImportAliasesContext* SolidityParser::SymbolAliasesContext::importAliases(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::SymbolAliasesContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::SymbolAliasesContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::SymbolAliasesContext::getRuleIndex() const { + return SolidityParser::RuleSymbolAliases; +} + + +antlrcpp::Any SolidityParser::SymbolAliasesContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitSymbolAliases(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::SymbolAliasesContext* SolidityParser::symbolAliases() { + SymbolAliasesContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 10, SolidityParser::RuleSymbolAliases); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(214); + match(SolidityParser::LBrace); + setState(215); + dynamic_cast(_localctx)->importAliasesContext = importAliases(); + dynamic_cast(_localctx)->aliases.push_back(dynamic_cast(_localctx)->importAliasesContext); + setState(220); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(216); + match(SolidityParser::Comma); + setState(217); + dynamic_cast(_localctx)->importAliasesContext = importAliases(); + dynamic_cast(_localctx)->aliases.push_back(dynamic_cast(_localctx)->importAliasesContext); + setState(222); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(223); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ContractDefinitionContext ------------------------------------------------------------------ + +SolidityParser::ContractDefinitionContext::ContractDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ContractDefinitionContext::Contract() { + return getToken(SolidityParser::Contract, 0); +} + +tree::TerminalNode* SolidityParser::ContractDefinitionContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::ContractDefinitionContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::ContractDefinitionContext::identifier() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::ContractDefinitionContext::Abstract() { + return getToken(SolidityParser::Abstract, 0); +} + +SolidityParser::InheritanceSpecifierListContext* SolidityParser::ContractDefinitionContext::inheritanceSpecifierList() { + return getRuleContext(0); +} + +std::vector SolidityParser::ContractDefinitionContext::contractBodyElement() { + return getRuleContexts(); +} + +SolidityParser::ContractBodyElementContext* SolidityParser::ContractDefinitionContext::contractBodyElement(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::ContractDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleContractDefinition; +} + + +antlrcpp::Any SolidityParser::ContractDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitContractDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ContractDefinitionContext* SolidityParser::contractDefinition() { + ContractDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, SolidityParser::RuleContractDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(226); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Abstract) { + setState(225); + match(SolidityParser::Abstract); + } + setState(228); + match(SolidityParser::Contract); + setState(229); + dynamic_cast(_localctx)->name = identifier(); + setState(231); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Is) { + setState(230); + inheritanceSpecifierList(); + } + setState(233); + match(SolidityParser::LBrace); + setState(237); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 9, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(234); + contractBodyElement(); + } + setState(239); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 9, _ctx); + } + setState(240); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InterfaceDefinitionContext ------------------------------------------------------------------ + +SolidityParser::InterfaceDefinitionContext::InterfaceDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::InterfaceDefinitionContext::Interface() { + return getToken(SolidityParser::Interface, 0); +} + +tree::TerminalNode* SolidityParser::InterfaceDefinitionContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::InterfaceDefinitionContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::InterfaceDefinitionContext::identifier() { + return getRuleContext(0); +} + +SolidityParser::InheritanceSpecifierListContext* SolidityParser::InterfaceDefinitionContext::inheritanceSpecifierList() { + return getRuleContext(0); +} + +std::vector SolidityParser::InterfaceDefinitionContext::contractBodyElement() { + return getRuleContexts(); +} + +SolidityParser::ContractBodyElementContext* SolidityParser::InterfaceDefinitionContext::contractBodyElement(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::InterfaceDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleInterfaceDefinition; +} + + +antlrcpp::Any SolidityParser::InterfaceDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInterfaceDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::InterfaceDefinitionContext* SolidityParser::interfaceDefinition() { + InterfaceDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 14, SolidityParser::RuleInterfaceDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(242); + match(SolidityParser::Interface); + setState(243); + dynamic_cast(_localctx)->name = identifier(); + setState(245); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Is) { + setState(244); + inheritanceSpecifierList(); + } + setState(247); + match(SolidityParser::LBrace); + setState(251); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 11, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(248); + contractBodyElement(); + } + setState(253); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 11, _ctx); + } + setState(254); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LibraryDefinitionContext ------------------------------------------------------------------ + +SolidityParser::LibraryDefinitionContext::LibraryDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::LibraryDefinitionContext::Library() { + return getToken(SolidityParser::Library, 0); +} + +tree::TerminalNode* SolidityParser::LibraryDefinitionContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::LibraryDefinitionContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::LibraryDefinitionContext::identifier() { + return getRuleContext(0); +} + +std::vector SolidityParser::LibraryDefinitionContext::contractBodyElement() { + return getRuleContexts(); +} + +SolidityParser::ContractBodyElementContext* SolidityParser::LibraryDefinitionContext::contractBodyElement(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::LibraryDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleLibraryDefinition; +} + + +antlrcpp::Any SolidityParser::LibraryDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLibraryDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::LibraryDefinitionContext* SolidityParser::libraryDefinition() { + LibraryDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 16, SolidityParser::RuleLibraryDefinition); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(256); + match(SolidityParser::Library); + setState(257); + dynamic_cast(_localctx)->name = identifier(); + setState(258); + match(SolidityParser::LBrace); + setState(262); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 12, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(259); + contractBodyElement(); + } + setState(264); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 12, _ctx); + } + setState(265); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InheritanceSpecifierListContext ------------------------------------------------------------------ + +SolidityParser::InheritanceSpecifierListContext::InheritanceSpecifierListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::InheritanceSpecifierListContext::Is() { + return getToken(SolidityParser::Is, 0); +} + +std::vector SolidityParser::InheritanceSpecifierListContext::inheritanceSpecifier() { + return getRuleContexts(); +} + +SolidityParser::InheritanceSpecifierContext* SolidityParser::InheritanceSpecifierListContext::inheritanceSpecifier(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::InheritanceSpecifierListContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::InheritanceSpecifierListContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::InheritanceSpecifierListContext::getRuleIndex() const { + return SolidityParser::RuleInheritanceSpecifierList; +} + + +antlrcpp::Any SolidityParser::InheritanceSpecifierListContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInheritanceSpecifierList(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::InheritanceSpecifierListContext* SolidityParser::inheritanceSpecifierList() { + InheritanceSpecifierListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 18, SolidityParser::RuleInheritanceSpecifierList); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(267); + match(SolidityParser::Is); + setState(268); + dynamic_cast(_localctx)->inheritanceSpecifierContext = inheritanceSpecifier(); + dynamic_cast(_localctx)->inheritanceSpecifiers.push_back(dynamic_cast(_localctx)->inheritanceSpecifierContext); + setState(273); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 13, _ctx); + while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1 + 1) { + setState(269); + match(SolidityParser::Comma); + setState(270); + dynamic_cast(_localctx)->inheritanceSpecifierContext = inheritanceSpecifier(); + dynamic_cast(_localctx)->inheritanceSpecifiers.push_back(dynamic_cast(_localctx)->inheritanceSpecifierContext); + } + setState(275); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 13, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InheritanceSpecifierContext ------------------------------------------------------------------ + +SolidityParser::InheritanceSpecifierContext::InheritanceSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::InheritanceSpecifierContext::userDefinedTypeName() { + return getRuleContext(0); +} + +SolidityParser::CallArgumentListContext* SolidityParser::InheritanceSpecifierContext::callArgumentList() { + return getRuleContext(0); +} + + +size_t SolidityParser::InheritanceSpecifierContext::getRuleIndex() const { + return SolidityParser::RuleInheritanceSpecifier; +} + + +antlrcpp::Any SolidityParser::InheritanceSpecifierContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInheritanceSpecifier(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::InheritanceSpecifierContext* SolidityParser::inheritanceSpecifier() { + InheritanceSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 20, SolidityParser::RuleInheritanceSpecifier); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(276); + dynamic_cast(_localctx)->name = userDefinedTypeName(); + setState(278); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::LParen) { + setState(277); + dynamic_cast(_localctx)->arguments = callArgumentList(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ContractBodyElementContext ------------------------------------------------------------------ + +SolidityParser::ContractBodyElementContext::ContractBodyElementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::ConstructorDefinitionContext* SolidityParser::ContractBodyElementContext::constructorDefinition() { + return getRuleContext(0); +} + +SolidityParser::FunctionDefinitionContext* SolidityParser::ContractBodyElementContext::functionDefinition() { + return getRuleContext(0); +} + +SolidityParser::ModifierDefinitionContext* SolidityParser::ContractBodyElementContext::modifierDefinition() { + return getRuleContext(0); +} + +SolidityParser::FallbackReceiveFunctionDefinitionContext* SolidityParser::ContractBodyElementContext::fallbackReceiveFunctionDefinition() { + return getRuleContext(0); +} + +SolidityParser::StructDefinitionContext* SolidityParser::ContractBodyElementContext::structDefinition() { + return getRuleContext(0); +} + +SolidityParser::EnumDefinitionContext* SolidityParser::ContractBodyElementContext::enumDefinition() { + return getRuleContext(0); +} + +SolidityParser::StateVariableDeclarationContext* SolidityParser::ContractBodyElementContext::stateVariableDeclaration() { + return getRuleContext(0); +} + +SolidityParser::EventDefinitionContext* SolidityParser::ContractBodyElementContext::eventDefinition() { + return getRuleContext(0); +} + +SolidityParser::UsingDirectiveContext* SolidityParser::ContractBodyElementContext::usingDirective() { + return getRuleContext(0); +} + + +size_t SolidityParser::ContractBodyElementContext::getRuleIndex() const { + return SolidityParser::RuleContractBodyElement; +} + + +antlrcpp::Any SolidityParser::ContractBodyElementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitContractBodyElement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ContractBodyElementContext* SolidityParser::contractBodyElement() { + ContractBodyElementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 22, SolidityParser::RuleContractBodyElement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(289); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 15, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(280); + constructorDefinition(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(281); + functionDefinition(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(282); + modifierDefinition(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(283); + fallbackReceiveFunctionDefinition(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(284); + structDefinition(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(285); + enumDefinition(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(286); + stateVariableDeclaration(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(287); + eventDefinition(); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(288); + usingDirective(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NamedArgumentContext ------------------------------------------------------------------ + +SolidityParser::NamedArgumentContext::NamedArgumentContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::NamedArgumentContext::Colon() { + return getToken(SolidityParser::Colon, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::NamedArgumentContext::identifier() { + return getRuleContext(0); +} + +SolidityParser::ExpressionContext* SolidityParser::NamedArgumentContext::expression() { + return getRuleContext(0); +} + + +size_t SolidityParser::NamedArgumentContext::getRuleIndex() const { + return SolidityParser::RuleNamedArgument; +} + + +antlrcpp::Any SolidityParser::NamedArgumentContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNamedArgument(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::NamedArgumentContext* SolidityParser::namedArgument() { + NamedArgumentContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 24, SolidityParser::RuleNamedArgument); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(291); + dynamic_cast(_localctx)->name = identifier(); + setState(292); + match(SolidityParser::Colon); + setState(293); + dynamic_cast(_localctx)->value = expression(0); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CallArgumentListContext ------------------------------------------------------------------ + +SolidityParser::CallArgumentListContext::CallArgumentListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::CallArgumentListContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::CallArgumentListContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +tree::TerminalNode* SolidityParser::CallArgumentListContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::CallArgumentListContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +std::vector SolidityParser::CallArgumentListContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::CallArgumentListContext::expression(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::CallArgumentListContext::namedArgument() { + return getRuleContexts(); +} + +SolidityParser::NamedArgumentContext* SolidityParser::CallArgumentListContext::namedArgument(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::CallArgumentListContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::CallArgumentListContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::CallArgumentListContext::getRuleIndex() const { + return SolidityParser::RuleCallArgumentList; +} + + +antlrcpp::Any SolidityParser::CallArgumentListContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCallArgumentList(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::CallArgumentListContext* SolidityParser::callArgumentList() { + CallArgumentListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 26, SolidityParser::RuleCallArgumentList); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(295); + match(SolidityParser::LParen); + setState(318); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 20, _ctx)) { + case 1: { + setState(304); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 17, _ctx)) { + case 1: { + setState(296); + expression(0); + setState(301); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(297); + match(SolidityParser::Comma); + setState(298); + expression(0); + setState(303); + _errHandler->sync(this); + _la = _input->LA(1); + } + break; + } + + } + break; + } + + case 2: { + setState(306); + match(SolidityParser::LBrace); + setState(315); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::From || _la == SolidityParser::Identifier) { + setState(307); + namedArgument(); + setState(312); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(308); + match(SolidityParser::Comma); + setState(309); + namedArgument(); + setState(314); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(317); + match(SolidityParser::RBrace); + break; + } + + } + setState(320); + match(SolidityParser::RParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UserDefinedTypeNameContext ------------------------------------------------------------------ + +SolidityParser::UserDefinedTypeNameContext::UserDefinedTypeNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::UserDefinedTypeNameContext::identifier() { + return getRuleContexts(); +} + +SolidityParser::IdentifierContext* SolidityParser::UserDefinedTypeNameContext::identifier(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::UserDefinedTypeNameContext::Period() { + return getTokens(SolidityParser::Period); +} + +tree::TerminalNode* SolidityParser::UserDefinedTypeNameContext::Period(size_t i) { + return getToken(SolidityParser::Period, i); +} + + +size_t SolidityParser::UserDefinedTypeNameContext::getRuleIndex() const { + return SolidityParser::RuleUserDefinedTypeName; +} + + +antlrcpp::Any SolidityParser::UserDefinedTypeNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUserDefinedTypeName(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::userDefinedTypeName() { + UserDefinedTypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 28, SolidityParser::RuleUserDefinedTypeName); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(322); + identifier(); + setState(327); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 21, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(323); + match(SolidityParser::Period); + setState(324); + identifier(); + } + setState(329); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 21, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ModifierInvocationContext ------------------------------------------------------------------ + +SolidityParser::ModifierInvocationContext::ModifierInvocationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::IdentifierContext* SolidityParser::ModifierInvocationContext::identifier() { + return getRuleContext(0); +} + +SolidityParser::CallArgumentListContext* SolidityParser::ModifierInvocationContext::callArgumentList() { + return getRuleContext(0); +} + + +size_t SolidityParser::ModifierInvocationContext::getRuleIndex() const { + return SolidityParser::RuleModifierInvocation; +} + + +antlrcpp::Any SolidityParser::ModifierInvocationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitModifierInvocation(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ModifierInvocationContext* SolidityParser::modifierInvocation() { + ModifierInvocationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 30, SolidityParser::RuleModifierInvocation); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(330); + identifier(); + setState(332); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 22, _ctx)) { + case 1: { + setState(331); + callArgumentList(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VisibilityContext ------------------------------------------------------------------ + +SolidityParser::VisibilityContext::VisibilityContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::VisibilityContext::Internal() { + return getToken(SolidityParser::Internal, 0); +} + +tree::TerminalNode* SolidityParser::VisibilityContext::External() { + return getToken(SolidityParser::External, 0); +} + +tree::TerminalNode* SolidityParser::VisibilityContext::Private() { + return getToken(SolidityParser::Private, 0); +} + +tree::TerminalNode* SolidityParser::VisibilityContext::Public() { + return getToken(SolidityParser::Public, 0); +} + + +size_t SolidityParser::VisibilityContext::getRuleIndex() const { + return SolidityParser::RuleVisibility; +} + + +antlrcpp::Any SolidityParser::VisibilityContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVisibility(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::VisibilityContext* SolidityParser::visibility() { + VisibilityContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, SolidityParser::RuleVisibility); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(334); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SolidityParser::External) + | (1ULL << SolidityParser::Internal) + | (1ULL << SolidityParser::Private) + | (1ULL << SolidityParser::Public))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ParameterListContext ------------------------------------------------------------------ + +SolidityParser::ParameterListContext::ParameterListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::ParameterListContext::parameterDeclaration() { + return getRuleContexts(); +} + +SolidityParser::ParameterDeclarationContext* SolidityParser::ParameterListContext::parameterDeclaration(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::ParameterListContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::ParameterListContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::ParameterListContext::getRuleIndex() const { + return SolidityParser::RuleParameterList; +} + + +antlrcpp::Any SolidityParser::ParameterListContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitParameterList(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ParameterListContext* SolidityParser::parameterList() { + ParameterListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, SolidityParser::RuleParameterList); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(336); + dynamic_cast(_localctx)->parameterDeclarationContext = parameterDeclaration(); + dynamic_cast(_localctx)->parameters.push_back(dynamic_cast(_localctx)->parameterDeclarationContext); + setState(341); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(337); + match(SolidityParser::Comma); + setState(338); + dynamic_cast(_localctx)->parameterDeclarationContext = parameterDeclaration(); + dynamic_cast(_localctx)->parameters.push_back(dynamic_cast(_localctx)->parameterDeclarationContext); + setState(343); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ParameterDeclarationContext ------------------------------------------------------------------ + +SolidityParser::ParameterDeclarationContext::ParameterDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::TypeNameContext* SolidityParser::ParameterDeclarationContext::typeName() { + return getRuleContext(0); +} + +SolidityParser::DataLocationContext* SolidityParser::ParameterDeclarationContext::dataLocation() { + return getRuleContext(0); +} + +SolidityParser::IdentifierContext* SolidityParser::ParameterDeclarationContext::identifier() { + return getRuleContext(0); +} + + +size_t SolidityParser::ParameterDeclarationContext::getRuleIndex() const { + return SolidityParser::RuleParameterDeclaration; +} + + +antlrcpp::Any SolidityParser::ParameterDeclarationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitParameterDeclaration(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ParameterDeclarationContext* SolidityParser::parameterDeclaration() { + ParameterDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, SolidityParser::RuleParameterDeclaration); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(344); + dynamic_cast(_localctx)->type = typeName(0); + setState(346); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SolidityParser::Calldata) + | (1ULL << SolidityParser::Memory) + | (1ULL << SolidityParser::Storage))) != 0)) { + setState(345); + dynamic_cast(_localctx)->location = dataLocation(); + } + setState(349); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::From || _la == SolidityParser::Identifier) { + setState(348); + dynamic_cast(_localctx)->name = identifier(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ConstructorDefinitionContext ------------------------------------------------------------------ + +SolidityParser::ConstructorDefinitionContext::ConstructorDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Constructor() { + return getToken(SolidityParser::Constructor, 0); +} + +tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +SolidityParser::BlockContext* SolidityParser::ConstructorDefinitionContext::block() { + return getRuleContext(0); +} + +std::vector SolidityParser::ConstructorDefinitionContext::modifierInvocation() { + return getRuleContexts(); +} + +SolidityParser::ModifierInvocationContext* SolidityParser::ConstructorDefinitionContext::modifierInvocation(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::ConstructorDefinitionContext::Payable() { + return getTokens(SolidityParser::Payable); +} + +tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Payable(size_t i) { + return getToken(SolidityParser::Payable, i); +} + +std::vector SolidityParser::ConstructorDefinitionContext::Internal() { + return getTokens(SolidityParser::Internal); +} + +tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Internal(size_t i) { + return getToken(SolidityParser::Internal, i); +} + +std::vector SolidityParser::ConstructorDefinitionContext::Public() { + return getTokens(SolidityParser::Public); +} + +tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Public(size_t i) { + return getToken(SolidityParser::Public, i); +} + +SolidityParser::ParameterListContext* SolidityParser::ConstructorDefinitionContext::parameterList() { + return getRuleContext(0); +} + + +size_t SolidityParser::ConstructorDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleConstructorDefinition; +} + + +antlrcpp::Any SolidityParser::ConstructorDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConstructorDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ConstructorDefinitionContext* SolidityParser::constructorDefinition() { + ConstructorDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, SolidityParser::RuleConstructorDefinition); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(351); + match(SolidityParser::Constructor); + setState(352); + match(SolidityParser::LParen); + setState(354); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 26, _ctx)) { + case 1: { + setState(353); + dynamic_cast(_localctx)->arguments = parameterList(); + break; + } + + } + setState(356); + match(SolidityParser::RParen); + setState(369); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 28, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(367); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 27, _ctx)) { + case 1: { + setState(357); + modifierInvocation(); + break; + } + + case 2: { + setState(358); + + if (!(!_localctx->payableSet)) throw FailedPredicateException(this, "!$payableSet"); + setState(359); + match(SolidityParser::Payable); + dynamic_cast(_localctx)->payableSet = true; + break; + } + + case 3: { + setState(361); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(362); + match(SolidityParser::Internal); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 4: { + setState(364); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(365); + match(SolidityParser::Public); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + } + } + setState(371); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 28, _ctx); + } + setState(372); + dynamic_cast(_localctx)->body = block(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StateMutabilityContext ------------------------------------------------------------------ + +SolidityParser::StateMutabilityContext::StateMutabilityContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::StateMutabilityContext::Pure() { + return getToken(SolidityParser::Pure, 0); +} + +tree::TerminalNode* SolidityParser::StateMutabilityContext::View() { + return getToken(SolidityParser::View, 0); +} + +tree::TerminalNode* SolidityParser::StateMutabilityContext::Payable() { + return getToken(SolidityParser::Payable, 0); +} + + +size_t SolidityParser::StateMutabilityContext::getRuleIndex() const { + return SolidityParser::RuleStateMutability; +} + + +antlrcpp::Any SolidityParser::StateMutabilityContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStateMutability(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::StateMutabilityContext* SolidityParser::stateMutability() { + StateMutabilityContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, SolidityParser::RuleStateMutability); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(374); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SolidityParser::Payable) + | (1ULL << SolidityParser::Pure) + | (1ULL << SolidityParser::View))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- OverrideSpecifierContext ------------------------------------------------------------------ + +SolidityParser::OverrideSpecifierContext::OverrideSpecifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::OverrideSpecifierContext::Override() { + return getToken(SolidityParser::Override, 0); +} + +tree::TerminalNode* SolidityParser::OverrideSpecifierContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::OverrideSpecifierContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +std::vector SolidityParser::OverrideSpecifierContext::userDefinedTypeName() { + return getRuleContexts(); +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::OverrideSpecifierContext::userDefinedTypeName(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::OverrideSpecifierContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::OverrideSpecifierContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::OverrideSpecifierContext::getRuleIndex() const { + return SolidityParser::RuleOverrideSpecifier; +} + + +antlrcpp::Any SolidityParser::OverrideSpecifierContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitOverrideSpecifier(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::OverrideSpecifierContext* SolidityParser::overrideSpecifier() { + OverrideSpecifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, SolidityParser::RuleOverrideSpecifier); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(376); + match(SolidityParser::Override); + setState(388); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 30, _ctx)) { + case 1: { + setState(377); + match(SolidityParser::LParen); + setState(378); + dynamic_cast(_localctx)->userDefinedTypeNameContext = userDefinedTypeName(); + dynamic_cast(_localctx)->overrides.push_back(dynamic_cast(_localctx)->userDefinedTypeNameContext); + setState(383); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(379); + match(SolidityParser::Comma); + setState(380); + dynamic_cast(_localctx)->userDefinedTypeNameContext = userDefinedTypeName(); + dynamic_cast(_localctx)->overrides.push_back(dynamic_cast(_localctx)->userDefinedTypeNameContext); + setState(385); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(386); + match(SolidityParser::RParen); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FunctionDefinitionContext ------------------------------------------------------------------ + +SolidityParser::FunctionDefinitionContext::FunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Function() { + return getToken(SolidityParser::Function, 0); +} + +std::vector SolidityParser::FunctionDefinitionContext::LParen() { + return getTokens(SolidityParser::LParen); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::LParen(size_t i) { + return getToken(SolidityParser::LParen, i); +} + +std::vector SolidityParser::FunctionDefinitionContext::RParen() { + return getTokens(SolidityParser::RParen); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::RParen(size_t i) { + return getToken(SolidityParser::RParen, i); +} + +SolidityParser::IdentifierContext* SolidityParser::FunctionDefinitionContext::identifier() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Fallback() { + return getToken(SolidityParser::Fallback, 0); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Receive() { + return getToken(SolidityParser::Receive, 0); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +std::vector SolidityParser::FunctionDefinitionContext::visibility() { + return getRuleContexts(); +} + +SolidityParser::VisibilityContext* SolidityParser::FunctionDefinitionContext::visibility(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FunctionDefinitionContext::stateMutability() { + return getRuleContexts(); +} + +SolidityParser::StateMutabilityContext* SolidityParser::FunctionDefinitionContext::stateMutability(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FunctionDefinitionContext::modifierInvocation() { + return getRuleContexts(); +} + +SolidityParser::ModifierInvocationContext* SolidityParser::FunctionDefinitionContext::modifierInvocation(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FunctionDefinitionContext::Virtual() { + return getTokens(SolidityParser::Virtual); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Virtual(size_t i) { + return getToken(SolidityParser::Virtual, i); +} + +std::vector SolidityParser::FunctionDefinitionContext::overrideSpecifier() { + return getRuleContexts(); +} + +SolidityParser::OverrideSpecifierContext* SolidityParser::FunctionDefinitionContext::overrideSpecifier(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Returns() { + return getToken(SolidityParser::Returns, 0); +} + +SolidityParser::BlockContext* SolidityParser::FunctionDefinitionContext::block() { + return getRuleContext(0); +} + +std::vector SolidityParser::FunctionDefinitionContext::parameterList() { + return getRuleContexts(); +} + +SolidityParser::ParameterListContext* SolidityParser::FunctionDefinitionContext::parameterList(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::FunctionDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleFunctionDefinition; +} + + +antlrcpp::Any SolidityParser::FunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFunctionDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::FunctionDefinitionContext* SolidityParser::functionDefinition() { + FunctionDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 44, SolidityParser::RuleFunctionDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(390); + match(SolidityParser::Function); + setState(394); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::From: + case SolidityParser::Identifier: { + setState(391); + identifier(); + break; + } + + case SolidityParser::Fallback: { + setState(392); + match(SolidityParser::Fallback); + break; + } + + case SolidityParser::Receive: { + setState(393); + match(SolidityParser::Receive); + break; + } + + default: + throw NoViableAltException(this); + } + setState(396); + match(SolidityParser::LParen); + setState(398); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 32, _ctx)) { + case 1: { + setState(397); + dynamic_cast(_localctx)->arguments = parameterList(); + break; + } + + } + setState(400); + match(SolidityParser::RParen); + setState(419); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(417); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 33, _ctx)) { + case 1: { + setState(401); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(402); + visibility(); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 2: { + setState(405); + + if (!(!_localctx->mutabilitySet)) throw FailedPredicateException(this, "!$mutabilitySet"); + setState(406); + stateMutability(); + dynamic_cast(_localctx)->mutabilitySet = true; + break; + } + + case 3: { + setState(409); + modifierInvocation(); + break; + } + + case 4: { + setState(410); + + if (!(!_localctx->virtualSet)) throw FailedPredicateException(this, "!$virtualSet"); + setState(411); + match(SolidityParser::Virtual); + dynamic_cast(_localctx)->virtualSet = true; + break; + } + + case 5: { + setState(413); + + if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet"); + setState(414); + overrideSpecifier(); + dynamic_cast(_localctx)->overrideSpecifierSet = true; + break; + } + + } + } + setState(421); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + } + setState(427); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Returns) { + setState(422); + match(SolidityParser::Returns); + setState(423); + match(SolidityParser::LParen); + setState(424); + dynamic_cast(_localctx)->returnParameters = parameterList(); + setState(425); + match(SolidityParser::RParen); + } + setState(431); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::Semicolon: { + setState(429); + match(SolidityParser::Semicolon); + break; + } + + case SolidityParser::LBrace: { + setState(430); + dynamic_cast(_localctx)->body = block(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ModifierDefinitionContext ------------------------------------------------------------------ + +SolidityParser::ModifierDefinitionContext::ModifierDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ModifierDefinitionContext::Modifier() { + return getToken(SolidityParser::Modifier, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::ModifierDefinitionContext::identifier() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::ModifierDefinitionContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +tree::TerminalNode* SolidityParser::ModifierDefinitionContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::ModifierDefinitionContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +std::vector SolidityParser::ModifierDefinitionContext::Virtual() { + return getTokens(SolidityParser::Virtual); +} + +tree::TerminalNode* SolidityParser::ModifierDefinitionContext::Virtual(size_t i) { + return getToken(SolidityParser::Virtual, i); +} + +std::vector SolidityParser::ModifierDefinitionContext::overrideSpecifier() { + return getRuleContexts(); +} + +SolidityParser::OverrideSpecifierContext* SolidityParser::ModifierDefinitionContext::overrideSpecifier(size_t i) { + return getRuleContext(i); +} + +SolidityParser::BlockContext* SolidityParser::ModifierDefinitionContext::block() { + return getRuleContext(0); +} + +SolidityParser::ParameterListContext* SolidityParser::ModifierDefinitionContext::parameterList() { + return getRuleContext(0); +} + + +size_t SolidityParser::ModifierDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleModifierDefinition; +} + + +antlrcpp::Any SolidityParser::ModifierDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitModifierDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ModifierDefinitionContext* SolidityParser::modifierDefinition() { + ModifierDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 46, SolidityParser::RuleModifierDefinition); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(433); + match(SolidityParser::Modifier); + setState(434); + dynamic_cast(_localctx)->name = identifier(); + setState(440); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 38, _ctx)) { + case 1: { + setState(435); + match(SolidityParser::LParen); + setState(437); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 37, _ctx)) { + case 1: { + setState(436); + dynamic_cast(_localctx)->arguments = parameterList(); + break; + } + + } + setState(439); + match(SolidityParser::RParen); + break; + } + + } + setState(451); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 40, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(449); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 39, _ctx)) { + case 1: { + setState(442); + + if (!(!_localctx->virtualSet)) throw FailedPredicateException(this, "!$virtualSet"); + setState(443); + match(SolidityParser::Virtual); + dynamic_cast(_localctx)->virtualSet = true; + break; + } + + case 2: { + setState(445); + + if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet"); + setState(446); + overrideSpecifier(); + dynamic_cast(_localctx)->overrideSpecifierSet = true; + break; + } + + } + } + setState(453); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 40, _ctx); + } + setState(456); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::Semicolon: { + setState(454); + match(SolidityParser::Semicolon); + break; + } + + case SolidityParser::LBrace: { + setState(455); + dynamic_cast(_localctx)->body = block(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FallbackReceiveFunctionDefinitionContext ------------------------------------------------------------------ + +SolidityParser::FallbackReceiveFunctionDefinitionContext::FallbackReceiveFunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Fallback() { + return getToken(SolidityParser::Fallback, 0); +} + +tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Receive() { + return getToken(SolidityParser::Receive, 0); +} + +tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +std::vector SolidityParser::FallbackReceiveFunctionDefinitionContext::visibility() { + return getRuleContexts(); +} + +SolidityParser::VisibilityContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::visibility(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FallbackReceiveFunctionDefinitionContext::stateMutability() { + return getRuleContexts(); +} + +SolidityParser::StateMutabilityContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::stateMutability(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FallbackReceiveFunctionDefinitionContext::modifierInvocation() { + return getRuleContexts(); +} + +SolidityParser::ModifierInvocationContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::modifierInvocation(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FallbackReceiveFunctionDefinitionContext::Virtual() { + return getTokens(SolidityParser::Virtual); +} + +tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Virtual(size_t i) { + return getToken(SolidityParser::Virtual, i); +} + +std::vector SolidityParser::FallbackReceiveFunctionDefinitionContext::overrideSpecifier() { + return getRuleContexts(); +} + +SolidityParser::OverrideSpecifierContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::overrideSpecifier(size_t i) { + return getRuleContext(i); +} + +SolidityParser::BlockContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::block() { + return getRuleContext(0); +} + + +size_t SolidityParser::FallbackReceiveFunctionDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleFallbackReceiveFunctionDefinition; +} + + +antlrcpp::Any SolidityParser::FallbackReceiveFunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFallbackReceiveFunctionDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::FallbackReceiveFunctionDefinitionContext* SolidityParser::fallbackReceiveFunctionDefinition() { + FallbackReceiveFunctionDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, SolidityParser::RuleFallbackReceiveFunctionDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(458); + dynamic_cast(_localctx)->kind = _input->LT(1); + _la = _input->LA(1); + if (!(_la == SolidityParser::Fallback + + || _la == SolidityParser::Receive)) { + dynamic_cast(_localctx)->kind = _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(459); + match(SolidityParser::LParen); + setState(460); + match(SolidityParser::RParen); + setState(479); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 43, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(477); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 42, _ctx)) { + case 1: { + setState(461); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(462); + visibility(); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 2: { + setState(465); + + if (!(!_localctx->mutabilitySet)) throw FailedPredicateException(this, "!$mutabilitySet"); + setState(466); + stateMutability(); + dynamic_cast(_localctx)->mutabilitySet = true; + break; + } + + case 3: { + setState(469); + modifierInvocation(); + break; + } + + case 4: { + setState(470); + + if (!(!_localctx->virtualSet)) throw FailedPredicateException(this, "!$virtualSet"); + setState(471); + match(SolidityParser::Virtual); + dynamic_cast(_localctx)->virtualSet = true; + break; + } + + case 5: { + setState(473); + + if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet"); + setState(474); + overrideSpecifier(); + dynamic_cast(_localctx)->overrideSpecifierSet = true; + break; + } + + } + } + setState(481); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 43, _ctx); + } + setState(484); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::Semicolon: { + setState(482); + match(SolidityParser::Semicolon); + break; + } + + case SolidityParser::LBrace: { + setState(483); + dynamic_cast(_localctx)->body = block(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StructDefinitionContext ------------------------------------------------------------------ + +SolidityParser::StructDefinitionContext::StructDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::StructDefinitionContext::Struct() { + return getToken(SolidityParser::Struct, 0); +} + +tree::TerminalNode* SolidityParser::StructDefinitionContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::StructDefinitionContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::StructDefinitionContext::identifier() { + return getRuleContext(0); +} + +std::vector SolidityParser::StructDefinitionContext::structMember() { + return getRuleContexts(); +} + +SolidityParser::StructMemberContext* SolidityParser::StructDefinitionContext::structMember(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::StructDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleStructDefinition; +} + + +antlrcpp::Any SolidityParser::StructDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStructDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::StructDefinitionContext* SolidityParser::structDefinition() { + StructDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 50, SolidityParser::RuleStructDefinition); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(486); + match(SolidityParser::Struct); + setState(487); + dynamic_cast(_localctx)->name = identifier(); + setState(488); + match(SolidityParser::LBrace); + setState(490); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(489); + dynamic_cast(_localctx)->members = structMember(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(492); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 45, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + setState(494); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StructMemberContext ------------------------------------------------------------------ + +SolidityParser::StructMemberContext::StructMemberContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::StructMemberContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +SolidityParser::TypeNameContext* SolidityParser::StructMemberContext::typeName() { + return getRuleContext(0); +} + +SolidityParser::IdentifierContext* SolidityParser::StructMemberContext::identifier() { + return getRuleContext(0); +} + + +size_t SolidityParser::StructMemberContext::getRuleIndex() const { + return SolidityParser::RuleStructMember; +} + + +antlrcpp::Any SolidityParser::StructMemberContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStructMember(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::StructMemberContext* SolidityParser::structMember() { + StructMemberContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 52, SolidityParser::RuleStructMember); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(496); + dynamic_cast(_localctx)->type = typeName(0); + setState(497); + dynamic_cast(_localctx)->name = identifier(); + setState(498); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EnumDefinitionContext ------------------------------------------------------------------ + +SolidityParser::EnumDefinitionContext::EnumDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::EnumDefinitionContext::Enum() { + return getToken(SolidityParser::Enum, 0); +} + +tree::TerminalNode* SolidityParser::EnumDefinitionContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::EnumDefinitionContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +std::vector SolidityParser::EnumDefinitionContext::identifier() { + return getRuleContexts(); +} + +SolidityParser::IdentifierContext* SolidityParser::EnumDefinitionContext::identifier(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::EnumDefinitionContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::EnumDefinitionContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::EnumDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleEnumDefinition; +} + + +antlrcpp::Any SolidityParser::EnumDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEnumDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::EnumDefinitionContext* SolidityParser::enumDefinition() { + EnumDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 54, SolidityParser::RuleEnumDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(500); + match(SolidityParser::Enum); + setState(501); + dynamic_cast(_localctx)->name = identifier(); + setState(502); + match(SolidityParser::LBrace); + setState(503); + dynamic_cast(_localctx)->identifierContext = identifier(); + dynamic_cast(_localctx)->enumValues.push_back(dynamic_cast(_localctx)->identifierContext); + setState(508); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(504); + match(SolidityParser::Comma); + setState(505); + dynamic_cast(_localctx)->identifierContext = identifier(); + dynamic_cast(_localctx)->enumValues.push_back(dynamic_cast(_localctx)->identifierContext); + setState(510); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(511); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StateVariableDeclarationContext ------------------------------------------------------------------ + +SolidityParser::StateVariableDeclarationContext::StateVariableDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +SolidityParser::TypeNameContext* SolidityParser::StateVariableDeclarationContext::typeName() { + return getRuleContext(0); +} + +SolidityParser::IdentifierContext* SolidityParser::StateVariableDeclarationContext::identifier() { + return getRuleContext(0); +} + +std::vector SolidityParser::StateVariableDeclarationContext::Public() { + return getTokens(SolidityParser::Public); +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Public(size_t i) { + return getToken(SolidityParser::Public, i); +} + +std::vector SolidityParser::StateVariableDeclarationContext::Private() { + return getTokens(SolidityParser::Private); +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Private(size_t i) { + return getToken(SolidityParser::Private, i); +} + +std::vector SolidityParser::StateVariableDeclarationContext::Internal() { + return getTokens(SolidityParser::Internal); +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Internal(size_t i) { + return getToken(SolidityParser::Internal, i); +} + +std::vector SolidityParser::StateVariableDeclarationContext::Constant() { + return getTokens(SolidityParser::Constant); +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Constant(size_t i) { + return getToken(SolidityParser::Constant, i); +} + +std::vector SolidityParser::StateVariableDeclarationContext::overrideSpecifier() { + return getRuleContexts(); +} + +SolidityParser::OverrideSpecifierContext* SolidityParser::StateVariableDeclarationContext::overrideSpecifier(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::StateVariableDeclarationContext::Immutable() { + return getTokens(SolidityParser::Immutable); +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Immutable(size_t i) { + return getToken(SolidityParser::Immutable, i); +} + +tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Assign() { + return getToken(SolidityParser::Assign, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::StateVariableDeclarationContext::expression() { + return getRuleContext(0); +} + + +size_t SolidityParser::StateVariableDeclarationContext::getRuleIndex() const { + return SolidityParser::RuleStateVariableDeclaration; +} + + +antlrcpp::Any SolidityParser::StateVariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStateVariableDeclaration(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::StateVariableDeclarationContext* SolidityParser::stateVariableDeclaration() { + StateVariableDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 56, SolidityParser::RuleStateVariableDeclaration); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(513); + dynamic_cast(_localctx)->type = typeName(0); + setState(535); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 48, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(533); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 47, _ctx)) { + case 1: { + setState(514); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(515); + match(SolidityParser::Public); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 2: { + setState(517); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(518); + match(SolidityParser::Private); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 3: { + setState(520); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(521); + match(SolidityParser::Internal); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 4: { + setState(523); + + if (!(!_localctx->constantnessSet)) throw FailedPredicateException(this, "!$constantnessSet"); + setState(524); + match(SolidityParser::Constant); + dynamic_cast(_localctx)->constantnessSet = true; + break; + } + + case 5: { + setState(526); + + if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet"); + setState(527); + overrideSpecifier(); + dynamic_cast(_localctx)->overrideSpecifierSet = true; + break; + } + + case 6: { + setState(530); + + if (!(!_localctx->constantnessSet)) throw FailedPredicateException(this, "!$constantnessSet"); + setState(531); + match(SolidityParser::Immutable); + dynamic_cast(_localctx)->constantnessSet = true; + break; + } + + } + } + setState(537); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 48, _ctx); + } + setState(538); + dynamic_cast(_localctx)->name = identifier(); + setState(541); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Assign) { + setState(539); + match(SolidityParser::Assign); + setState(540); + dynamic_cast(_localctx)->initialValue = expression(0); + } + setState(543); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EventParameterContext ------------------------------------------------------------------ + +SolidityParser::EventParameterContext::EventParameterContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::TypeNameContext* SolidityParser::EventParameterContext::typeName() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::EventParameterContext::Indexed() { + return getToken(SolidityParser::Indexed, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::EventParameterContext::identifier() { + return getRuleContext(0); +} + + +size_t SolidityParser::EventParameterContext::getRuleIndex() const { + return SolidityParser::RuleEventParameter; +} + + +antlrcpp::Any SolidityParser::EventParameterContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEventParameter(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::EventParameterContext* SolidityParser::eventParameter() { + EventParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, SolidityParser::RuleEventParameter); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(545); + dynamic_cast(_localctx)->type = typeName(0); + setState(547); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Indexed) { + setState(546); + match(SolidityParser::Indexed); + } + setState(550); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::From || _la == SolidityParser::Identifier) { + setState(549); + dynamic_cast(_localctx)->name = identifier(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EventDefinitionContext ------------------------------------------------------------------ + +SolidityParser::EventDefinitionContext::EventDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::EventDefinitionContext::Event() { + return getToken(SolidityParser::Event, 0); +} + +tree::TerminalNode* SolidityParser::EventDefinitionContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::EventDefinitionContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +tree::TerminalNode* SolidityParser::EventDefinitionContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::EventDefinitionContext::identifier() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::EventDefinitionContext::Anonymous() { + return getToken(SolidityParser::Anonymous, 0); +} + +std::vector SolidityParser::EventDefinitionContext::eventParameter() { + return getRuleContexts(); +} + +SolidityParser::EventParameterContext* SolidityParser::EventDefinitionContext::eventParameter(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::EventDefinitionContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::EventDefinitionContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::EventDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleEventDefinition; +} + + +antlrcpp::Any SolidityParser::EventDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEventDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::EventDefinitionContext* SolidityParser::eventDefinition() { + EventDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 60, SolidityParser::RuleEventDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(552); + match(SolidityParser::Event); + setState(553); + dynamic_cast(_localctx)->name = identifier(); + setState(554); + match(SolidityParser::LParen); + setState(563); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 53, _ctx)) { + case 1: { + setState(555); + dynamic_cast(_localctx)->eventParameterContext = eventParameter(); + dynamic_cast(_localctx)->parameters.push_back(dynamic_cast(_localctx)->eventParameterContext); + setState(560); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(556); + match(SolidityParser::Comma); + setState(557); + dynamic_cast(_localctx)->eventParameterContext = eventParameter(); + dynamic_cast(_localctx)->parameters.push_back(dynamic_cast(_localctx)->eventParameterContext); + setState(562); + _errHandler->sync(this); + _la = _input->LA(1); + } + break; + } + + } + setState(565); + match(SolidityParser::RParen); + setState(567); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Anonymous) { + setState(566); + match(SolidityParser::Anonymous); + } + setState(569); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UsingDirectiveContext ------------------------------------------------------------------ + +SolidityParser::UsingDirectiveContext::UsingDirectiveContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::UsingDirectiveContext::Using() { + return getToken(SolidityParser::Using, 0); +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::UsingDirectiveContext::userDefinedTypeName() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::UsingDirectiveContext::For() { + return getToken(SolidityParser::For, 0); +} + +tree::TerminalNode* SolidityParser::UsingDirectiveContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +tree::TerminalNode* SolidityParser::UsingDirectiveContext::Mul() { + return getToken(SolidityParser::Mul, 0); +} + +SolidityParser::TypeNameContext* SolidityParser::UsingDirectiveContext::typeName() { + return getRuleContext(0); +} + + +size_t SolidityParser::UsingDirectiveContext::getRuleIndex() const { + return SolidityParser::RuleUsingDirective; +} + + +antlrcpp::Any SolidityParser::UsingDirectiveContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUsingDirective(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::UsingDirectiveContext* SolidityParser::usingDirective() { + UsingDirectiveContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, SolidityParser::RuleUsingDirective); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(571); + match(SolidityParser::Using); + setState(572); + userDefinedTypeName(); + setState(573); + match(SolidityParser::For); + setState(576); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 55, _ctx)) { + case 1: { + setState(574); + match(SolidityParser::Mul); + break; + } + + case 2: { + setState(575); + typeName(0); + break; + } + + } + setState(578); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TypeNameContext ------------------------------------------------------------------ + +SolidityParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::ElementaryTypeNameContext* SolidityParser::TypeNameContext::elementaryTypeName() { + return getRuleContext(0); +} + +SolidityParser::FunctionTypeNameContext* SolidityParser::TypeNameContext::functionTypeName() { + return getRuleContext(0); +} + +SolidityParser::MappingTypeContext* SolidityParser::TypeNameContext::mappingType() { + return getRuleContext(0); +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::TypeNameContext::userDefinedTypeName() { + return getRuleContext(0); +} + +SolidityParser::TypeNameContext* SolidityParser::TypeNameContext::typeName() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::TypeNameContext::LBrack() { + return getToken(SolidityParser::LBrack, 0); +} + +tree::TerminalNode* SolidityParser::TypeNameContext::RBrack() { + return getToken(SolidityParser::RBrack, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::TypeNameContext::expression() { + return getRuleContext(0); +} + + +size_t SolidityParser::TypeNameContext::getRuleIndex() const { + return SolidityParser::RuleTypeName; +} + + +antlrcpp::Any SolidityParser::TypeNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitTypeName(this); + else + return visitor->visitChildren(this); +} + + +SolidityParser::TypeNameContext* SolidityParser::typeName() { + return typeName(0); +} + +SolidityParser::TypeNameContext* SolidityParser::typeName(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SolidityParser::TypeNameContext *_localctx = _tracker.createInstance(_ctx, parentState); + SolidityParser::TypeNameContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 64; + enterRecursionRule(_localctx, 64, SolidityParser::RuleTypeName, precedence); + + + + auto onExit = finally([=] { + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(585); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 56, _ctx)) { + case 1: { + setState(581); + elementaryTypeName(true); + break; + } + + case 2: { + setState(582); + functionTypeName(); + break; + } + + case 3: { + setState(583); + mappingType(); + break; + } + + case 4: { + setState(584); + userDefinedTypeName(); + break; + } + + } + _ctx->stop = _input->LT(-1); + setState(595); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 58, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + _localctx = _tracker.createInstance(parentContext, parentState); + pushNewRecursionContext(_localctx, startState, RuleTypeName); + setState(587); + + if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(588); + match(SolidityParser::LBrack); + setState(590); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 57, _ctx)) { + case 1: { + setState(589); + expression(0); + break; + } + + } + setState(592); + match(SolidityParser::RBrack); + } + setState(597); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 58, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- ElementaryTypeNameContext ------------------------------------------------------------------ + +SolidityParser::ElementaryTypeNameContext::ElementaryTypeNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::ElementaryTypeNameContext::ElementaryTypeNameContext(ParserRuleContext *parent, size_t invokingState, bool allowAddressPayable) + : ParserRuleContext(parent, invokingState) { + this->allowAddressPayable = allowAddressPayable; +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Address() { + return getToken(SolidityParser::Address, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Payable() { + return getToken(SolidityParser::Payable, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Bool() { + return getToken(SolidityParser::Bool, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::String() { + return getToken(SolidityParser::String, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Bytes() { + return getToken(SolidityParser::Bytes, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::SignedIntegerType() { + return getToken(SolidityParser::SignedIntegerType, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::UnsignedIntegerType() { + return getToken(SolidityParser::UnsignedIntegerType, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::FixedBytes() { + return getToken(SolidityParser::FixedBytes, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Fixed() { + return getToken(SolidityParser::Fixed, 0); +} + +tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Ufixed() { + return getToken(SolidityParser::Ufixed, 0); +} + + +size_t SolidityParser::ElementaryTypeNameContext::getRuleIndex() const { + return SolidityParser::RuleElementaryTypeName; +} + + +antlrcpp::Any SolidityParser::ElementaryTypeNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitElementaryTypeName(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ElementaryTypeNameContext* SolidityParser::elementaryTypeName(bool allowAddressPayable) { + ElementaryTypeNameContext *_localctx = _tracker.createInstance(_ctx, getState(), allowAddressPayable); + enterRule(_localctx, 66, SolidityParser::RuleElementaryTypeName); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(610); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 59, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(598); + match(SolidityParser::Address); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(599); + + if (!(_localctx->allowAddressPayable)) throw FailedPredicateException(this, "$allowAddressPayable"); + setState(600); + match(SolidityParser::Address); + setState(601); + match(SolidityParser::Payable); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(602); + match(SolidityParser::Bool); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(603); + match(SolidityParser::String); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(604); + match(SolidityParser::Bytes); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(605); + match(SolidityParser::SignedIntegerType); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(606); + match(SolidityParser::UnsignedIntegerType); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(607); + match(SolidityParser::FixedBytes); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(608); + match(SolidityParser::Fixed); + break; + } + + case 10: { + enterOuterAlt(_localctx, 10); + setState(609); + match(SolidityParser::Ufixed); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- FunctionTypeNameContext ------------------------------------------------------------------ + +SolidityParser::FunctionTypeNameContext::FunctionTypeNameContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::FunctionTypeNameContext::Function() { + return getToken(SolidityParser::Function, 0); +} + +std::vector SolidityParser::FunctionTypeNameContext::LParen() { + return getTokens(SolidityParser::LParen); +} + +tree::TerminalNode* SolidityParser::FunctionTypeNameContext::LParen(size_t i) { + return getToken(SolidityParser::LParen, i); +} + +std::vector SolidityParser::FunctionTypeNameContext::RParen() { + return getTokens(SolidityParser::RParen); +} + +tree::TerminalNode* SolidityParser::FunctionTypeNameContext::RParen(size_t i) { + return getToken(SolidityParser::RParen, i); +} + +std::vector SolidityParser::FunctionTypeNameContext::visibility() { + return getRuleContexts(); +} + +SolidityParser::VisibilityContext* SolidityParser::FunctionTypeNameContext::visibility(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FunctionTypeNameContext::stateMutability() { + return getRuleContexts(); +} + +SolidityParser::StateMutabilityContext* SolidityParser::FunctionTypeNameContext::stateMutability(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::FunctionTypeNameContext::Returns() { + return getToken(SolidityParser::Returns, 0); +} + +std::vector SolidityParser::FunctionTypeNameContext::parameterList() { + return getRuleContexts(); +} + +SolidityParser::ParameterListContext* SolidityParser::FunctionTypeNameContext::parameterList(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::FunctionTypeNameContext::getRuleIndex() const { + return SolidityParser::RuleFunctionTypeName; +} + + +antlrcpp::Any SolidityParser::FunctionTypeNameContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFunctionTypeName(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::FunctionTypeNameContext* SolidityParser::functionTypeName() { + FunctionTypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 68, SolidityParser::RuleFunctionTypeName); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(612); + match(SolidityParser::Function); + setState(613); + match(SolidityParser::LParen); + setState(615); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 60, _ctx)) { + case 1: { + setState(614); + dynamic_cast(_localctx)->arguments = parameterList(); + break; + } + + } + setState(617); + match(SolidityParser::RParen); + setState(628); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 62, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(626); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 61, _ctx)) { + case 1: { + setState(618); + + if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet"); + setState(619); + visibility(); + dynamic_cast(_localctx)->visibilitySet = true; + break; + } + + case 2: { + setState(622); + + if (!(!_localctx->mutabilitySet)) throw FailedPredicateException(this, "!$mutabilitySet"); + setState(623); + stateMutability(); + dynamic_cast(_localctx)->mutabilitySet = true; + break; + } + + } + } + setState(630); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 62, _ctx); + } + setState(636); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 63, _ctx)) { + case 1: { + setState(631); + match(SolidityParser::Returns); + setState(632); + match(SolidityParser::LParen); + setState(633); + dynamic_cast(_localctx)->returnParameters = parameterList(); + setState(634); + match(SolidityParser::RParen); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VariableDeclarationContext ------------------------------------------------------------------ + +SolidityParser::VariableDeclarationContext::VariableDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::TypeNameContext* SolidityParser::VariableDeclarationContext::typeName() { + return getRuleContext(0); +} + +SolidityParser::IdentifierContext* SolidityParser::VariableDeclarationContext::identifier() { + return getRuleContext(0); +} + +SolidityParser::DataLocationContext* SolidityParser::VariableDeclarationContext::dataLocation() { + return getRuleContext(0); +} + + +size_t SolidityParser::VariableDeclarationContext::getRuleIndex() const { + return SolidityParser::RuleVariableDeclaration; +} + + +antlrcpp::Any SolidityParser::VariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVariableDeclaration(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::VariableDeclarationContext* SolidityParser::variableDeclaration() { + VariableDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 70, SolidityParser::RuleVariableDeclaration); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(638); + dynamic_cast(_localctx)->type = typeName(0); + setState(640); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SolidityParser::Calldata) + | (1ULL << SolidityParser::Memory) + | (1ULL << SolidityParser::Storage))) != 0)) { + setState(639); + dynamic_cast(_localctx)->location = dataLocation(); + } + setState(642); + dynamic_cast(_localctx)->name = identifier(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DataLocationContext ------------------------------------------------------------------ + +SolidityParser::DataLocationContext::DataLocationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::DataLocationContext::Memory() { + return getToken(SolidityParser::Memory, 0); +} + +tree::TerminalNode* SolidityParser::DataLocationContext::Storage() { + return getToken(SolidityParser::Storage, 0); +} + +tree::TerminalNode* SolidityParser::DataLocationContext::Calldata() { + return getToken(SolidityParser::Calldata, 0); +} + + +size_t SolidityParser::DataLocationContext::getRuleIndex() const { + return SolidityParser::RuleDataLocation; +} + + +antlrcpp::Any SolidityParser::DataLocationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitDataLocation(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::DataLocationContext* SolidityParser::dataLocation() { + DataLocationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 72, SolidityParser::RuleDataLocation); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(644); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << SolidityParser::Calldata) + | (1ULL << SolidityParser::Memory) + | (1ULL << SolidityParser::Storage))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpressionContext ------------------------------------------------------------------ + +SolidityParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t SolidityParser::ExpressionContext::getRuleIndex() const { + return SolidityParser::RuleExpression; +} + +void SolidityParser::ExpressionContext::copyFrom(ExpressionContext *ctx) { + ParserRuleContext::copyFrom(ctx); +} + +//----------------- UnaryPrefixOperationContext ------------------------------------------------------------------ + +SolidityParser::ExpressionContext* SolidityParser::UnaryPrefixOperationContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Inc() { + return getToken(SolidityParser::Inc, 0); +} + +tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Dec() { + return getToken(SolidityParser::Dec, 0); +} + +tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Not() { + return getToken(SolidityParser::Not, 0); +} + +tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::BitNot() { + return getToken(SolidityParser::BitNot, 0); +} + +tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Delete() { + return getToken(SolidityParser::Delete, 0); +} + +tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Sub() { + return getToken(SolidityParser::Sub, 0); +} + +SolidityParser::UnaryPrefixOperationContext::UnaryPrefixOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::UnaryPrefixOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnaryPrefixOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- PrimaryExpressionContext ------------------------------------------------------------------ + +SolidityParser::IdentifierContext* SolidityParser::PrimaryExpressionContext::identifier() { + return getRuleContext(0); +} + +SolidityParser::LiteralContext* SolidityParser::PrimaryExpressionContext::literal() { + return getRuleContext(0); +} + +SolidityParser::ElementaryTypeNameContext* SolidityParser::PrimaryExpressionContext::elementaryTypeName() { + return getRuleContext(0); +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::PrimaryExpressionContext::userDefinedTypeName() { + return getRuleContext(0); +} + +SolidityParser::PrimaryExpressionContext::PrimaryExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::PrimaryExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPrimaryExpression(this); + else + return visitor->visitChildren(this); +} +//----------------- OrderComparisonContext ------------------------------------------------------------------ + +std::vector SolidityParser::OrderComparisonContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::OrderComparisonContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::OrderComparisonContext::LessThan() { + return getToken(SolidityParser::LessThan, 0); +} + +tree::TerminalNode* SolidityParser::OrderComparisonContext::GreaterThan() { + return getToken(SolidityParser::GreaterThan, 0); +} + +tree::TerminalNode* SolidityParser::OrderComparisonContext::LessThanOrEqual() { + return getToken(SolidityParser::LessThanOrEqual, 0); +} + +tree::TerminalNode* SolidityParser::OrderComparisonContext::GreaterThanOrEqual() { + return getToken(SolidityParser::GreaterThanOrEqual, 0); +} + +SolidityParser::OrderComparisonContext::OrderComparisonContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::OrderComparisonContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitOrderComparison(this); + else + return visitor->visitChildren(this); +} +//----------------- ConditionalContext ------------------------------------------------------------------ + +std::vector SolidityParser::ConditionalContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::ConditionalContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::ConditionalContext::Conditional() { + return getToken(SolidityParser::Conditional, 0); +} + +tree::TerminalNode* SolidityParser::ConditionalContext::Colon() { + return getToken(SolidityParser::Colon, 0); +} + +SolidityParser::ConditionalContext::ConditionalContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::ConditionalContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitConditional(this); + else + return visitor->visitChildren(this); +} +//----------------- PayableConversionContext ------------------------------------------------------------------ + +tree::TerminalNode* SolidityParser::PayableConversionContext::Payable() { + return getToken(SolidityParser::Payable, 0); +} + +SolidityParser::CallArgumentListContext* SolidityParser::PayableConversionContext::callArgumentList() { + return getRuleContext(0); +} + +SolidityParser::PayableConversionContext::PayableConversionContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::PayableConversionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitPayableConversion(this); + else + return visitor->visitChildren(this); +} +//----------------- AssignmentContext ------------------------------------------------------------------ + +std::vector SolidityParser::AssignmentContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::AssignmentContext::expression(size_t i) { + return getRuleContext(i); +} + +SolidityParser::AssignOpContext* SolidityParser::AssignmentContext::assignOp() { + return getRuleContext(0); +} + +SolidityParser::AssignmentContext::AssignmentContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::AssignmentContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAssignment(this); + else + return visitor->visitChildren(this); +} +//----------------- UnarySuffixOperationContext ------------------------------------------------------------------ + +SolidityParser::ExpressionContext* SolidityParser::UnarySuffixOperationContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::UnarySuffixOperationContext::Inc() { + return getToken(SolidityParser::Inc, 0); +} + +tree::TerminalNode* SolidityParser::UnarySuffixOperationContext::Dec() { + return getToken(SolidityParser::Dec, 0); +} + +SolidityParser::UnarySuffixOperationContext::UnarySuffixOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::UnarySuffixOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnarySuffixOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- ShiftOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::ShiftOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::ShiftOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::ShiftOperationContext::Shl() { + return getToken(SolidityParser::Shl, 0); +} + +tree::TerminalNode* SolidityParser::ShiftOperationContext::Sar() { + return getToken(SolidityParser::Sar, 0); +} + +tree::TerminalNode* SolidityParser::ShiftOperationContext::Shr() { + return getToken(SolidityParser::Shr, 0); +} + +SolidityParser::ShiftOperationContext::ShiftOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::ShiftOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitShiftOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- BitAndOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::BitAndOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::BitAndOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::BitAndOperationContext::BitAnd() { + return getToken(SolidityParser::BitAnd, 0); +} + +SolidityParser::BitAndOperationContext::BitAndOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::BitAndOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBitAndOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- FunctionCallContext ------------------------------------------------------------------ + +SolidityParser::ExpressionContext* SolidityParser::FunctionCallContext::expression() { + return getRuleContext(0); +} + +SolidityParser::CallArgumentListContext* SolidityParser::FunctionCallContext::callArgumentList() { + return getRuleContext(0); +} + +SolidityParser::FunctionCallContext::FunctionCallContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::FunctionCallContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFunctionCall(this); + else + return visitor->visitChildren(this); +} +//----------------- IndexRangeAccessContext ------------------------------------------------------------------ + +std::vector SolidityParser::IndexRangeAccessContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::IndexRangeAccessContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::IndexRangeAccessContext::LBrack() { + return getToken(SolidityParser::LBrack, 0); +} + +tree::TerminalNode* SolidityParser::IndexRangeAccessContext::Colon() { + return getToken(SolidityParser::Colon, 0); +} + +tree::TerminalNode* SolidityParser::IndexRangeAccessContext::RBrack() { + return getToken(SolidityParser::RBrack, 0); +} + +SolidityParser::IndexRangeAccessContext::IndexRangeAccessContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::IndexRangeAccessContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIndexRangeAccess(this); + else + return visitor->visitChildren(this); +} +//----------------- NewExpressionContext ------------------------------------------------------------------ + +tree::TerminalNode* SolidityParser::NewExpressionContext::New() { + return getToken(SolidityParser::New, 0); +} + +SolidityParser::TypeNameContext* SolidityParser::NewExpressionContext::typeName() { + return getRuleContext(0); +} + +SolidityParser::NewExpressionContext::NewExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::NewExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNewExpression(this); + else + return visitor->visitChildren(this); +} +//----------------- IndexAccessContext ------------------------------------------------------------------ + +std::vector SolidityParser::IndexAccessContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::IndexAccessContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::IndexAccessContext::LBrack() { + return getToken(SolidityParser::LBrack, 0); +} + +tree::TerminalNode* SolidityParser::IndexAccessContext::RBrack() { + return getToken(SolidityParser::RBrack, 0); +} + +SolidityParser::IndexAccessContext::IndexAccessContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::IndexAccessContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIndexAccess(this); + else + return visitor->visitChildren(this); +} +//----------------- AddSubOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::AddSubOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::AddSubOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::AddSubOperationContext::Add() { + return getToken(SolidityParser::Add, 0); +} + +tree::TerminalNode* SolidityParser::AddSubOperationContext::Sub() { + return getToken(SolidityParser::Sub, 0); +} + +SolidityParser::AddSubOperationContext::AddSubOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::AddSubOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAddSubOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- BitOrOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::BitOrOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::BitOrOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::BitOrOperationContext::BitOr() { + return getToken(SolidityParser::BitOr, 0); +} + +SolidityParser::BitOrOperationContext::BitOrOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::BitOrOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBitOrOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- ExpOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::ExpOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::ExpOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::ExpOperationContext::Exp() { + return getToken(SolidityParser::Exp, 0); +} + +SolidityParser::ExpOperationContext::ExpOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::ExpOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- AndOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::AndOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::AndOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::AndOperationContext::And() { + return getToken(SolidityParser::And, 0); +} + +SolidityParser::AndOperationContext::AndOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::AndOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAndOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- InlineArrayContext ------------------------------------------------------------------ + +SolidityParser::InlineArrayExpressionContext* SolidityParser::InlineArrayContext::inlineArrayExpression() { + return getRuleContext(0); +} + +SolidityParser::InlineArrayContext::InlineArrayContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::InlineArrayContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInlineArray(this); + else + return visitor->visitChildren(this); +} +//----------------- OrOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::OrOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::OrOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::OrOperationContext::Or() { + return getToken(SolidityParser::Or, 0); +} + +SolidityParser::OrOperationContext::OrOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::OrOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitOrOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- MemberAccessContext ------------------------------------------------------------------ + +SolidityParser::ExpressionContext* SolidityParser::MemberAccessContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::MemberAccessContext::Period() { + return getToken(SolidityParser::Period, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::MemberAccessContext::identifier() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::MemberAccessContext::Address() { + return getToken(SolidityParser::Address, 0); +} + +SolidityParser::MemberAccessContext::MemberAccessContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::MemberAccessContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMemberAccess(this); + else + return visitor->visitChildren(this); +} +//----------------- MulDivModOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::MulDivModOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::MulDivModOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::MulDivModOperationContext::Mul() { + return getToken(SolidityParser::Mul, 0); +} + +tree::TerminalNode* SolidityParser::MulDivModOperationContext::Div() { + return getToken(SolidityParser::Div, 0); +} + +tree::TerminalNode* SolidityParser::MulDivModOperationContext::Mod() { + return getToken(SolidityParser::Mod, 0); +} + +SolidityParser::MulDivModOperationContext::MulDivModOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::MulDivModOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMulDivModOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- FunctionCallOptionsContext ------------------------------------------------------------------ + +SolidityParser::ExpressionContext* SolidityParser::FunctionCallOptionsContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::FunctionCallOptionsContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::FunctionCallOptionsContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +std::vector SolidityParser::FunctionCallOptionsContext::namedArgument() { + return getRuleContexts(); +} + +SolidityParser::NamedArgumentContext* SolidityParser::FunctionCallOptionsContext::namedArgument(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::FunctionCallOptionsContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::FunctionCallOptionsContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + +SolidityParser::FunctionCallOptionsContext::FunctionCallOptionsContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::FunctionCallOptionsContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitFunctionCallOptions(this); + else + return visitor->visitChildren(this); +} +//----------------- BitXorOperationContext ------------------------------------------------------------------ + +std::vector SolidityParser::BitXorOperationContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::BitXorOperationContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::BitXorOperationContext::BitXor() { + return getToken(SolidityParser::BitXor, 0); +} + +SolidityParser::BitXorOperationContext::BitXorOperationContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::BitXorOperationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBitXorOperation(this); + else + return visitor->visitChildren(this); +} +//----------------- TupleContext ------------------------------------------------------------------ + +SolidityParser::TupleExpressionContext* SolidityParser::TupleContext::tupleExpression() { + return getRuleContext(0); +} + +SolidityParser::TupleContext::TupleContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::TupleContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitTuple(this); + else + return visitor->visitChildren(this); +} +//----------------- EqualityComparisonContext ------------------------------------------------------------------ + +std::vector SolidityParser::EqualityComparisonContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::EqualityComparisonContext::expression(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::EqualityComparisonContext::Equal() { + return getToken(SolidityParser::Equal, 0); +} + +tree::TerminalNode* SolidityParser::EqualityComparisonContext::NotEqual() { + return getToken(SolidityParser::NotEqual, 0); +} + +SolidityParser::EqualityComparisonContext::EqualityComparisonContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::EqualityComparisonContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEqualityComparison(this); + else + return visitor->visitChildren(this); +} +//----------------- MetaTypeContext ------------------------------------------------------------------ + +tree::TerminalNode* SolidityParser::MetaTypeContext::Type() { + return getToken(SolidityParser::Type, 0); +} + +tree::TerminalNode* SolidityParser::MetaTypeContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +SolidityParser::TypeNameContext* SolidityParser::MetaTypeContext::typeName() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::MetaTypeContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +SolidityParser::MetaTypeContext::MetaTypeContext(ExpressionContext *ctx) { copyFrom(ctx); } + + +antlrcpp::Any SolidityParser::MetaTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMetaType(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ExpressionContext* SolidityParser::expression() { + return expression(0); +} + +SolidityParser::ExpressionContext* SolidityParser::expression(int precedence) { + ParserRuleContext *parentContext = _ctx; + size_t parentState = getState(); + SolidityParser::ExpressionContext *_localctx = _tracker.createInstance(_ctx, parentState); + SolidityParser::ExpressionContext *previousContext = _localctx; + (void)previousContext; // Silence compiler, in case the context is not used by generated code. + size_t startState = 74; + enterRecursionRule(_localctx, 74, SolidityParser::RuleExpression, precedence); + + size_t _la = 0; + + auto onExit = finally([=] { + unrollRecursionContexts(parentContext); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(666); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 66, _ctx)) { + case 1: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + + setState(647); + match(SolidityParser::Payable); + setState(648); + callArgumentList(); + break; + } + + case 2: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(649); + match(SolidityParser::Type); + setState(650); + match(SolidityParser::LParen); + setState(651); + typeName(0); + setState(652); + match(SolidityParser::RParen); + break; + } + + case 3: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(654); + _la = _input->LA(1); + if (!(_la == SolidityParser::Delete || ((((_la - 99) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 99)) & ((1ULL << (SolidityParser::Sub - 99)) + | (1ULL << (SolidityParser::Not - 99)) + | (1ULL << (SolidityParser::BitNot - 99)) + | (1ULL << (SolidityParser::Inc - 99)) + | (1ULL << (SolidityParser::Dec - 99)))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(655); + expression(19); + break; + } + + case 4: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(656); + match(SolidityParser::New); + setState(657); + typeName(0); + break; + } + + case 5: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(658); + tupleExpression(); + break; + } + + case 6: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(659); + inlineArrayExpression(); + break; + } + + case 7: { + _localctx = _tracker.createInstance(_localctx); + _ctx = _localctx; + previousContext = _localctx; + setState(664); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 65, _ctx)) { + case 1: { + setState(660); + identifier(); + break; + } + + case 2: { + setState(661); + literal(); + break; + } + + case 3: { + setState(662); + elementaryTypeName(false); + break; + } + + case 4: { + setState(663); + userDefinedTypeName(); + break; + } + + } + break; + } + + } + _ctx->stop = _input->LT(-1); + setState(752); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 74, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + if (!_parseListeners.empty()) + triggerExitRuleEvent(); + previousContext = _localctx; + setState(750); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 73, _ctx)) { + case 1: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(668); + + if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)"); + setState(669); + match(SolidityParser::Exp); + setState(670); + expression(17); + break; + } + + case 2: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(671); + + if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(672); + _la = _input->LA(1); + if (!(((((_la - 100) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 100)) & ((1ULL << (SolidityParser::Mul - 100)) + | (1ULL << (SolidityParser::Div - 100)) + | (1ULL << (SolidityParser::Mod - 100)))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(673); + expression(17); + break; + } + + case 3: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(674); + + if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(675); + _la = _input->LA(1); + if (!(_la == SolidityParser::Add + + || _la == SolidityParser::Sub)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(676); + expression(16); + break; + } + + case 4: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(677); + + if (!(precpred(_ctx, 14))) throw FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(678); + _la = _input->LA(1); + if (!(((((_la - 95) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 95)) & ((1ULL << (SolidityParser::Shl - 95)) + | (1ULL << (SolidityParser::Sar - 95)) + | (1ULL << (SolidityParser::Shr - 95)))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(679); + expression(15); + break; + } + + case 5: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(680); + + if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)"); + setState(681); + match(SolidityParser::BitAnd); + setState(682); + expression(14); + break; + } + + case 6: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(683); + + if (!(precpred(_ctx, 12))) throw FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(684); + match(SolidityParser::BitXor); + setState(685); + expression(13); + break; + } + + case 7: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(686); + + if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(687); + match(SolidityParser::BitOr); + setState(688); + expression(12); + break; + } + + case 8: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(689); + + if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(690); + _la = _input->LA(1); + if (!(((((_la - 106) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 106)) & ((1ULL << (SolidityParser::LessThan - 106)) + | (1ULL << (SolidityParser::GreaterThan - 106)) + | (1ULL << (SolidityParser::LessThanOrEqual - 106)) + | (1ULL << (SolidityParser::GreaterThanOrEqual - 106)))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(691); + expression(11); + break; + } + + case 9: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(692); + + if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(693); + _la = _input->LA(1); + if (!(_la == SolidityParser::Equal + + || _la == SolidityParser::NotEqual)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(694); + expression(10); + break; + } + + case 10: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(695); + + if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(696); + match(SolidityParser::And); + setState(697); + expression(9); + break; + } + + case 11: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(698); + + if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(699); + match(SolidityParser::Or); + setState(700); + expression(8); + break; + } + + case 12: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(701); + + if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(702); + match(SolidityParser::Conditional); + setState(703); + expression(0); + setState(704); + match(SolidityParser::Colon); + setState(705); + expression(6); + break; + } + + case 13: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(707); + + if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(708); + assignOp(); + setState(709); + expression(5); + break; + } + + case 14: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(711); + + if (!(precpred(_ctx, 26))) throw FailedPredicateException(this, "precpred(_ctx, 26)"); + setState(712); + match(SolidityParser::LBrack); + setState(714); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 67, _ctx)) { + case 1: { + setState(713); + dynamic_cast(_localctx)->index = expression(0); + break; + } + + } + setState(716); + match(SolidityParser::RBrack); + break; + } + + case 15: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(717); + + if (!(precpred(_ctx, 25))) throw FailedPredicateException(this, "precpred(_ctx, 25)"); + setState(718); + match(SolidityParser::LBrack); + setState(720); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 68, _ctx)) { + case 1: { + setState(719); + dynamic_cast(_localctx)->start = expression(0); + break; + } + + } + setState(722); + match(SolidityParser::Colon); + setState(724); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 69, _ctx)) { + case 1: { + setState(723); + dynamic_cast(_localctx)->end = expression(0); + break; + } + + } + setState(726); + match(SolidityParser::RBrack); + break; + } + + case 16: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(727); + + if (!(precpred(_ctx, 24))) throw FailedPredicateException(this, "precpred(_ctx, 24)"); + setState(728); + match(SolidityParser::Period); + setState(731); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::From: + case SolidityParser::Identifier: { + setState(729); + identifier(); + break; + } + + case SolidityParser::Address: { + setState(730); + match(SolidityParser::Address); + break; + } + + default: + throw NoViableAltException(this); + } + break; + } + + case 17: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(733); + + if (!(precpred(_ctx, 23))) throw FailedPredicateException(this, "precpred(_ctx, 23)"); + setState(734); + match(SolidityParser::LBrace); + setState(743); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::From || _la == SolidityParser::Identifier) { + setState(735); + namedArgument(); + setState(740); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(736); + match(SolidityParser::Comma); + setState(737); + namedArgument(); + setState(742); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(745); + match(SolidityParser::RBrace); + break; + } + + case 18: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(746); + + if (!(precpred(_ctx, 22))) throw FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(747); + callArgumentList(); + break; + } + + case 19: { + auto newContext = _tracker.createInstance(_tracker.createInstance(parentContext, parentState)); + _localctx = newContext; + pushNewRecursionContext(newContext, startState, RuleExpression); + setState(748); + + if (!(precpred(_ctx, 18))) throw FailedPredicateException(this, "precpred(_ctx, 18)"); + setState(749); + _la = _input->LA(1); + if (!(_la == SolidityParser::Inc + + || _la == SolidityParser::Dec)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + break; + } + + } + } + setState(754); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 74, _ctx); + } + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + return _localctx; +} + +//----------------- AssignOpContext ------------------------------------------------------------------ + +SolidityParser::AssignOpContext::AssignOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::AssignOpContext::Assign() { + return getToken(SolidityParser::Assign, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignBitOr() { + return getToken(SolidityParser::AssignBitOr, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignBitXor() { + return getToken(SolidityParser::AssignBitXor, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignBitAnd() { + return getToken(SolidityParser::AssignBitAnd, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignShl() { + return getToken(SolidityParser::AssignShl, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignSar() { + return getToken(SolidityParser::AssignSar, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignShr() { + return getToken(SolidityParser::AssignShr, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignAdd() { + return getToken(SolidityParser::AssignAdd, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignSub() { + return getToken(SolidityParser::AssignSub, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignMul() { + return getToken(SolidityParser::AssignMul, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignDiv() { + return getToken(SolidityParser::AssignDiv, 0); +} + +tree::TerminalNode* SolidityParser::AssignOpContext::AssignMod() { + return getToken(SolidityParser::AssignMod, 0); +} + + +size_t SolidityParser::AssignOpContext::getRuleIndex() const { + return SolidityParser::RuleAssignOp; +} + + +antlrcpp::Any SolidityParser::AssignOpContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAssignOp(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::AssignOpContext* SolidityParser::assignOp() { + AssignOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 76, SolidityParser::RuleAssignOp); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(755); + _la = _input->LA(1); + if (!(((((_la - 77) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 77)) & ((1ULL << (SolidityParser::Assign - 77)) + | (1ULL << (SolidityParser::AssignBitOr - 77)) + | (1ULL << (SolidityParser::AssignBitXor - 77)) + | (1ULL << (SolidityParser::AssignBitAnd - 77)) + | (1ULL << (SolidityParser::AssignShl - 77)) + | (1ULL << (SolidityParser::AssignSar - 77)) + | (1ULL << (SolidityParser::AssignShr - 77)) + | (1ULL << (SolidityParser::AssignAdd - 77)) + | (1ULL << (SolidityParser::AssignSub - 77)) + | (1ULL << (SolidityParser::AssignMul - 77)) + | (1ULL << (SolidityParser::AssignDiv - 77)) + | (1ULL << (SolidityParser::AssignMod - 77)))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TupleExpressionContext ------------------------------------------------------------------ + +SolidityParser::TupleExpressionContext::TupleExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::TupleExpressionContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::TupleExpressionContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +std::vector SolidityParser::TupleExpressionContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::TupleExpressionContext::expression(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::TupleExpressionContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::TupleExpressionContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::TupleExpressionContext::getRuleIndex() const { + return SolidityParser::RuleTupleExpression; +} + + +antlrcpp::Any SolidityParser::TupleExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitTupleExpression(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::TupleExpressionContext* SolidityParser::tupleExpression() { + TupleExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 78, SolidityParser::RuleTupleExpression); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(757); + match(SolidityParser::LParen); + + setState(759); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 75, _ctx)) { + case 1: { + setState(758); + expression(0); + break; + } + + } + setState(767); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(761); + match(SolidityParser::Comma); + setState(763); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 76, _ctx)) { + case 1: { + setState(762); + expression(0); + break; + } + + } + setState(769); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(770); + match(SolidityParser::RParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- InlineArrayExpressionContext ------------------------------------------------------------------ + +SolidityParser::InlineArrayExpressionContext::InlineArrayExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::InlineArrayExpressionContext::LBrack() { + return getToken(SolidityParser::LBrack, 0); +} + +tree::TerminalNode* SolidityParser::InlineArrayExpressionContext::RBrack() { + return getToken(SolidityParser::RBrack, 0); +} + +std::vector SolidityParser::InlineArrayExpressionContext::expression() { + return getRuleContexts(); +} + +SolidityParser::ExpressionContext* SolidityParser::InlineArrayExpressionContext::expression(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::InlineArrayExpressionContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::InlineArrayExpressionContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::InlineArrayExpressionContext::getRuleIndex() const { + return SolidityParser::RuleInlineArrayExpression; +} + + +antlrcpp::Any SolidityParser::InlineArrayExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitInlineArrayExpression(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::InlineArrayExpressionContext* SolidityParser::inlineArrayExpression() { + InlineArrayExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 80, SolidityParser::RuleInlineArrayExpression); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(772); + match(SolidityParser::LBrack); + + setState(773); + expression(0); + setState(778); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(774); + match(SolidityParser::Comma); + setState(775); + expression(0); + setState(780); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(781); + match(SolidityParser::RBrack); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IdentifierContext ------------------------------------------------------------------ + +SolidityParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::IdentifierContext::Identifier() { + return getToken(SolidityParser::Identifier, 0); +} + +tree::TerminalNode* SolidityParser::IdentifierContext::From() { + return getToken(SolidityParser::From, 0); +} + + +size_t SolidityParser::IdentifierContext::getRuleIndex() const { + return SolidityParser::RuleIdentifier; +} + + +antlrcpp::Any SolidityParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIdentifier(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::IdentifierContext* SolidityParser::identifier() { + IdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 82, SolidityParser::RuleIdentifier); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(783); + _la = _input->LA(1); + if (!(_la == SolidityParser::From || _la == SolidityParser::Identifier)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- LiteralContext ------------------------------------------------------------------ + +SolidityParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::StringLiteralContext* SolidityParser::LiteralContext::stringLiteral() { + return getRuleContext(0); +} + +SolidityParser::NumberLiteralContext* SolidityParser::LiteralContext::numberLiteral() { + return getRuleContext(0); +} + +SolidityParser::boolLiteralContext* SolidityParser::LiteralContext::boolLiteral() { + return getRuleContext(0); +} + +SolidityParser::HexStringLiteralContext* SolidityParser::LiteralContext::hexStringLiteral() { + return getRuleContext(0); +} + +SolidityParser::UnicodeStringLiteralContext* SolidityParser::LiteralContext::unicodeStringLiteral() { + return getRuleContext(0); +} + + +size_t SolidityParser::LiteralContext::getRuleIndex() const { + return SolidityParser::RuleLiteral; +} + + +antlrcpp::Any SolidityParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::LiteralContext* SolidityParser::literal() { + LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 84, SolidityParser::RuleLiteral); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(790); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::StringLiteral: { + enterOuterAlt(_localctx, 1); + setState(785); + stringLiteral(); + break; + } + + case SolidityParser::HexNumber: + case SolidityParser::DecimalNumber: { + enterOuterAlt(_localctx, 2); + setState(786); + numberLiteral(); + break; + } + + case SolidityParser::False: + case SolidityParser::True: { + enterOuterAlt(_localctx, 3); + setState(787); + boolLiteral(); + break; + } + + case SolidityParser::HexString: { + enterOuterAlt(_localctx, 4); + setState(788); + hexStringLiteral(); + break; + } + + case SolidityParser::UnicodeStringLiteral: { + enterOuterAlt(_localctx, 5); + setState(789); + unicodeStringLiteral(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- boolLiteralContext ------------------------------------------------------------------ + +SolidityParser::boolLiteralContext::boolLiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::boolLiteralContext::True() { + return getToken(SolidityParser::True, 0); +} + +tree::TerminalNode* SolidityParser::boolLiteralContext::False() { + return getToken(SolidityParser::False, 0); +} + + +size_t SolidityParser::boolLiteralContext::getRuleIndex() const { + return SolidityParser::RuleboolLiteral; +} + + +antlrcpp::Any SolidityParser::boolLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBooleanLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::boolLiteralContext* SolidityParser::boolLiteral() { + boolLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 86, SolidityParser::RuleboolLiteral); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(792); + _la = _input->LA(1); + if (!(_la == SolidityParser::False + + || _la == SolidityParser::True)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StringLiteralContext ------------------------------------------------------------------ + +SolidityParser::StringLiteralContext::StringLiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::StringLiteralContext::StringLiteral() { + return getTokens(SolidityParser::StringLiteral); +} + +tree::TerminalNode* SolidityParser::StringLiteralContext::StringLiteral(size_t i) { + return getToken(SolidityParser::StringLiteral, i); +} + + +size_t SolidityParser::StringLiteralContext::getRuleIndex() const { + return SolidityParser::RuleStringLiteral; +} + + +antlrcpp::Any SolidityParser::StringLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStringLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::StringLiteralContext* SolidityParser::stringLiteral() { + StringLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 88, SolidityParser::RuleStringLiteral); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(795); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(794); + match(SolidityParser::StringLiteral); + break; + } + + default: + throw NoViableAltException(this); + } + setState(797); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 80, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- HexStringLiteralContext ------------------------------------------------------------------ + +SolidityParser::HexStringLiteralContext::HexStringLiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::HexStringLiteralContext::HexString() { + return getTokens(SolidityParser::HexString); +} + +tree::TerminalNode* SolidityParser::HexStringLiteralContext::HexString(size_t i) { + return getToken(SolidityParser::HexString, i); +} + + +size_t SolidityParser::HexStringLiteralContext::getRuleIndex() const { + return SolidityParser::RuleHexStringLiteral; +} + + +antlrcpp::Any SolidityParser::HexStringLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitHexStringLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::HexStringLiteralContext* SolidityParser::hexStringLiteral() { + HexStringLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 90, SolidityParser::RuleHexStringLiteral); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(800); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(799); + match(SolidityParser::HexString); + break; + } + + default: + throw NoViableAltException(this); + } + setState(802); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 81, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- UnicodeStringLiteralContext ------------------------------------------------------------------ + +SolidityParser::UnicodeStringLiteralContext::UnicodeStringLiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::UnicodeStringLiteralContext::UnicodeStringLiteral() { + return getTokens(SolidityParser::UnicodeStringLiteral); +} + +tree::TerminalNode* SolidityParser::UnicodeStringLiteralContext::UnicodeStringLiteral(size_t i) { + return getToken(SolidityParser::UnicodeStringLiteral, i); +} + + +size_t SolidityParser::UnicodeStringLiteralContext::getRuleIndex() const { + return SolidityParser::RuleUnicodeStringLiteral; +} + + +antlrcpp::Any SolidityParser::UnicodeStringLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitUnicodeStringLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::UnicodeStringLiteralContext* SolidityParser::unicodeStringLiteral() { + UnicodeStringLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 92, SolidityParser::RuleUnicodeStringLiteral); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(805); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(804); + match(SolidityParser::UnicodeStringLiteral); + break; + } + + default: + throw NoViableAltException(this); + } + setState(807); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 82, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- NumberLiteralContext ------------------------------------------------------------------ + +SolidityParser::NumberLiteralContext::NumberLiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::NumberLiteralContext::DecimalNumber() { + return getToken(SolidityParser::DecimalNumber, 0); +} + +tree::TerminalNode* SolidityParser::NumberLiteralContext::HexNumber() { + return getToken(SolidityParser::HexNumber, 0); +} + +tree::TerminalNode* SolidityParser::NumberLiteralContext::NumberUnit() { + return getToken(SolidityParser::NumberUnit, 0); +} + + +size_t SolidityParser::NumberLiteralContext::getRuleIndex() const { + return SolidityParser::RuleNumberLiteral; +} + + +antlrcpp::Any SolidityParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitNumberLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::NumberLiteralContext* SolidityParser::numberLiteral() { + NumberLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 94, SolidityParser::RuleNumberLiteral); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(809); + _la = _input->LA(1); + if (!(_la == SolidityParser::HexNumber + + || _la == SolidityParser::DecimalNumber)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(811); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 83, _ctx)) { + case 1: { + setState(810); + match(SolidityParser::NumberUnit); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BlockContext ------------------------------------------------------------------ + +SolidityParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::BlockContext::LBrace() { + return getToken(SolidityParser::LBrace, 0); +} + +tree::TerminalNode* SolidityParser::BlockContext::RBrace() { + return getToken(SolidityParser::RBrace, 0); +} + +std::vector SolidityParser::BlockContext::statement() { + return getRuleContexts(); +} + +SolidityParser::StatementContext* SolidityParser::BlockContext::statement(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::BlockContext::getRuleIndex() const { + return SolidityParser::RuleBlock; +} + + +antlrcpp::Any SolidityParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBlock(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::BlockContext* SolidityParser::block() { + BlockContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 96, SolidityParser::RuleBlock); + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(813); + match(SolidityParser::LBrace); + setState(817); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 84, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(814); + statement(); + } + setState(819); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 84, _ctx); + } + setState(820); + match(SolidityParser::RBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StatementContext ------------------------------------------------------------------ + +SolidityParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::BlockContext* SolidityParser::StatementContext::block() { + return getRuleContext(0); +} + +SolidityParser::SimpleStatementContext* SolidityParser::StatementContext::simpleStatement() { + return getRuleContext(0); +} + +SolidityParser::IfStatementContext* SolidityParser::StatementContext::ifStatement() { + return getRuleContext(0); +} + +SolidityParser::ForStatementContext* SolidityParser::StatementContext::forStatement() { + return getRuleContext(0); +} + +SolidityParser::WhileStatementContext* SolidityParser::StatementContext::whileStatement() { + return getRuleContext(0); +} + +SolidityParser::DoWhileStatementContext* SolidityParser::StatementContext::doWhileStatement() { + return getRuleContext(0); +} + +SolidityParser::ContinueStatementContext* SolidityParser::StatementContext::continueStatement() { + return getRuleContext(0); +} + +SolidityParser::BreakStatementContext* SolidityParser::StatementContext::breakStatement() { + return getRuleContext(0); +} + +SolidityParser::TryStatementContext* SolidityParser::StatementContext::tryStatement() { + return getRuleContext(0); +} + +SolidityParser::ReturnStatementContext* SolidityParser::StatementContext::returnStatement() { + return getRuleContext(0); +} + +SolidityParser::EmitStatementContext* SolidityParser::StatementContext::emitStatement() { + return getRuleContext(0); +} + +SolidityParser::AssemblyStatementContext* SolidityParser::StatementContext::assemblyStatement() { + return getRuleContext(0); +} + + +size_t SolidityParser::StatementContext::getRuleIndex() const { + return SolidityParser::RuleStatement; +} + + +antlrcpp::Any SolidityParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::StatementContext* SolidityParser::statement() { + StatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 98, SolidityParser::RuleStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(834); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 85, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(822); + block(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(823); + simpleStatement(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(824); + ifStatement(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(825); + forStatement(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(826); + whileStatement(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(827); + doWhileStatement(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(828); + continueStatement(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(829); + breakStatement(); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(830); + tryStatement(); + break; + } + + case 10: { + enterOuterAlt(_localctx, 10); + setState(831); + returnStatement(); + break; + } + + case 11: { + enterOuterAlt(_localctx, 11); + setState(832); + emitStatement(); + break; + } + + case 12: { + enterOuterAlt(_localctx, 12); + setState(833); + assemblyStatement(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SimpleStatementContext ------------------------------------------------------------------ + +SolidityParser::SimpleStatementContext::SimpleStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::VariableDeclarationStatementContext* SolidityParser::SimpleStatementContext::variableDeclarationStatement() { + return getRuleContext(0); +} + +SolidityParser::ExpressionStatementContext* SolidityParser::SimpleStatementContext::expressionStatement() { + return getRuleContext(0); +} + + +size_t SolidityParser::SimpleStatementContext::getRuleIndex() const { + return SolidityParser::RuleSimpleStatement; +} + + +antlrcpp::Any SolidityParser::SimpleStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitSimpleStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::SimpleStatementContext* SolidityParser::simpleStatement() { + SimpleStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 100, SolidityParser::RuleSimpleStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(838); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 86, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(836); + variableDeclarationStatement(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(837); + expressionStatement(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- IfStatementContext ------------------------------------------------------------------ + +SolidityParser::IfStatementContext::IfStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::IfStatementContext::If() { + return getToken(SolidityParser::If, 0); +} + +tree::TerminalNode* SolidityParser::IfStatementContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::IfStatementContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::IfStatementContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +std::vector SolidityParser::IfStatementContext::statement() { + return getRuleContexts(); +} + +SolidityParser::StatementContext* SolidityParser::IfStatementContext::statement(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::IfStatementContext::Else() { + return getToken(SolidityParser::Else, 0); +} + + +size_t SolidityParser::IfStatementContext::getRuleIndex() const { + return SolidityParser::RuleIfStatement; +} + + +antlrcpp::Any SolidityParser::IfStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitIfStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::IfStatementContext* SolidityParser::ifStatement() { + IfStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 102, SolidityParser::RuleIfStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(840); + match(SolidityParser::If); + setState(841); + match(SolidityParser::LParen); + setState(842); + expression(0); + setState(843); + match(SolidityParser::RParen); + setState(844); + statement(); + setState(847); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 87, _ctx)) { + case 1: { + setState(845); + match(SolidityParser::Else); + setState(846); + statement(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ForStatementContext ------------------------------------------------------------------ + +SolidityParser::ForStatementContext::ForStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ForStatementContext::For() { + return getToken(SolidityParser::For, 0); +} + +tree::TerminalNode* SolidityParser::ForStatementContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::ForStatementContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +SolidityParser::StatementContext* SolidityParser::ForStatementContext::statement() { + return getRuleContext(0); +} + +SolidityParser::SimpleStatementContext* SolidityParser::ForStatementContext::simpleStatement() { + return getRuleContext(0); +} + +std::vector SolidityParser::ForStatementContext::Semicolon() { + return getTokens(SolidityParser::Semicolon); +} + +tree::TerminalNode* SolidityParser::ForStatementContext::Semicolon(size_t i) { + return getToken(SolidityParser::Semicolon, i); +} + +SolidityParser::ExpressionStatementContext* SolidityParser::ForStatementContext::expressionStatement() { + return getRuleContext(0); +} + +SolidityParser::ExpressionContext* SolidityParser::ForStatementContext::expression() { + return getRuleContext(0); +} + + +size_t SolidityParser::ForStatementContext::getRuleIndex() const { + return SolidityParser::RuleForStatement; +} + + +antlrcpp::Any SolidityParser::ForStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitForStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ForStatementContext* SolidityParser::forStatement() { + ForStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 104, SolidityParser::RuleForStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(849); + match(SolidityParser::For); + setState(850); + match(SolidityParser::LParen); + setState(853); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 88, _ctx)) { + case 1: { + setState(851); + simpleStatement(); + break; + } + + case 2: { + setState(852); + match(SolidityParser::Semicolon); + break; + } + + } + setState(857); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 89, _ctx)) { + case 1: { + setState(855); + expressionStatement(); + break; + } + + case 2: { + setState(856); + match(SolidityParser::Semicolon); + break; + } + + } + setState(860); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 90, _ctx)) { + case 1: { + setState(859); + expression(0); + break; + } + + } + setState(862); + match(SolidityParser::RParen); + setState(863); + statement(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- WhileStatementContext ------------------------------------------------------------------ + +SolidityParser::WhileStatementContext::WhileStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::WhileStatementContext::While() { + return getToken(SolidityParser::While, 0); +} + +tree::TerminalNode* SolidityParser::WhileStatementContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::WhileStatementContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::WhileStatementContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +SolidityParser::StatementContext* SolidityParser::WhileStatementContext::statement() { + return getRuleContext(0); +} + + +size_t SolidityParser::WhileStatementContext::getRuleIndex() const { + return SolidityParser::RuleWhileStatement; +} + + +antlrcpp::Any SolidityParser::WhileStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitWhileStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::WhileStatementContext* SolidityParser::whileStatement() { + WhileStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 106, SolidityParser::RuleWhileStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(865); + match(SolidityParser::While); + setState(866); + match(SolidityParser::LParen); + setState(867); + expression(0); + setState(868); + match(SolidityParser::RParen); + setState(869); + statement(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- DoWhileStatementContext ------------------------------------------------------------------ + +SolidityParser::DoWhileStatementContext::DoWhileStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::DoWhileStatementContext::Do() { + return getToken(SolidityParser::Do, 0); +} + +SolidityParser::StatementContext* SolidityParser::DoWhileStatementContext::statement() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::DoWhileStatementContext::While() { + return getToken(SolidityParser::While, 0); +} + +tree::TerminalNode* SolidityParser::DoWhileStatementContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::DoWhileStatementContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::DoWhileStatementContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +tree::TerminalNode* SolidityParser::DoWhileStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + + +size_t SolidityParser::DoWhileStatementContext::getRuleIndex() const { + return SolidityParser::RuleDoWhileStatement; +} + + +antlrcpp::Any SolidityParser::DoWhileStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitDoWhileStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::DoWhileStatementContext* SolidityParser::doWhileStatement() { + DoWhileStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 108, SolidityParser::RuleDoWhileStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(871); + match(SolidityParser::Do); + setState(872); + statement(); + setState(873); + match(SolidityParser::While); + setState(874); + match(SolidityParser::LParen); + setState(875); + expression(0); + setState(876); + match(SolidityParser::RParen); + setState(877); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ContinueStatementContext ------------------------------------------------------------------ + +SolidityParser::ContinueStatementContext::ContinueStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ContinueStatementContext::Continue() { + return getToken(SolidityParser::Continue, 0); +} + +tree::TerminalNode* SolidityParser::ContinueStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + + +size_t SolidityParser::ContinueStatementContext::getRuleIndex() const { + return SolidityParser::RuleContinueStatement; +} + + +antlrcpp::Any SolidityParser::ContinueStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitContinueStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ContinueStatementContext* SolidityParser::continueStatement() { + ContinueStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 110, SolidityParser::RuleContinueStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(879); + match(SolidityParser::Continue); + setState(880); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- BreakStatementContext ------------------------------------------------------------------ + +SolidityParser::BreakStatementContext::BreakStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::BreakStatementContext::Break() { + return getToken(SolidityParser::Break, 0); +} + +tree::TerminalNode* SolidityParser::BreakStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + + +size_t SolidityParser::BreakStatementContext::getRuleIndex() const { + return SolidityParser::RuleBreakStatement; +} + + +antlrcpp::Any SolidityParser::BreakStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitBreakStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::BreakStatementContext* SolidityParser::breakStatement() { + BreakStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 112, SolidityParser::RuleBreakStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(882); + match(SolidityParser::Break); + setState(883); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TryStatementContext ------------------------------------------------------------------ + +SolidityParser::TryStatementContext::TryStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::TryStatementContext::Try() { + return getToken(SolidityParser::Try, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::TryStatementContext::expression() { + return getRuleContext(0); +} + +SolidityParser::BlockContext* SolidityParser::TryStatementContext::block() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::TryStatementContext::Returns() { + return getToken(SolidityParser::Returns, 0); +} + +tree::TerminalNode* SolidityParser::TryStatementContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::TryStatementContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +std::vector SolidityParser::TryStatementContext::catchClause() { + return getRuleContexts(); +} + +SolidityParser::CatchClauseContext* SolidityParser::TryStatementContext::catchClause(size_t i) { + return getRuleContext(i); +} + +SolidityParser::ParameterListContext* SolidityParser::TryStatementContext::parameterList() { + return getRuleContext(0); +} + + +size_t SolidityParser::TryStatementContext::getRuleIndex() const { + return SolidityParser::RuleTryStatement; +} + + +antlrcpp::Any SolidityParser::TryStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitTryStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::TryStatementContext* SolidityParser::tryStatement() { + TryStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 114, SolidityParser::RuleTryStatement); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(885); + match(SolidityParser::Try); + setState(886); + expression(0); + setState(892); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Returns) { + setState(887); + match(SolidityParser::Returns); + setState(888); + match(SolidityParser::LParen); + setState(889); + dynamic_cast(_localctx)->returnParameters = parameterList(); + setState(890); + match(SolidityParser::RParen); + } + setState(894); + block(); + setState(896); + _errHandler->sync(this); + alt = 1; + do { + switch (alt) { + case 1: { + setState(895); + catchClause(); + break; + } + + default: + throw NoViableAltException(this); + } + setState(898); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 92, _ctx); + } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- CatchClauseContext ------------------------------------------------------------------ + +SolidityParser::CatchClauseContext::CatchClauseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::CatchClauseContext::Catch() { + return getToken(SolidityParser::Catch, 0); +} + +SolidityParser::BlockContext* SolidityParser::CatchClauseContext::block() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::CatchClauseContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::CatchClauseContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +SolidityParser::IdentifierContext* SolidityParser::CatchClauseContext::identifier() { + return getRuleContext(0); +} + +SolidityParser::ParameterListContext* SolidityParser::CatchClauseContext::parameterList() { + return getRuleContext(0); +} + + +size_t SolidityParser::CatchClauseContext::getRuleIndex() const { + return SolidityParser::RuleCatchClause; +} + + +antlrcpp::Any SolidityParser::CatchClauseContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitCatchClause(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::CatchClauseContext* SolidityParser::catchClause() { + CatchClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 116, SolidityParser::RuleCatchClause); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(900); + match(SolidityParser::Catch); + setState(908); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::From || _la == SolidityParser::LParen + + || _la == SolidityParser::Identifier) { + setState(902); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::From || _la == SolidityParser::Identifier) { + setState(901); + identifier(); + } + setState(904); + match(SolidityParser::LParen); + + setState(905); + dynamic_cast(_localctx)->arguments = parameterList(); + setState(906); + match(SolidityParser::RParen); + } + setState(910); + block(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ReturnStatementContext ------------------------------------------------------------------ + +SolidityParser::ReturnStatementContext::ReturnStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::ReturnStatementContext::Return() { + return getToken(SolidityParser::Return, 0); +} + +tree::TerminalNode* SolidityParser::ReturnStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::ReturnStatementContext::expression() { + return getRuleContext(0); +} + + +size_t SolidityParser::ReturnStatementContext::getRuleIndex() const { + return SolidityParser::RuleReturnStatement; +} + + +antlrcpp::Any SolidityParser::ReturnStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitReturnStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ReturnStatementContext* SolidityParser::returnStatement() { + ReturnStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 118, SolidityParser::RuleReturnStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(912); + match(SolidityParser::Return); + setState(914); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 95, _ctx)) { + case 1: { + setState(913); + expression(0); + break; + } + + } + setState(916); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- EmitStatementContext ------------------------------------------------------------------ + +SolidityParser::EmitStatementContext::EmitStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::EmitStatementContext::Emit() { + return getToken(SolidityParser::Emit, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::EmitStatementContext::expression() { + return getRuleContext(0); +} + +SolidityParser::CallArgumentListContext* SolidityParser::EmitStatementContext::callArgumentList() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::EmitStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + + +size_t SolidityParser::EmitStatementContext::getRuleIndex() const { + return SolidityParser::RuleEmitStatement; +} + + +antlrcpp::Any SolidityParser::EmitStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitEmitStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::EmitStatementContext* SolidityParser::emitStatement() { + EmitStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 120, SolidityParser::RuleEmitStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(918); + match(SolidityParser::Emit); + setState(919); + expression(0); + setState(920); + callArgumentList(); + setState(921); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- AssemblyStatementContext ------------------------------------------------------------------ + +SolidityParser::AssemblyStatementContext::AssemblyStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::AssemblyStatementContext::Assembly() { + return getToken(SolidityParser::Assembly, 0); +} + +tree::TerminalNode* SolidityParser::AssemblyStatementContext::AssemblyLBrace() { + return getToken(SolidityParser::AssemblyLBrace, 0); +} + +tree::TerminalNode* SolidityParser::AssemblyStatementContext::YulRBrace() { + return getToken(SolidityParser::YulRBrace, 0); +} + +tree::TerminalNode* SolidityParser::AssemblyStatementContext::AssemblyDialect() { + return getToken(SolidityParser::AssemblyDialect, 0); +} + +std::vector SolidityParser::AssemblyStatementContext::yulStatement() { + return getRuleContexts(); +} + +SolidityParser::YulStatementContext* SolidityParser::AssemblyStatementContext::yulStatement(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::AssemblyStatementContext::getRuleIndex() const { + return SolidityParser::RuleAssemblyStatement; +} + + +antlrcpp::Any SolidityParser::AssemblyStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitAssemblyStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::AssemblyStatementContext* SolidityParser::assemblyStatement() { + AssemblyStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 122, SolidityParser::RuleAssemblyStatement); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(923); + match(SolidityParser::Assembly); + setState(925); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::AssemblyDialect) { + setState(924); + match(SolidityParser::AssemblyDialect); + } + setState(927); + match(SolidityParser::AssemblyLBrace); + setState(931); + _errHandler->sync(this); + _la = _input->LA(1); + while (((((_la - 129) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 129)) & ((1ULL << (SolidityParser::YulBreak - 129)) + | (1ULL << (SolidityParser::YulContinue - 129)) + | (1ULL << (SolidityParser::YulFor - 129)) + | (1ULL << (SolidityParser::YulFunction - 129)) + | (1ULL << (SolidityParser::YulIf - 129)) + | (1ULL << (SolidityParser::YulLeave - 129)) + | (1ULL << (SolidityParser::YulLet - 129)) + | (1ULL << (SolidityParser::YulSwitch - 129)) + | (1ULL << (SolidityParser::YulEVMBuiltin - 129)) + | (1ULL << (SolidityParser::YulLBrace - 129)) + | (1ULL << (SolidityParser::YulIdentifier - 129)))) != 0)) { + setState(928); + yulStatement(); + setState(933); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(934); + match(SolidityParser::YulRBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VariableDeclarationListContext ------------------------------------------------------------------ + +SolidityParser::VariableDeclarationListContext::VariableDeclarationListContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::VariableDeclarationListContext::variableDeclaration() { + return getRuleContexts(); +} + +SolidityParser::VariableDeclarationContext* SolidityParser::VariableDeclarationListContext::variableDeclaration(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::VariableDeclarationListContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::VariableDeclarationListContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::VariableDeclarationListContext::getRuleIndex() const { + return SolidityParser::RuleVariableDeclarationList; +} + + +antlrcpp::Any SolidityParser::VariableDeclarationListContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVariableDeclarationList(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::VariableDeclarationListContext* SolidityParser::variableDeclarationList() { + VariableDeclarationListContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 124, SolidityParser::RuleVariableDeclarationList); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(936); + dynamic_cast(_localctx)->variableDeclarationContext = variableDeclaration(); + dynamic_cast(_localctx)->variableDeclarations.push_back(dynamic_cast(_localctx)->variableDeclarationContext); + setState(941); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(937); + match(SolidityParser::Comma); + setState(938); + dynamic_cast(_localctx)->variableDeclarationContext = variableDeclaration(); + dynamic_cast(_localctx)->variableDeclarations.push_back(dynamic_cast(_localctx)->variableDeclarationContext); + setState(943); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VariableDeclarationTupleContext ------------------------------------------------------------------ + +SolidityParser::VariableDeclarationTupleContext::VariableDeclarationTupleContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::VariableDeclarationTupleContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::VariableDeclarationTupleContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +std::vector SolidityParser::VariableDeclarationTupleContext::variableDeclaration() { + return getRuleContexts(); +} + +SolidityParser::VariableDeclarationContext* SolidityParser::VariableDeclarationTupleContext::variableDeclaration(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::VariableDeclarationTupleContext::Comma() { + return getTokens(SolidityParser::Comma); +} + +tree::TerminalNode* SolidityParser::VariableDeclarationTupleContext::Comma(size_t i) { + return getToken(SolidityParser::Comma, i); +} + + +size_t SolidityParser::VariableDeclarationTupleContext::getRuleIndex() const { + return SolidityParser::RuleVariableDeclarationTuple; +} + + +antlrcpp::Any SolidityParser::VariableDeclarationTupleContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVariableDeclarationTuple(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::VariableDeclarationTupleContext* SolidityParser::variableDeclarationTuple() { + VariableDeclarationTupleContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 126, SolidityParser::RuleVariableDeclarationTuple); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(944); + match(SolidityParser::LParen); + + setState(948); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 99, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(945); + match(SolidityParser::Comma); + } + setState(950); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 99, _ctx); + } + setState(951); + dynamic_cast(_localctx)->variableDeclarationContext = variableDeclaration(); + dynamic_cast(_localctx)->variableDeclarations.push_back(dynamic_cast(_localctx)->variableDeclarationContext); + setState(959); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::Comma) { + setState(953); + match(SolidityParser::Comma); + setState(955); + _errHandler->sync(this); + + switch (getInterpreter()->adaptivePredict(_input, 100, _ctx)) { + case 1: { + setState(954); + dynamic_cast(_localctx)->variableDeclarationContext = variableDeclaration(); + dynamic_cast(_localctx)->variableDeclarations.push_back(dynamic_cast(_localctx)->variableDeclarationContext); + break; + } + + } + setState(961); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(962); + match(SolidityParser::RParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- VariableDeclarationStatementContext ------------------------------------------------------------------ + +SolidityParser::VariableDeclarationStatementContext::VariableDeclarationStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::VariableDeclarationStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + +SolidityParser::VariableDeclarationContext* SolidityParser::VariableDeclarationStatementContext::variableDeclaration() { + return getRuleContext(0); +} + +SolidityParser::VariableDeclarationTupleContext* SolidityParser::VariableDeclarationStatementContext::variableDeclarationTuple() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::VariableDeclarationStatementContext::Assign() { + return getToken(SolidityParser::Assign, 0); +} + +SolidityParser::ExpressionContext* SolidityParser::VariableDeclarationStatementContext::expression() { + return getRuleContext(0); +} + + +size_t SolidityParser::VariableDeclarationStatementContext::getRuleIndex() const { + return SolidityParser::RuleVariableDeclarationStatement; +} + + +antlrcpp::Any SolidityParser::VariableDeclarationStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitVariableDeclarationStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::VariableDeclarationStatementContext* SolidityParser::variableDeclarationStatement() { + VariableDeclarationStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 128, SolidityParser::RuleVariableDeclarationStatement); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(973); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 103, _ctx)) { + case 1: { + setState(964); + variableDeclaration(); + setState(967); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::Assign) { + setState(965); + match(SolidityParser::Assign); + setState(966); + expression(0); + } + break; + } + + case 2: { + setState(969); + variableDeclarationTuple(); + setState(970); + match(SolidityParser::Assign); + setState(971); + expression(0); + break; + } + + } + setState(975); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ExpressionStatementContext ------------------------------------------------------------------ + +SolidityParser::ExpressionStatementContext::ExpressionStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::ExpressionContext* SolidityParser::ExpressionStatementContext::expression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::ExpressionStatementContext::Semicolon() { + return getToken(SolidityParser::Semicolon, 0); +} + + +size_t SolidityParser::ExpressionStatementContext::getRuleIndex() const { + return SolidityParser::RuleExpressionStatement; +} + + +antlrcpp::Any SolidityParser::ExpressionStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitExpressionStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::ExpressionStatementContext* SolidityParser::expressionStatement() { + ExpressionStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 130, SolidityParser::RuleExpressionStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(977); + expression(0); + setState(978); + match(SolidityParser::Semicolon); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MappingTypeContext ------------------------------------------------------------------ + +SolidityParser::MappingTypeContext::MappingTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::MappingTypeContext::Mapping() { + return getToken(SolidityParser::Mapping, 0); +} + +tree::TerminalNode* SolidityParser::MappingTypeContext::LParen() { + return getToken(SolidityParser::LParen, 0); +} + +tree::TerminalNode* SolidityParser::MappingTypeContext::Arrow() { + return getToken(SolidityParser::Arrow, 0); +} + +tree::TerminalNode* SolidityParser::MappingTypeContext::RParen() { + return getToken(SolidityParser::RParen, 0); +} + +SolidityParser::MappingKeyTypeContext* SolidityParser::MappingTypeContext::mappingKeyType() { + return getRuleContext(0); +} + +SolidityParser::TypeNameContext* SolidityParser::MappingTypeContext::typeName() { + return getRuleContext(0); +} + + +size_t SolidityParser::MappingTypeContext::getRuleIndex() const { + return SolidityParser::RuleMappingType; +} + + +antlrcpp::Any SolidityParser::MappingTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMappingType(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::MappingTypeContext* SolidityParser::mappingType() { + MappingTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 132, SolidityParser::RuleMappingType); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(980); + match(SolidityParser::Mapping); + setState(981); + match(SolidityParser::LParen); + setState(982); + dynamic_cast(_localctx)->key = mappingKeyType(); + setState(983); + match(SolidityParser::Arrow); + setState(984); + dynamic_cast(_localctx)->value = typeName(0); + setState(985); + match(SolidityParser::RParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- MappingKeyTypeContext ------------------------------------------------------------------ + +SolidityParser::MappingKeyTypeContext::MappingKeyTypeContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::ElementaryTypeNameContext* SolidityParser::MappingKeyTypeContext::elementaryTypeName() { + return getRuleContext(0); +} + +SolidityParser::UserDefinedTypeNameContext* SolidityParser::MappingKeyTypeContext::userDefinedTypeName() { + return getRuleContext(0); +} + + +size_t SolidityParser::MappingKeyTypeContext::getRuleIndex() const { + return SolidityParser::RuleMappingKeyType; +} + + +antlrcpp::Any SolidityParser::MappingKeyTypeContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitMappingKeyType(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::MappingKeyTypeContext* SolidityParser::mappingKeyType() { + MappingKeyTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 134, SolidityParser::RuleMappingKeyType); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(989); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 104, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(987); + elementaryTypeName(false); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(988); + userDefinedTypeName(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulStatementContext ------------------------------------------------------------------ + +SolidityParser::YulStatementContext::YulStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::YulBlockContext* SolidityParser::YulStatementContext::yulBlock() { + return getRuleContext(0); +} + +SolidityParser::YulVariableDeclarationContext* SolidityParser::YulStatementContext::yulVariableDeclaration() { + return getRuleContext(0); +} + +SolidityParser::YulAssignmentContext* SolidityParser::YulStatementContext::yulAssignment() { + return getRuleContext(0); +} + +SolidityParser::YulFunctionCallContext* SolidityParser::YulStatementContext::yulFunctionCall() { + return getRuleContext(0); +} + +SolidityParser::YulIfStatementContext* SolidityParser::YulStatementContext::yulIfStatement() { + return getRuleContext(0); +} + +SolidityParser::YulForStatementContext* SolidityParser::YulStatementContext::yulForStatement() { + return getRuleContext(0); +} + +SolidityParser::YulSwitchStatementContext* SolidityParser::YulStatementContext::yulSwitchStatement() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::YulStatementContext::YulLeave() { + return getToken(SolidityParser::YulLeave, 0); +} + +tree::TerminalNode* SolidityParser::YulStatementContext::YulBreak() { + return getToken(SolidityParser::YulBreak, 0); +} + +tree::TerminalNode* SolidityParser::YulStatementContext::YulContinue() { + return getToken(SolidityParser::YulContinue, 0); +} + +SolidityParser::YulFunctionDefinitionContext* SolidityParser::YulStatementContext::yulFunctionDefinition() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulStatementContext::getRuleIndex() const { + return SolidityParser::RuleYulStatement; +} + + +antlrcpp::Any SolidityParser::YulStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulStatementContext* SolidityParser::yulStatement() { + YulStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 136, SolidityParser::RuleYulStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(1002); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 105, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(991); + yulBlock(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(992); + yulVariableDeclaration(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(993); + yulAssignment(); + break; + } + + case 4: { + enterOuterAlt(_localctx, 4); + setState(994); + yulFunctionCall(); + break; + } + + case 5: { + enterOuterAlt(_localctx, 5); + setState(995); + yulIfStatement(); + break; + } + + case 6: { + enterOuterAlt(_localctx, 6); + setState(996); + yulForStatement(); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(997); + yulSwitchStatement(); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(998); + match(SolidityParser::YulLeave); + break; + } + + case 9: { + enterOuterAlt(_localctx, 9); + setState(999); + match(SolidityParser::YulBreak); + break; + } + + case 10: { + enterOuterAlt(_localctx, 10); + setState(1000); + match(SolidityParser::YulContinue); + break; + } + + case 11: { + enterOuterAlt(_localctx, 11); + setState(1001); + yulFunctionDefinition(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulBlockContext ------------------------------------------------------------------ + +SolidityParser::YulBlockContext::YulBlockContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulBlockContext::YulLBrace() { + return getToken(SolidityParser::YulLBrace, 0); +} + +tree::TerminalNode* SolidityParser::YulBlockContext::YulRBrace() { + return getToken(SolidityParser::YulRBrace, 0); +} + +std::vector SolidityParser::YulBlockContext::yulStatement() { + return getRuleContexts(); +} + +SolidityParser::YulStatementContext* SolidityParser::YulBlockContext::yulStatement(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::YulBlockContext::getRuleIndex() const { + return SolidityParser::RuleYulBlock; +} + + +antlrcpp::Any SolidityParser::YulBlockContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulBlock(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulBlockContext* SolidityParser::yulBlock() { + YulBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 138, SolidityParser::RuleYulBlock); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1004); + match(SolidityParser::YulLBrace); + setState(1008); + _errHandler->sync(this); + _la = _input->LA(1); + while (((((_la - 129) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 129)) & ((1ULL << (SolidityParser::YulBreak - 129)) + | (1ULL << (SolidityParser::YulContinue - 129)) + | (1ULL << (SolidityParser::YulFor - 129)) + | (1ULL << (SolidityParser::YulFunction - 129)) + | (1ULL << (SolidityParser::YulIf - 129)) + | (1ULL << (SolidityParser::YulLeave - 129)) + | (1ULL << (SolidityParser::YulLet - 129)) + | (1ULL << (SolidityParser::YulSwitch - 129)) + | (1ULL << (SolidityParser::YulEVMBuiltin - 129)) + | (1ULL << (SolidityParser::YulLBrace - 129)) + | (1ULL << (SolidityParser::YulIdentifier - 129)))) != 0)) { + setState(1005); + yulStatement(); + setState(1010); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(1011); + match(SolidityParser::YulRBrace); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulVariableDeclarationContext ------------------------------------------------------------------ + +SolidityParser::YulVariableDeclarationContext::YulVariableDeclarationContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulLet() { + return getToken(SolidityParser::YulLet, 0); +} + +std::vector SolidityParser::YulVariableDeclarationContext::YulIdentifier() { + return getTokens(SolidityParser::YulIdentifier); +} + +tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulIdentifier(size_t i) { + return getToken(SolidityParser::YulIdentifier, i); +} + +tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulAssign() { + return getToken(SolidityParser::YulAssign, 0); +} + +SolidityParser::YulExpressionContext* SolidityParser::YulVariableDeclarationContext::yulExpression() { + return getRuleContext(0); +} + +std::vector SolidityParser::YulVariableDeclarationContext::YulComma() { + return getTokens(SolidityParser::YulComma); +} + +tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulComma(size_t i) { + return getToken(SolidityParser::YulComma, i); +} + +SolidityParser::YulFunctionCallContext* SolidityParser::YulVariableDeclarationContext::yulFunctionCall() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulVariableDeclarationContext::getRuleIndex() const { + return SolidityParser::RuleYulVariableDeclaration; +} + + +antlrcpp::Any SolidityParser::YulVariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulVariableDeclaration(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulVariableDeclarationContext* SolidityParser::yulVariableDeclaration() { + YulVariableDeclarationContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 140, SolidityParser::RuleYulVariableDeclaration); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(1032); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 110, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1013); + match(SolidityParser::YulLet); + setState(1014); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->variables.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1017); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::YulAssign) { + setState(1015); + match(SolidityParser::YulAssign); + setState(1016); + yulExpression(); + } + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1019); + match(SolidityParser::YulLet); + setState(1020); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->variables.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1025); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::YulComma) { + setState(1021); + match(SolidityParser::YulComma); + setState(1022); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->variables.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1027); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(1030); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::YulAssign) { + setState(1028); + match(SolidityParser::YulAssign); + setState(1029); + yulFunctionCall(); + } + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulAssignmentContext ------------------------------------------------------------------ + +SolidityParser::YulAssignmentContext::YulAssignmentContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::YulAssignmentContext::yulPath() { + return getRuleContexts(); +} + +SolidityParser::YulPathContext* SolidityParser::YulAssignmentContext::yulPath(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* SolidityParser::YulAssignmentContext::YulAssign() { + return getToken(SolidityParser::YulAssign, 0); +} + +SolidityParser::YulExpressionContext* SolidityParser::YulAssignmentContext::yulExpression() { + return getRuleContext(0); +} + +SolidityParser::YulFunctionCallContext* SolidityParser::YulAssignmentContext::yulFunctionCall() { + return getRuleContext(0); +} + +std::vector SolidityParser::YulAssignmentContext::YulComma() { + return getTokens(SolidityParser::YulComma); +} + +tree::TerminalNode* SolidityParser::YulAssignmentContext::YulComma(size_t i) { + return getToken(SolidityParser::YulComma, i); +} + + +size_t SolidityParser::YulAssignmentContext::getRuleIndex() const { + return SolidityParser::RuleYulAssignment; +} + + +antlrcpp::Any SolidityParser::YulAssignmentContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulAssignment(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulAssignmentContext* SolidityParser::yulAssignment() { + YulAssignmentContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 142, SolidityParser::RuleYulAssignment); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(1048); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 112, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1034); + yulPath(); + setState(1035); + match(SolidityParser::YulAssign); + setState(1036); + yulExpression(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1038); + yulPath(); + setState(1041); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1039); + match(SolidityParser::YulComma); + setState(1040); + yulPath(); + setState(1043); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == SolidityParser::YulComma); + setState(1045); + match(SolidityParser::YulAssign); + setState(1046); + yulFunctionCall(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulIfStatementContext ------------------------------------------------------------------ + +SolidityParser::YulIfStatementContext::YulIfStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulIfStatementContext::YulIf() { + return getToken(SolidityParser::YulIf, 0); +} + +SolidityParser::YulExpressionContext* SolidityParser::YulIfStatementContext::yulExpression() { + return getRuleContext(0); +} + +SolidityParser::YulBlockContext* SolidityParser::YulIfStatementContext::yulBlock() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulIfStatementContext::getRuleIndex() const { + return SolidityParser::RuleYulIfStatement; +} + + +antlrcpp::Any SolidityParser::YulIfStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulIfStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulIfStatementContext* SolidityParser::yulIfStatement() { + YulIfStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 144, SolidityParser::RuleYulIfStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1050); + match(SolidityParser::YulIf); + setState(1051); + dynamic_cast(_localctx)->cond = yulExpression(); + setState(1052); + dynamic_cast(_localctx)->body = yulBlock(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulForStatementContext ------------------------------------------------------------------ + +SolidityParser::YulForStatementContext::YulForStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulForStatementContext::YulFor() { + return getToken(SolidityParser::YulFor, 0); +} + +std::vector SolidityParser::YulForStatementContext::yulBlock() { + return getRuleContexts(); +} + +SolidityParser::YulBlockContext* SolidityParser::YulForStatementContext::yulBlock(size_t i) { + return getRuleContext(i); +} + +SolidityParser::YulExpressionContext* SolidityParser::YulForStatementContext::yulExpression() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulForStatementContext::getRuleIndex() const { + return SolidityParser::RuleYulForStatement; +} + + +antlrcpp::Any SolidityParser::YulForStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulForStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulForStatementContext* SolidityParser::yulForStatement() { + YulForStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 146, SolidityParser::RuleYulForStatement); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1054); + match(SolidityParser::YulFor); + setState(1055); + dynamic_cast(_localctx)->init = yulBlock(); + setState(1056); + dynamic_cast(_localctx)->cond = yulExpression(); + setState(1057); + dynamic_cast(_localctx)->post = yulBlock(); + setState(1058); + dynamic_cast(_localctx)->body = yulBlock(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulSwitchCaseContext ------------------------------------------------------------------ + +SolidityParser::YulSwitchCaseContext::YulSwitchCaseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulSwitchCaseContext::YulCase() { + return getToken(SolidityParser::YulCase, 0); +} + +SolidityParser::YulLiteralContext* SolidityParser::YulSwitchCaseContext::yulLiteral() { + return getRuleContext(0); +} + +SolidityParser::YulBlockContext* SolidityParser::YulSwitchCaseContext::yulBlock() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulSwitchCaseContext::getRuleIndex() const { + return SolidityParser::RuleYulSwitchCase; +} + + +antlrcpp::Any SolidityParser::YulSwitchCaseContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulSwitchCase(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulSwitchCaseContext* SolidityParser::yulSwitchCase() { + YulSwitchCaseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 148, SolidityParser::RuleYulSwitchCase); + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1060); + match(SolidityParser::YulCase); + setState(1061); + yulLiteral(); + setState(1062); + yulBlock(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulSwitchStatementContext ------------------------------------------------------------------ + +SolidityParser::YulSwitchStatementContext::YulSwitchStatementContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulSwitchStatementContext::YulSwitch() { + return getToken(SolidityParser::YulSwitch, 0); +} + +SolidityParser::YulExpressionContext* SolidityParser::YulSwitchStatementContext::yulExpression() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::YulSwitchStatementContext::YulDefault() { + return getToken(SolidityParser::YulDefault, 0); +} + +SolidityParser::YulBlockContext* SolidityParser::YulSwitchStatementContext::yulBlock() { + return getRuleContext(0); +} + +std::vector SolidityParser::YulSwitchStatementContext::yulSwitchCase() { + return getRuleContexts(); +} + +SolidityParser::YulSwitchCaseContext* SolidityParser::YulSwitchStatementContext::yulSwitchCase(size_t i) { + return getRuleContext(i); +} + + +size_t SolidityParser::YulSwitchStatementContext::getRuleIndex() const { + return SolidityParser::RuleYulSwitchStatement; +} + + +antlrcpp::Any SolidityParser::YulSwitchStatementContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulSwitchStatement(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulSwitchStatementContext* SolidityParser::yulSwitchStatement() { + YulSwitchStatementContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 150, SolidityParser::RuleYulSwitchStatement); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1064); + match(SolidityParser::YulSwitch); + setState(1065); + yulExpression(); + setState(1077); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::YulCase: { + setState(1067); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(1066); + yulSwitchCase(); + setState(1069); + _errHandler->sync(this); + _la = _input->LA(1); + } while (_la == SolidityParser::YulCase); + setState(1073); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::YulDefault) { + setState(1071); + match(SolidityParser::YulDefault); + setState(1072); + yulBlock(); + } + break; + } + + case SolidityParser::YulDefault: { + setState(1075); + match(SolidityParser::YulDefault); + setState(1076); + yulBlock(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulFunctionDefinitionContext ------------------------------------------------------------------ + +SolidityParser::YulFunctionDefinitionContext::YulFunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulFunction() { + return getToken(SolidityParser::YulFunction, 0); +} + +std::vector SolidityParser::YulFunctionDefinitionContext::YulIdentifier() { + return getTokens(SolidityParser::YulIdentifier); +} + +tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulIdentifier(size_t i) { + return getToken(SolidityParser::YulIdentifier, i); +} + +tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulLParen() { + return getToken(SolidityParser::YulLParen, 0); +} + +tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulRParen() { + return getToken(SolidityParser::YulRParen, 0); +} + +SolidityParser::YulBlockContext* SolidityParser::YulFunctionDefinitionContext::yulBlock() { + return getRuleContext(0); +} + +tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulArrow() { + return getToken(SolidityParser::YulArrow, 0); +} + +std::vector SolidityParser::YulFunctionDefinitionContext::YulComma() { + return getTokens(SolidityParser::YulComma); +} + +tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulComma(size_t i) { + return getToken(SolidityParser::YulComma, i); +} + + +size_t SolidityParser::YulFunctionDefinitionContext::getRuleIndex() const { + return SolidityParser::RuleYulFunctionDefinition; +} + + +antlrcpp::Any SolidityParser::YulFunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulFunctionDefinition(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulFunctionDefinitionContext* SolidityParser::yulFunctionDefinition() { + YulFunctionDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 152, SolidityParser::RuleYulFunctionDefinition); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1079); + match(SolidityParser::YulFunction); + setState(1080); + match(SolidityParser::YulIdentifier); + setState(1081); + match(SolidityParser::YulLParen); + setState(1090); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::YulIdentifier) { + setState(1082); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->arguments.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1087); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::YulComma) { + setState(1083); + match(SolidityParser::YulComma); + setState(1084); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->arguments.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1089); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(1092); + match(SolidityParser::YulRParen); + setState(1102); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == SolidityParser::YulArrow) { + setState(1093); + match(SolidityParser::YulArrow); + setState(1094); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->returnParameters.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1099); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::YulComma) { + setState(1095); + match(SolidityParser::YulComma); + setState(1096); + dynamic_cast(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier); + dynamic_cast(_localctx)->returnParameters.push_back(dynamic_cast(_localctx)->yulidentifierToken); + setState(1101); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(1104); + dynamic_cast(_localctx)->body = yulBlock(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulPathContext ------------------------------------------------------------------ + +SolidityParser::YulPathContext::YulPathContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector SolidityParser::YulPathContext::YulIdentifier() { + return getTokens(SolidityParser::YulIdentifier); +} + +tree::TerminalNode* SolidityParser::YulPathContext::YulIdentifier(size_t i) { + return getToken(SolidityParser::YulIdentifier, i); +} + +std::vector SolidityParser::YulPathContext::YulPeriod() { + return getTokens(SolidityParser::YulPeriod); +} + +tree::TerminalNode* SolidityParser::YulPathContext::YulPeriod(size_t i) { + return getToken(SolidityParser::YulPeriod, i); +} + + +size_t SolidityParser::YulPathContext::getRuleIndex() const { + return SolidityParser::RuleYulPath; +} + + +antlrcpp::Any SolidityParser::YulPathContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulPath(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulPathContext* SolidityParser::yulPath() { + YulPathContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 154, SolidityParser::RuleYulPath); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1106); + match(SolidityParser::YulIdentifier); + setState(1111); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::YulPeriod) { + setState(1107); + match(SolidityParser::YulPeriod); + setState(1108); + match(SolidityParser::YulIdentifier); + setState(1113); + _errHandler->sync(this); + _la = _input->LA(1); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulFunctionCallContext ------------------------------------------------------------------ + +SolidityParser::YulFunctionCallContext::YulFunctionCallContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulLParen() { + return getToken(SolidityParser::YulLParen, 0); +} + +tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulRParen() { + return getToken(SolidityParser::YulRParen, 0); +} + +tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulIdentifier() { + return getToken(SolidityParser::YulIdentifier, 0); +} + +tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulEVMBuiltin() { + return getToken(SolidityParser::YulEVMBuiltin, 0); +} + +std::vector SolidityParser::YulFunctionCallContext::yulExpression() { + return getRuleContexts(); +} + +SolidityParser::YulExpressionContext* SolidityParser::YulFunctionCallContext::yulExpression(size_t i) { + return getRuleContext(i); +} + +std::vector SolidityParser::YulFunctionCallContext::YulComma() { + return getTokens(SolidityParser::YulComma); +} + +tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulComma(size_t i) { + return getToken(SolidityParser::YulComma, i); +} + + +size_t SolidityParser::YulFunctionCallContext::getRuleIndex() const { + return SolidityParser::RuleYulFunctionCall; +} + + +antlrcpp::Any SolidityParser::YulFunctionCallContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulFunctionCall(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulFunctionCallContext* SolidityParser::yulFunctionCall() { + YulFunctionCallContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 156, SolidityParser::RuleYulFunctionCall); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1114); + _la = _input->LA(1); + if (!(_la == SolidityParser::YulEVMBuiltin + + || _la == SolidityParser::YulIdentifier)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(1115); + match(SolidityParser::YulLParen); + setState(1124); + _errHandler->sync(this); + + _la = _input->LA(1); + if (((((_la - 133) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 133)) & ((1ULL << (SolidityParser::YulFalse - 133)) + | (1ULL << (SolidityParser::YulTrue - 133)) + | (1ULL << (SolidityParser::YulEVMBuiltin - 133)) + | (1ULL << (SolidityParser::YulIdentifier - 133)) + | (1ULL << (SolidityParser::YulHexNumber - 133)) + | (1ULL << (SolidityParser::YulDecimalNumber - 133)) + | (1ULL << (SolidityParser::YulStringLiteral - 133)))) != 0)) { + setState(1116); + yulExpression(); + setState(1121); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == SolidityParser::YulComma) { + setState(1117); + match(SolidityParser::YulComma); + setState(1118); + yulExpression(); + setState(1123); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(1126); + match(SolidityParser::YulRParen); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulboolContext ------------------------------------------------------------------ + +SolidityParser::YulboolContext::YulboolContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulboolContext::YulTrue() { + return getToken(SolidityParser::YulTrue, 0); +} + +tree::TerminalNode* SolidityParser::YulboolContext::YulFalse() { + return getToken(SolidityParser::YulFalse, 0); +} + + +size_t SolidityParser::YulboolContext::getRuleIndex() const { + return SolidityParser::RuleYulbool; +} + + +antlrcpp::Any SolidityParser::YulboolContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulBoolean(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulboolContext* SolidityParser::yulbool() { + YulboolContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 158, SolidityParser::RuleYulbool); + size_t _la = 0; + + auto onExit = finally([=] { + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(1128); + _la = _input->LA(1); + if (!(_la == SolidityParser::YulFalse + + || _la == SolidityParser::YulTrue)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulLiteralContext ------------------------------------------------------------------ + +SolidityParser::YulLiteralContext::YulLiteralContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* SolidityParser::YulLiteralContext::YulDecimalNumber() { + return getToken(SolidityParser::YulDecimalNumber, 0); +} + +tree::TerminalNode* SolidityParser::YulLiteralContext::YulStringLiteral() { + return getToken(SolidityParser::YulStringLiteral, 0); +} + +tree::TerminalNode* SolidityParser::YulLiteralContext::YulHexNumber() { + return getToken(SolidityParser::YulHexNumber, 0); +} + +SolidityParser::YulboolContext* SolidityParser::YulLiteralContext::yulbool() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulLiteralContext::getRuleIndex() const { + return SolidityParser::RuleYulLiteral; +} + + +antlrcpp::Any SolidityParser::YulLiteralContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulLiteral(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulLiteralContext* SolidityParser::yulLiteral() { + YulLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 160, SolidityParser::RuleYulLiteral); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(1134); + _errHandler->sync(this); + switch (_input->LA(1)) { + case SolidityParser::YulDecimalNumber: { + enterOuterAlt(_localctx, 1); + setState(1130); + match(SolidityParser::YulDecimalNumber); + break; + } + + case SolidityParser::YulStringLiteral: { + enterOuterAlt(_localctx, 2); + setState(1131); + match(SolidityParser::YulStringLiteral); + break; + } + + case SolidityParser::YulHexNumber: { + enterOuterAlt(_localctx, 3); + setState(1132); + match(SolidityParser::YulHexNumber); + break; + } + + case SolidityParser::YulFalse: + case SolidityParser::YulTrue: { + enterOuterAlt(_localctx, 4); + setState(1133); + yulbool(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- YulExpressionContext ------------------------------------------------------------------ + +SolidityParser::YulExpressionContext::YulExpressionContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +SolidityParser::YulPathContext* SolidityParser::YulExpressionContext::yulPath() { + return getRuleContext(0); +} + +SolidityParser::YulFunctionCallContext* SolidityParser::YulExpressionContext::yulFunctionCall() { + return getRuleContext(0); +} + +SolidityParser::YulLiteralContext* SolidityParser::YulExpressionContext::yulLiteral() { + return getRuleContext(0); +} + + +size_t SolidityParser::YulExpressionContext::getRuleIndex() const { + return SolidityParser::RuleYulExpression; +} + + +antlrcpp::Any SolidityParser::YulExpressionContext::accept(tree::ParseTreeVisitor *visitor) { + if (auto parserVisitor = dynamic_cast(visitor)) + return parserVisitor->visitYulExpression(this); + else + return visitor->visitChildren(this); +} + +SolidityParser::YulExpressionContext* SolidityParser::yulExpression() { + YulExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 162, SolidityParser::RuleYulExpression); + + auto onExit = finally([=] { + exitRule(); + }); + try { + setState(1139); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 124, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(1136); + yulPath(); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(1137); + yulFunctionCall(); + break; + } + + case 3: { + enterOuterAlt(_localctx, 3); + setState(1138); + yulLiteral(); + break; + } + + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +bool SolidityParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { + switch (ruleIndex) { + case 19: return constructorDefinitionSempred(dynamic_cast(context), predicateIndex); + case 22: return functionDefinitionSempred(dynamic_cast(context), predicateIndex); + case 23: return modifierDefinitionSempred(dynamic_cast(context), predicateIndex); + case 24: return fallbackReceiveFunctionDefinitionSempred(dynamic_cast(context), predicateIndex); + case 28: return stateVariableDeclarationSempred(dynamic_cast(context), predicateIndex); + case 32: return typeNameSempred(dynamic_cast(context), predicateIndex); + case 33: return elementaryTypeNameSempred(dynamic_cast(context), predicateIndex); + case 34: return functionTypeNameSempred(dynamic_cast(context), predicateIndex); + case 37: return expressionSempred(dynamic_cast(context), predicateIndex); + + default: + break; + } + return true; +} + +bool SolidityParser::constructorDefinitionSempred(ConstructorDefinitionContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 0: return !_localctx->payableSet; + case 1: return !_localctx->visibilitySet; + case 2: return !_localctx->visibilitySet; + + default: + break; + } + return true; +} + +bool SolidityParser::functionDefinitionSempred(FunctionDefinitionContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 3: return !_localctx->visibilitySet; + case 4: return !_localctx->mutabilitySet; + case 5: return !_localctx->virtualSet; + case 6: return !_localctx->overrideSpecifierSet; + + default: + break; + } + return true; +} + +bool SolidityParser::modifierDefinitionSempred(ModifierDefinitionContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 7: return !_localctx->virtualSet; + case 8: return !_localctx->overrideSpecifierSet; + + default: + break; + } + return true; +} + +bool SolidityParser::fallbackReceiveFunctionDefinitionSempred(FallbackReceiveFunctionDefinitionContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 9: return !_localctx->visibilitySet; + case 10: return !_localctx->mutabilitySet; + case 11: return !_localctx->virtualSet; + case 12: return !_localctx->overrideSpecifierSet; + + default: + break; + } + return true; +} + +bool SolidityParser::stateVariableDeclarationSempred(StateVariableDeclarationContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 13: return !_localctx->visibilitySet; + case 14: return !_localctx->visibilitySet; + case 15: return !_localctx->visibilitySet; + case 16: return !_localctx->constantnessSet; + case 17: return !_localctx->overrideSpecifierSet; + case 18: return !_localctx->constantnessSet; + + default: + break; + } + return true; +} + +bool SolidityParser::typeNameSempred(TypeNameContext *, size_t predicateIndex) { + switch (predicateIndex) { + case 19: return precpred(_ctx, 1); + + default: + break; + } + return true; +} + +bool SolidityParser::elementaryTypeNameSempred(ElementaryTypeNameContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 20: return _localctx->allowAddressPayable; + + default: + break; + } + return true; +} + +bool SolidityParser::functionTypeNameSempred(FunctionTypeNameContext *_localctx, size_t predicateIndex) { + switch (predicateIndex) { + case 21: return !_localctx->visibilitySet; + case 22: return !_localctx->mutabilitySet; + + default: + break; + } + return true; +} + +bool SolidityParser::expressionSempred(ExpressionContext *, size_t predicateIndex) { + switch (predicateIndex) { + case 23: return precpred(_ctx, 17); + case 24: return precpred(_ctx, 16); + case 25: return precpred(_ctx, 15); + case 26: return precpred(_ctx, 14); + case 27: return precpred(_ctx, 13); + case 28: return precpred(_ctx, 12); + case 29: return precpred(_ctx, 11); + case 30: return precpred(_ctx, 10); + case 31: return precpred(_ctx, 9); + case 32: return precpred(_ctx, 8); + case 33: return precpred(_ctx, 7); + case 34: return precpred(_ctx, 6); + case 35: return precpred(_ctx, 5); + case 36: return precpred(_ctx, 26); + case 37: return precpred(_ctx, 25); + case 38: return precpred(_ctx, 24); + case 39: return precpred(_ctx, 23); + case 40: return precpred(_ctx, 22); + case 41: return precpred(_ctx, 18); + + default: + break; + } + return true; +} + +// Static vars and initialization. +std::vector SolidityParser::_decisionToDFA; +atn::PredictionContextCache SolidityParser::_sharedContextCache; + +// We own the ATN which in turn owns the ATN states. +atn::ATN SolidityParser::_atn; +std::vector SolidityParser::_serializedATN; + +std::vector SolidityParser::_ruleNames = { + "sourceUnit", "pragmaDirective", "importDirective", "importAliases", "path", + "symbolAliases", "contractDefinition", "interfaceDefinition", "libraryDefinition", + "inheritanceSpecifierList", "inheritanceSpecifier", "contractBodyElement", + "namedArgument", "callArgumentList", "userDefinedTypeName", "modifierInvocation", + "visibility", "parameterList", "parameterDeclaration", "constructorDefinition", + "stateMutability", "overrideSpecifier", "functionDefinition", "modifierDefinition", + "fallbackReceiveFunctionDefinition", "structDefinition", "structMember", + "enumDefinition", "stateVariableDeclaration", "eventParameter", "eventDefinition", + "usingDirective", "typeName", "elementaryTypeName", "functionTypeName", + "variableDeclaration", "dataLocation", "expression", "assignOp", "tupleExpression", + "inlineArrayExpression", "identifier", "literal", "boolLiteral", "stringLiteral", + "hexStringLiteral", "unicodeStringLiteral", "numberLiteral", "block", + "statement", "simpleStatement", "ifStatement", "forStatement", "whileStatement", + "doWhileStatement", "continueStatement", "breakStatement", "tryStatement", + "catchClause", "returnStatement", "emitStatement", "assemblyStatement", + "variableDeclarationList", "variableDeclarationTuple", "variableDeclarationStatement", + "expressionStatement", "mappingType", "mappingKeyType", "yulStatement", + "yulBlock", "yulVariableDeclaration", "yulAssignment", "yulIfStatement", + "yulForStatement", "yulSwitchCase", "yulSwitchStatement", "yulFunctionDefinition", + "yulPath", "yulFunctionCall", "yulbool", "yulLiteral", "yulExpression" +}; + +std::vector SolidityParser::_literalNames = { + "", "", "'pragma'", "'abstract'", "'anonymous'", "'address'", "'as'", + "'assembly'", "'bool'", "", "'bytes'", "'calldata'", "'catch'", "'constant'", + "'constructor'", "", "'contract'", "'delete'", "'do'", "'else'", "'emit'", + "'enum'", "'event'", "'external'", "'fallback'", "", "", "'from'", "", + "", "", "'hex'", "", "'immutable'", "'import'", "'indexed'", "'interface'", + "'internal'", "'is'", "'library'", "'mapping'", "'memory'", "'modifier'", + "'new'", "", "'override'", "'payable'", "'private'", "'public'", "'pure'", + "'receive'", "'return'", "'returns'", "", "'storage'", "'string'", "'struct'", + "", "'try'", "'type'", "", "", "'using'", "'view'", "'virtual'", "'while'", + "", "", "'['", "']'", "", "", "':'", "", "", "'?'", "'=>'", "'='", "'|='", + "'^='", "'&='", "'<<='", "'>>='", "'>>>='", "'+='", "'-='", "'*='", "'/='", + "'%='", "", "'||'", "'&&'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'>>>'", + "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'=='", "'!='", "'<'", "'>'", + "'<='", "'>='", "'!'", "'~'", "'++'", "'--'", "", "", "", "", "", "", + "", "", "", "", "'\"evmasm\"'", "", "", "", "", "", "'case'", "", "'default'", + "", "", "", "", "'leave'", "'let'", "'switch'", "", "", "", "", "", "", + "':='" +}; + +std::vector SolidityParser::_symbolicNames = { + "", "ReservedKeywords", "Pragma", "Abstract", "Anonymous", "Address", + "As", "Assembly", "Bool", "Break", "Bytes", "Calldata", "Catch", "Constant", + "Constructor", "Continue", "Contract", "Delete", "Do", "Else", "Emit", + "Enum", "Event", "External", "Fallback", "False", "Fixed", "From", "FixedBytes", + "For", "Function", "Hex", "If", "Immutable", "Import", "Indexed", "Interface", + "Internal", "Is", "Library", "Mapping", "Memory", "Modifier", "New", "NumberUnit", + "Override", "Payable", "Private", "Public", "Pure", "Receive", "Return", + "Returns", "SignedIntegerType", "Storage", "String", "Struct", "True", + "Try", "Type", "Ufixed", "UnsignedIntegerType", "Using", "View", "Virtual", + "While", "LParen", "RParen", "LBrack", "RBrack", "LBrace", "RBrace", "Colon", + "Semicolon", "Period", "Conditional", "Arrow", "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", + "StringLiteral", "NonEmptyStringLiteral", "UnicodeStringLiteral", "HexString", + "HexNumber", "DecimalNumber", "Identifier", "WS", "COMMENT", "LINE_COMMENT", + "AssemblyDialect", "AssemblyLBrace", "AssemblyBlockWS", "AssemblyBlockCOMMENT", + "AssemblyBlockLINE_COMMENT", "YulBreak", "YulCase", "YulContinue", "YulDefault", + "YulFalse", "YulFor", "YulFunction", "YulIf", "YulLeave", "YulLet", "YulSwitch", + "YulTrue", "YulEVMBuiltin", "YulLBrace", "YulRBrace", "YulLParen", "YulRParen", + "YulAssign", "YulPeriod", "YulComma", "YulArrow", "YulIdentifier", "YulHexNumber", + "YulDecimalNumber", "YulStringLiteral", "YulWS", "YulCOMMENT", "YulLINE_COMMENT", + "PragmaToken", "PragmaSemicolon", "PragmaWS", "PragmaCOMMENT", "PragmaLINE_COMMENT" +}; + +dfa::Vocabulary SolidityParser::_vocabulary(_literalNames, _symbolicNames); + +std::vector SolidityParser::_tokenNames; + +SolidityParser::Initializer::Initializer() { + for (size_t i = 0; i < _symbolicNames.size(); ++i) { + std::string name = _vocabulary.getLiteralName(i); + if (name.empty()) { + name = _vocabulary.getSymbolicName(i); + } + + if (name.empty()) { + _tokenNames.push_back(""); + } else { + _tokenNames.push_back(name); + } + } + + _serializedATN = { + 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, + 0x3, 0xa3, 0x478, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, + 0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, + 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, + 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, + 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, + 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15, + 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9, + 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, + 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, + 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, + 0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, + 0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, + 0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, + 0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, + 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9, + 0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35, + 0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4, + 0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c, + 0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9, + 0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42, + 0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4, + 0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49, + 0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9, + 0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f, + 0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4, + 0x53, 0x9, 0x53, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, + 0x2, 0x3, 0x2, 0x3, 0x2, 0x7, 0x2, 0xaf, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, + 0xb2, 0xb, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x6, 0x3, 0xb8, + 0xa, 0x3, 0xd, 0x3, 0xe, 0x3, 0xb9, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, + 0x4, 0x3, 0x4, 0x3, 0x4, 0x5, 0x4, 0xc2, 0xa, 0x4, 0x3, 0x4, 0x3, 0x4, + 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, + 0x3, 0x4, 0x5, 0x4, 0xce, 0xa, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, + 0x5, 0x3, 0x5, 0x5, 0x5, 0xd5, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, + 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x7, 0x7, 0xdd, 0xa, 0x7, 0xc, 0x7, 0xe, + 0x7, 0xe0, 0xb, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x5, 0x8, 0xe5, 0xa, + 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0xea, 0xa, 0x8, 0x3, 0x8, + 0x3, 0x8, 0x7, 0x8, 0xee, 0xa, 0x8, 0xc, 0x8, 0xe, 0x8, 0xf1, 0xb, 0x8, + 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0xf8, 0xa, + 0x9, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0xfc, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, + 0xff, 0xb, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, + 0xa, 0x7, 0xa, 0x107, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x10a, 0xb, 0xa, + 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, + 0x112, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x115, 0xb, 0xb, 0x3, 0xc, 0x3, + 0xc, 0x5, 0xc, 0x119, 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, + 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0x124, 0xa, + 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, + 0xf, 0x3, 0xf, 0x7, 0xf, 0x12e, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x131, + 0xb, 0xf, 0x5, 0xf, 0x133, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, + 0xf, 0x7, 0xf, 0x139, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x13c, 0xb, 0xf, + 0x5, 0xf, 0x13e, 0xa, 0xf, 0x3, 0xf, 0x5, 0xf, 0x141, 0xa, 0xf, 0x3, + 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x7, 0x10, 0x148, 0xa, + 0x10, 0xc, 0x10, 0xe, 0x10, 0x14b, 0xb, 0x10, 0x3, 0x11, 0x3, 0x11, + 0x5, 0x11, 0x14f, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13, + 0x3, 0x13, 0x7, 0x13, 0x156, 0xa, 0x13, 0xc, 0x13, 0xe, 0x13, 0x159, + 0xb, 0x13, 0x3, 0x14, 0x3, 0x14, 0x5, 0x14, 0x15d, 0xa, 0x14, 0x3, 0x14, + 0x5, 0x14, 0x160, 0xa, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15, + 0x165, 0xa, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, + 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x7, + 0x15, 0x172, 0xa, 0x15, 0xc, 0x15, 0xe, 0x15, 0x175, 0xb, 0x15, 0x3, + 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, + 0x3, 0x17, 0x3, 0x17, 0x7, 0x17, 0x180, 0xa, 0x17, 0xc, 0x17, 0xe, 0x17, + 0x183, 0xb, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x187, 0xa, 0x17, + 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x18d, 0xa, 0x18, + 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x191, 0xa, 0x18, 0x3, 0x18, 0x3, 0x18, + 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, + 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, + 0x3, 0x18, 0x3, 0x18, 0x7, 0x18, 0x1a4, 0xa, 0x18, 0xc, 0x18, 0xe, 0x18, + 0x1a7, 0xb, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, + 0x5, 0x18, 0x1ae, 0xa, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x1b2, + 0xa, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1b8, + 0xa, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1bb, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, + 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x7, 0x19, 0x1c4, + 0xa, 0x19, 0xc, 0x19, 0xe, 0x19, 0x1c7, 0xb, 0x19, 0x3, 0x19, 0x3, 0x19, + 0x5, 0x19, 0x1cb, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, + 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, + 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, + 0x3, 0x1a, 0x3, 0x1a, 0x7, 0x1a, 0x1e0, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, + 0x1e3, 0xb, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x1e7, 0xa, 0x1a, + 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x6, 0x1b, 0x1ed, 0xa, 0x1b, + 0xd, 0x1b, 0xe, 0x1b, 0x1ee, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, + 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0x1fd, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d, + 0x200, 0xb, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, + 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, + 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, + 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x7, 0x1e, 0x218, 0xa, 0x1e, + 0xc, 0x1e, 0xe, 0x1e, 0x21b, 0xb, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, + 0x5, 0x1e, 0x220, 0xa, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 0x3, 0x1f, + 0x5, 0x1f, 0x226, 0xa, 0x1f, 0x3, 0x1f, 0x5, 0x1f, 0x229, 0xa, 0x1f, + 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x7, + 0x20, 0x231, 0xa, 0x20, 0xc, 0x20, 0xe, 0x20, 0x234, 0xb, 0x20, 0x5, + 0x20, 0x236, 0xa, 0x20, 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0x23a, 0xa, + 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, + 0x3, 0x21, 0x5, 0x21, 0x243, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, + 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x24c, 0xa, 0x22, + 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x251, 0xa, 0x22, 0x3, 0x22, + 0x7, 0x22, 0x254, 0xa, 0x22, 0xc, 0x22, 0xe, 0x22, 0x257, 0xb, 0x22, + 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, + 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23, + 0x265, 0xa, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x26a, + 0xa, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, + 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x7, 0x24, 0x275, 0xa, 0x24, + 0xc, 0x24, 0xe, 0x24, 0x278, 0xb, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, + 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x27f, 0xa, 0x24, 0x3, 0x25, 0x3, 0x25, + 0x5, 0x25, 0x283, 0xa, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, + 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x29b, + 0xa, 0x27, 0x5, 0x27, 0x29d, 0xa, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, + 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, + 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, + 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2cd, 0xa, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2d3, 0xa, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2d7, 0xa, 0x27, 0x3, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2de, 0xa, 0x27, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 0x2e5, 0xa, 0x27, + 0xc, 0x27, 0xe, 0x27, 0x2e8, 0xb, 0x27, 0x5, 0x27, 0x2ea, 0xa, 0x27, + 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 0x2f1, + 0xa, 0x27, 0xc, 0x27, 0xe, 0x27, 0x2f4, 0xb, 0x27, 0x3, 0x28, 0x3, 0x28, + 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2fa, 0xa, 0x29, 0x3, 0x29, 0x3, 0x29, + 0x5, 0x29, 0x2fe, 0xa, 0x29, 0x7, 0x29, 0x300, 0xa, 0x29, 0xc, 0x29, + 0xe, 0x29, 0x303, 0xb, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a, + 0x3, 0x2a, 0x3, 0x2a, 0x7, 0x2a, 0x30b, 0xa, 0x2a, 0xc, 0x2a, 0xe, 0x2a, + 0x30e, 0xb, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c, + 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x5, 0x2c, 0x319, 0xa, 0x2c, + 0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x6, 0x2e, 0x31e, 0xa, 0x2e, 0xd, 0x2e, + 0xe, 0x2e, 0x31f, 0x3, 0x2f, 0x6, 0x2f, 0x323, 0xa, 0x2f, 0xd, 0x2f, + 0xe, 0x2f, 0x324, 0x3, 0x30, 0x6, 0x30, 0x328, 0xa, 0x30, 0xd, 0x30, + 0xe, 0x30, 0x329, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31, 0x32e, 0xa, 0x31, + 0x3, 0x32, 0x3, 0x32, 0x7, 0x32, 0x332, 0xa, 0x32, 0xc, 0x32, 0xe, 0x32, + 0x335, 0xb, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, + 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, + 0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x345, 0xa, 0x33, 0x3, 0x34, + 0x3, 0x34, 0x5, 0x34, 0x349, 0xa, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, + 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x5, 0x35, 0x352, 0xa, 0x35, + 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x358, 0xa, 0x36, + 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x35c, 0xa, 0x36, 0x3, 0x36, 0x5, 0x36, + 0x35f, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x37, 0x3, 0x37, + 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x38, 0x3, 0x38, 0x3, + 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x39, + 0x3, 0x39, 0x3, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3, + 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b, + 0x37f, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x6, 0x3b, 0x383, 0xa, 0x3b, + 0xd, 0x3b, 0xe, 0x3b, 0x384, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x389, + 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x38f, + 0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x395, + 0xa, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3, + 0x3e, 0x3, 0x3e, 0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x3a0, 0xa, 0x3f, + 0x3, 0x3f, 0x3, 0x3f, 0x7, 0x3f, 0x3a4, 0xa, 0x3f, 0xc, 0x3f, 0xe, 0x3f, + 0x3a7, 0xb, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40, + 0x7, 0x40, 0x3ae, 0xa, 0x40, 0xc, 0x40, 0xe, 0x40, 0x3b1, 0xb, 0x40, + 0x3, 0x41, 0x3, 0x41, 0x7, 0x41, 0x3b5, 0xa, 0x41, 0xc, 0x41, 0xe, 0x41, + 0x3b8, 0xb, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41, + 0x3be, 0xa, 0x41, 0x7, 0x41, 0x3c0, 0xa, 0x41, 0xc, 0x41, 0xe, 0x41, + 0x3c3, 0xb, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, + 0x5, 0x42, 0x3ca, 0xa, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, + 0x5, 0x42, 0x3d0, 0xa, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43, + 0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, + 0x44, 0x3, 0x44, 0x3, 0x45, 0x3, 0x45, 0x5, 0x45, 0x3e0, 0xa, 0x45, + 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, + 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x5, 0x46, 0x3ed, + 0xa, 0x46, 0x3, 0x47, 0x3, 0x47, 0x7, 0x47, 0x3f1, 0xa, 0x47, 0xc, 0x47, + 0xe, 0x47, 0x3f4, 0xb, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48, + 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x3fc, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48, + 0x3, 0x48, 0x3, 0x48, 0x7, 0x48, 0x402, 0xa, 0x48, 0xc, 0x48, 0xe, 0x48, + 0x405, 0xb, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x409, 0xa, 0x48, + 0x5, 0x48, 0x40b, 0xa, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, + 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x6, 0x49, 0x414, 0xa, 0x49, 0xd, 0x49, + 0xe, 0x49, 0x415, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x5, 0x49, 0x41b, + 0xa, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3, + 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c, + 0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x6, 0x4d, 0x42e, + 0xa, 0x4d, 0xd, 0x4d, 0xe, 0x4d, 0x42f, 0x3, 0x4d, 0x3, 0x4d, 0x5, 0x4d, + 0x434, 0xa, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x5, 0x4d, 0x438, 0xa, 0x4d, + 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x7, + 0x4e, 0x440, 0xa, 0x4e, 0xc, 0x4e, 0xe, 0x4e, 0x443, 0xb, 0x4e, 0x5, + 0x4e, 0x445, 0xa, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, + 0x3, 0x4e, 0x7, 0x4e, 0x44c, 0xa, 0x4e, 0xc, 0x4e, 0xe, 0x4e, 0x44f, + 0xb, 0x4e, 0x5, 0x4e, 0x451, 0xa, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f, + 0x3, 0x4f, 0x3, 0x4f, 0x7, 0x4f, 0x458, 0xa, 0x4f, 0xc, 0x4f, 0xe, 0x4f, + 0x45b, 0xb, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, + 0x7, 0x50, 0x462, 0xa, 0x50, 0xc, 0x50, 0xe, 0x50, 0x465, 0xb, 0x50, + 0x5, 0x50, 0x467, 0xa, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x51, 0x3, 0x51, + 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x5, 0x52, 0x471, 0xa, 0x52, + 0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x5, 0x53, 0x476, 0xa, 0x53, 0x3, 0x53, + 0x3, 0x113, 0x4, 0x42, 0x4c, 0x54, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, + 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, + 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, + 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, + 0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, + 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, + 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, + 0xa0, 0xa2, 0xa4, 0x2, 0x13, 0x5, 0x2, 0x19, 0x19, 0x27, 0x27, 0x31, + 0x32, 0x5, 0x2, 0x30, 0x30, 0x33, 0x33, 0x41, 0x41, 0x4, 0x2, 0x1a, + 0x1a, 0x34, 0x34, 0x5, 0x2, 0xd, 0xd, 0x2b, 0x2b, 0x38, 0x38, 0x5, 0x2, + 0x13, 0x13, 0x65, 0x65, 0x70, 0x73, 0x3, 0x2, 0x66, 0x68, 0x3, 0x2, + 0x64, 0x65, 0x3, 0x2, 0x61, 0x63, 0x3, 0x2, 0x6c, 0x6f, 0x3, 0x2, 0x6a, + 0x6b, 0x3, 0x2, 0x72, 0x73, 0x3, 0x2, 0x4f, 0x5a, 0x4, 0x2, 0x1d, 0x1d, + 0x7a, 0x7a, 0x4, 0x2, 0x1b, 0x1b, 0x3b, 0x3b, 0x3, 0x2, 0x78, 0x79, + 0x4, 0x2, 0x8f, 0x8f, 0x98, 0x98, 0x4, 0x2, 0x87, 0x87, 0x8e, 0x8e, + 0x2, 0x4f8, 0x2, 0xb0, 0x3, 0x2, 0x2, 0x2, 0x4, 0xb5, 0x3, 0x2, 0x2, + 0x2, 0x6, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x8, 0xd1, 0x3, 0x2, 0x2, 0x2, 0xa, + 0xd6, 0x3, 0x2, 0x2, 0x2, 0xc, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xe, 0xe4, + 0x3, 0x2, 0x2, 0x2, 0x10, 0xf4, 0x3, 0x2, 0x2, 0x2, 0x12, 0x102, 0x3, + 0x2, 0x2, 0x2, 0x14, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x16, 0x116, 0x3, 0x2, + 0x2, 0x2, 0x18, 0x123, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x125, 0x3, 0x2, 0x2, + 0x2, 0x1c, 0x129, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x144, 0x3, 0x2, 0x2, 0x2, + 0x20, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x22, 0x150, 0x3, 0x2, 0x2, 0x2, 0x24, + 0x152, 0x3, 0x2, 0x2, 0x2, 0x26, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x28, 0x161, + 0x3, 0x2, 0x2, 0x2, 0x2a, 0x178, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x17a, 0x3, + 0x2, 0x2, 0x2, 0x2e, 0x188, 0x3, 0x2, 0x2, 0x2, 0x30, 0x1b3, 0x3, 0x2, + 0x2, 0x2, 0x32, 0x1cc, 0x3, 0x2, 0x2, 0x2, 0x34, 0x1e8, 0x3, 0x2, 0x2, + 0x2, 0x36, 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x38, 0x1f6, 0x3, 0x2, 0x2, 0x2, + 0x3a, 0x203, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x223, 0x3, 0x2, 0x2, 0x2, 0x3e, + 0x22a, 0x3, 0x2, 0x2, 0x2, 0x40, 0x23d, 0x3, 0x2, 0x2, 0x2, 0x42, 0x24b, + 0x3, 0x2, 0x2, 0x2, 0x44, 0x264, 0x3, 0x2, 0x2, 0x2, 0x46, 0x266, 0x3, + 0x2, 0x2, 0x2, 0x48, 0x280, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x286, 0x3, 0x2, + 0x2, 0x2, 0x4c, 0x29c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x2f5, 0x3, 0x2, 0x2, + 0x2, 0x50, 0x2f7, 0x3, 0x2, 0x2, 0x2, 0x52, 0x306, 0x3, 0x2, 0x2, 0x2, + 0x54, 0x311, 0x3, 0x2, 0x2, 0x2, 0x56, 0x318, 0x3, 0x2, 0x2, 0x2, 0x58, + 0x31a, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x322, + 0x3, 0x2, 0x2, 0x2, 0x5e, 0x327, 0x3, 0x2, 0x2, 0x2, 0x60, 0x32b, 0x3, + 0x2, 0x2, 0x2, 0x62, 0x32f, 0x3, 0x2, 0x2, 0x2, 0x64, 0x344, 0x3, 0x2, + 0x2, 0x2, 0x66, 0x348, 0x3, 0x2, 0x2, 0x2, 0x68, 0x34a, 0x3, 0x2, 0x2, + 0x2, 0x6a, 0x353, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x363, 0x3, 0x2, 0x2, 0x2, + 0x6e, 0x369, 0x3, 0x2, 0x2, 0x2, 0x70, 0x371, 0x3, 0x2, 0x2, 0x2, 0x72, + 0x374, 0x3, 0x2, 0x2, 0x2, 0x74, 0x377, 0x3, 0x2, 0x2, 0x2, 0x76, 0x386, + 0x3, 0x2, 0x2, 0x2, 0x78, 0x392, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x398, 0x3, + 0x2, 0x2, 0x2, 0x7c, 0x39d, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x3aa, 0x3, 0x2, + 0x2, 0x2, 0x80, 0x3b2, 0x3, 0x2, 0x2, 0x2, 0x82, 0x3cf, 0x3, 0x2, 0x2, + 0x2, 0x84, 0x3d3, 0x3, 0x2, 0x2, 0x2, 0x86, 0x3d6, 0x3, 0x2, 0x2, 0x2, + 0x88, 0x3df, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x3ec, 0x3, 0x2, 0x2, 0x2, 0x8c, + 0x3ee, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x40a, 0x3, 0x2, 0x2, 0x2, 0x90, 0x41a, + 0x3, 0x2, 0x2, 0x2, 0x92, 0x41c, 0x3, 0x2, 0x2, 0x2, 0x94, 0x420, 0x3, + 0x2, 0x2, 0x2, 0x96, 0x426, 0x3, 0x2, 0x2, 0x2, 0x98, 0x42a, 0x3, 0x2, + 0x2, 0x2, 0x9a, 0x439, 0x3, 0x2, 0x2, 0x2, 0x9c, 0x454, 0x3, 0x2, 0x2, + 0x2, 0x9e, 0x45c, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x46a, 0x3, 0x2, 0x2, 0x2, + 0xa2, 0x470, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x475, 0x3, 0x2, 0x2, 0x2, 0xa6, + 0xaf, 0x5, 0x4, 0x3, 0x2, 0xa7, 0xaf, 0x5, 0x6, 0x4, 0x2, 0xa8, 0xaf, + 0x5, 0xe, 0x8, 0x2, 0xa9, 0xaf, 0x5, 0x10, 0x9, 0x2, 0xaa, 0xaf, 0x5, + 0x12, 0xa, 0x2, 0xab, 0xaf, 0x5, 0x2e, 0x18, 0x2, 0xac, 0xaf, 0x5, 0x34, + 0x1b, 0x2, 0xad, 0xaf, 0x5, 0x38, 0x1d, 0x2, 0xae, 0xa6, 0x3, 0x2, 0x2, + 0x2, 0xae, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xae, 0xa8, 0x3, 0x2, 0x2, 0x2, + 0xae, 0xa9, 0x3, 0x2, 0x2, 0x2, 0xae, 0xaa, 0x3, 0x2, 0x2, 0x2, 0xae, + 0xab, 0x3, 0x2, 0x2, 0x2, 0xae, 0xac, 0x3, 0x2, 0x2, 0x2, 0xae, 0xad, + 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xae, 0x3, + 0x2, 0x2, 0x2, 0xb0, 0xb1, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xb3, 0x3, 0x2, + 0x2, 0x2, 0xb2, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x7, 0x2, 0x2, + 0x3, 0xb4, 0x3, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb7, 0x7, 0x4, 0x2, 0x2, + 0xb6, 0xb8, 0x7, 0x9f, 0x2, 0x2, 0xb7, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8, + 0xb9, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xba, + 0x3, 0x2, 0x2, 0x2, 0xba, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbc, 0x7, + 0xa0, 0x2, 0x2, 0xbc, 0x5, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xcd, 0x7, 0x24, + 0x2, 0x2, 0xbe, 0xc1, 0x5, 0xa, 0x6, 0x2, 0xbf, 0xc0, 0x7, 0x8, 0x2, + 0x2, 0xc0, 0xc2, 0x5, 0x54, 0x2b, 0x2, 0xc1, 0xbf, 0x3, 0x2, 0x2, 0x2, + 0xc1, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc2, 0xce, 0x3, 0x2, 0x2, 0x2, 0xc3, + 0xc4, 0x5, 0xc, 0x7, 0x2, 0xc4, 0xc5, 0x7, 0x1d, 0x2, 0x2, 0xc5, 0xc6, + 0x5, 0xa, 0x6, 0x2, 0xc6, 0xce, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc8, 0x7, + 0x66, 0x2, 0x2, 0xc8, 0xc9, 0x7, 0x8, 0x2, 0x2, 0xc9, 0xca, 0x5, 0x54, + 0x2b, 0x2, 0xca, 0xcb, 0x7, 0x1d, 0x2, 0x2, 0xcb, 0xcc, 0x5, 0xa, 0x6, + 0x2, 0xcc, 0xce, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xbe, 0x3, 0x2, 0x2, 0x2, + 0xcd, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xce, + 0xcf, 0x3, 0x2, 0x2, 0x2, 0xcf, 0xd0, 0x7, 0x4b, 0x2, 0x2, 0xd0, 0x7, + 0x3, 0x2, 0x2, 0x2, 0xd1, 0xd4, 0x5, 0x54, 0x2b, 0x2, 0xd2, 0xd3, 0x7, + 0x8, 0x2, 0x2, 0xd3, 0xd5, 0x5, 0x54, 0x2b, 0x2, 0xd4, 0xd2, 0x3, 0x2, + 0x2, 0x2, 0xd4, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0x9, 0x3, 0x2, 0x2, + 0x2, 0xd6, 0xd7, 0x7, 0x75, 0x2, 0x2, 0xd7, 0xb, 0x3, 0x2, 0x2, 0x2, + 0xd8, 0xd9, 0x7, 0x48, 0x2, 0x2, 0xd9, 0xde, 0x5, 0x8, 0x5, 0x2, 0xda, + 0xdb, 0x7, 0x5b, 0x2, 0x2, 0xdb, 0xdd, 0x5, 0x8, 0x5, 0x2, 0xdc, 0xda, + 0x3, 0x2, 0x2, 0x2, 0xdd, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdc, 0x3, + 0x2, 0x2, 0x2, 0xde, 0xdf, 0x3, 0x2, 0x2, 0x2, 0xdf, 0xe1, 0x3, 0x2, + 0x2, 0x2, 0xe0, 0xde, 0x3, 0x2, 0x2, 0x2, 0xe1, 0xe2, 0x7, 0x49, 0x2, + 0x2, 0xe2, 0xd, 0x3, 0x2, 0x2, 0x2, 0xe3, 0xe5, 0x7, 0x5, 0x2, 0x2, + 0xe4, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe5, + 0xe6, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x7, 0x12, 0x2, 0x2, 0xe7, 0xe9, + 0x5, 0x54, 0x2b, 0x2, 0xe8, 0xea, 0x5, 0x14, 0xb, 0x2, 0xe9, 0xe8, 0x3, + 0x2, 0x2, 0x2, 0xe9, 0xea, 0x3, 0x2, 0x2, 0x2, 0xea, 0xeb, 0x3, 0x2, + 0x2, 0x2, 0xeb, 0xef, 0x7, 0x48, 0x2, 0x2, 0xec, 0xee, 0x5, 0x18, 0xd, + 0x2, 0xed, 0xec, 0x3, 0x2, 0x2, 0x2, 0xee, 0xf1, 0x3, 0x2, 0x2, 0x2, + 0xef, 0xed, 0x3, 0x2, 0x2, 0x2, 0xef, 0xf0, 0x3, 0x2, 0x2, 0x2, 0xf0, + 0xf2, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3, + 0x7, 0x49, 0x2, 0x2, 0xf3, 0xf, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x7, + 0x26, 0x2, 0x2, 0xf5, 0xf7, 0x5, 0x54, 0x2b, 0x2, 0xf6, 0xf8, 0x5, 0x14, + 0xb, 0x2, 0xf7, 0xf6, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x3, 0x2, 0x2, + 0x2, 0xf8, 0xf9, 0x3, 0x2, 0x2, 0x2, 0xf9, 0xfd, 0x7, 0x48, 0x2, 0x2, + 0xfa, 0xfc, 0x5, 0x18, 0xd, 0x2, 0xfb, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xfc, + 0xff, 0x3, 0x2, 0x2, 0x2, 0xfd, 0xfb, 0x3, 0x2, 0x2, 0x2, 0xfd, 0xfe, + 0x3, 0x2, 0x2, 0x2, 0xfe, 0x100, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfd, 0x3, + 0x2, 0x2, 0x2, 0x100, 0x101, 0x7, 0x49, 0x2, 0x2, 0x101, 0x11, 0x3, + 0x2, 0x2, 0x2, 0x102, 0x103, 0x7, 0x29, 0x2, 0x2, 0x103, 0x104, 0x5, + 0x54, 0x2b, 0x2, 0x104, 0x108, 0x7, 0x48, 0x2, 0x2, 0x105, 0x107, 0x5, + 0x18, 0xd, 0x2, 0x106, 0x105, 0x3, 0x2, 0x2, 0x2, 0x107, 0x10a, 0x3, + 0x2, 0x2, 0x2, 0x108, 0x106, 0x3, 0x2, 0x2, 0x2, 0x108, 0x109, 0x3, + 0x2, 0x2, 0x2, 0x109, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x108, 0x3, + 0x2, 0x2, 0x2, 0x10b, 0x10c, 0x7, 0x49, 0x2, 0x2, 0x10c, 0x13, 0x3, + 0x2, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x28, 0x2, 0x2, 0x10e, 0x113, 0x5, + 0x16, 0xc, 0x2, 0x10f, 0x110, 0x7, 0x5b, 0x2, 0x2, 0x110, 0x112, 0x5, + 0x16, 0xc, 0x2, 0x111, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x112, 0x115, 0x3, + 0x2, 0x2, 0x2, 0x113, 0x114, 0x3, 0x2, 0x2, 0x2, 0x113, 0x111, 0x3, + 0x2, 0x2, 0x2, 0x114, 0x15, 0x3, 0x2, 0x2, 0x2, 0x115, 0x113, 0x3, 0x2, + 0x2, 0x2, 0x116, 0x118, 0x5, 0x1e, 0x10, 0x2, 0x117, 0x119, 0x5, 0x1c, + 0xf, 0x2, 0x118, 0x117, 0x3, 0x2, 0x2, 0x2, 0x118, 0x119, 0x3, 0x2, + 0x2, 0x2, 0x119, 0x17, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x124, 0x5, 0x28, + 0x15, 0x2, 0x11b, 0x124, 0x5, 0x2e, 0x18, 0x2, 0x11c, 0x124, 0x5, 0x30, + 0x19, 0x2, 0x11d, 0x124, 0x5, 0x32, 0x1a, 0x2, 0x11e, 0x124, 0x5, 0x34, + 0x1b, 0x2, 0x11f, 0x124, 0x5, 0x38, 0x1d, 0x2, 0x120, 0x124, 0x5, 0x3a, + 0x1e, 0x2, 0x121, 0x124, 0x5, 0x3e, 0x20, 0x2, 0x122, 0x124, 0x5, 0x40, + 0x21, 0x2, 0x123, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x123, 0x11b, 0x3, 0x2, + 0x2, 0x2, 0x123, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x123, 0x11d, 0x3, 0x2, + 0x2, 0x2, 0x123, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x123, 0x11f, 0x3, 0x2, + 0x2, 0x2, 0x123, 0x120, 0x3, 0x2, 0x2, 0x2, 0x123, 0x121, 0x3, 0x2, + 0x2, 0x2, 0x123, 0x122, 0x3, 0x2, 0x2, 0x2, 0x124, 0x19, 0x3, 0x2, 0x2, + 0x2, 0x125, 0x126, 0x5, 0x54, 0x2b, 0x2, 0x126, 0x127, 0x7, 0x4a, 0x2, + 0x2, 0x127, 0x128, 0x5, 0x4c, 0x27, 0x2, 0x128, 0x1b, 0x3, 0x2, 0x2, + 0x2, 0x129, 0x140, 0x7, 0x44, 0x2, 0x2, 0x12a, 0x12f, 0x5, 0x4c, 0x27, + 0x2, 0x12b, 0x12c, 0x7, 0x5b, 0x2, 0x2, 0x12c, 0x12e, 0x5, 0x4c, 0x27, + 0x2, 0x12d, 0x12b, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x131, 0x3, 0x2, 0x2, + 0x2, 0x12f, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x130, 0x3, 0x2, 0x2, + 0x2, 0x130, 0x133, 0x3, 0x2, 0x2, 0x2, 0x131, 0x12f, 0x3, 0x2, 0x2, + 0x2, 0x132, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x132, 0x133, 0x3, 0x2, 0x2, + 0x2, 0x133, 0x141, 0x3, 0x2, 0x2, 0x2, 0x134, 0x13d, 0x7, 0x48, 0x2, + 0x2, 0x135, 0x13a, 0x5, 0x1a, 0xe, 0x2, 0x136, 0x137, 0x7, 0x5b, 0x2, + 0x2, 0x137, 0x139, 0x5, 0x1a, 0xe, 0x2, 0x138, 0x136, 0x3, 0x2, 0x2, + 0x2, 0x139, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x13a, 0x138, 0x3, 0x2, 0x2, + 0x2, 0x13a, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13e, 0x3, 0x2, 0x2, + 0x2, 0x13c, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x135, 0x3, 0x2, 0x2, + 0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13f, 0x3, 0x2, 0x2, + 0x2, 0x13f, 0x141, 0x7, 0x49, 0x2, 0x2, 0x140, 0x132, 0x3, 0x2, 0x2, + 0x2, 0x140, 0x134, 0x3, 0x2, 0x2, 0x2, 0x141, 0x142, 0x3, 0x2, 0x2, + 0x2, 0x142, 0x143, 0x7, 0x45, 0x2, 0x2, 0x143, 0x1d, 0x3, 0x2, 0x2, + 0x2, 0x144, 0x149, 0x5, 0x54, 0x2b, 0x2, 0x145, 0x146, 0x7, 0x4c, 0x2, + 0x2, 0x146, 0x148, 0x5, 0x54, 0x2b, 0x2, 0x147, 0x145, 0x3, 0x2, 0x2, + 0x2, 0x148, 0x14b, 0x3, 0x2, 0x2, 0x2, 0x149, 0x147, 0x3, 0x2, 0x2, + 0x2, 0x149, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14a, 0x1f, 0x3, 0x2, 0x2, 0x2, + 0x14b, 0x149, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14e, 0x5, 0x54, 0x2b, 0x2, + 0x14d, 0x14f, 0x5, 0x1c, 0xf, 0x2, 0x14e, 0x14d, 0x3, 0x2, 0x2, 0x2, + 0x14e, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x14f, 0x21, 0x3, 0x2, 0x2, 0x2, 0x150, + 0x151, 0x9, 0x2, 0x2, 0x2, 0x151, 0x23, 0x3, 0x2, 0x2, 0x2, 0x152, 0x157, + 0x5, 0x26, 0x14, 0x2, 0x153, 0x154, 0x7, 0x5b, 0x2, 0x2, 0x154, 0x156, + 0x5, 0x26, 0x14, 0x2, 0x155, 0x153, 0x3, 0x2, 0x2, 0x2, 0x156, 0x159, + 0x3, 0x2, 0x2, 0x2, 0x157, 0x155, 0x3, 0x2, 0x2, 0x2, 0x157, 0x158, + 0x3, 0x2, 0x2, 0x2, 0x158, 0x25, 0x3, 0x2, 0x2, 0x2, 0x159, 0x157, 0x3, + 0x2, 0x2, 0x2, 0x15a, 0x15c, 0x5, 0x42, 0x22, 0x2, 0x15b, 0x15d, 0x5, + 0x4a, 0x26, 0x2, 0x15c, 0x15b, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15d, 0x3, + 0x2, 0x2, 0x2, 0x15d, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x15e, 0x160, 0x5, + 0x54, 0x2b, 0x2, 0x15f, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x15f, 0x160, 0x3, + 0x2, 0x2, 0x2, 0x160, 0x27, 0x3, 0x2, 0x2, 0x2, 0x161, 0x162, 0x7, 0x10, + 0x2, 0x2, 0x162, 0x164, 0x7, 0x44, 0x2, 0x2, 0x163, 0x165, 0x5, 0x24, + 0x13, 0x2, 0x164, 0x163, 0x3, 0x2, 0x2, 0x2, 0x164, 0x165, 0x3, 0x2, + 0x2, 0x2, 0x165, 0x166, 0x3, 0x2, 0x2, 0x2, 0x166, 0x173, 0x7, 0x45, + 0x2, 0x2, 0x167, 0x172, 0x5, 0x20, 0x11, 0x2, 0x168, 0x169, 0x6, 0x15, + 0x2, 0x3, 0x169, 0x16a, 0x7, 0x30, 0x2, 0x2, 0x16a, 0x172, 0x8, 0x15, + 0x1, 0x2, 0x16b, 0x16c, 0x6, 0x15, 0x3, 0x3, 0x16c, 0x16d, 0x7, 0x27, + 0x2, 0x2, 0x16d, 0x172, 0x8, 0x15, 0x1, 0x2, 0x16e, 0x16f, 0x6, 0x15, + 0x4, 0x3, 0x16f, 0x170, 0x7, 0x32, 0x2, 0x2, 0x170, 0x172, 0x8, 0x15, + 0x1, 0x2, 0x171, 0x167, 0x3, 0x2, 0x2, 0x2, 0x171, 0x168, 0x3, 0x2, + 0x2, 0x2, 0x171, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x171, 0x16e, 0x3, 0x2, + 0x2, 0x2, 0x172, 0x175, 0x3, 0x2, 0x2, 0x2, 0x173, 0x171, 0x3, 0x2, + 0x2, 0x2, 0x173, 0x174, 0x3, 0x2, 0x2, 0x2, 0x174, 0x176, 0x3, 0x2, + 0x2, 0x2, 0x175, 0x173, 0x3, 0x2, 0x2, 0x2, 0x176, 0x177, 0x5, 0x62, + 0x32, 0x2, 0x177, 0x29, 0x3, 0x2, 0x2, 0x2, 0x178, 0x179, 0x9, 0x3, + 0x2, 0x2, 0x179, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x186, 0x7, 0x2f, + 0x2, 0x2, 0x17b, 0x17c, 0x7, 0x44, 0x2, 0x2, 0x17c, 0x181, 0x5, 0x1e, + 0x10, 0x2, 0x17d, 0x17e, 0x7, 0x5b, 0x2, 0x2, 0x17e, 0x180, 0x5, 0x1e, + 0x10, 0x2, 0x17f, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x180, 0x183, 0x3, 0x2, + 0x2, 0x2, 0x181, 0x17f, 0x3, 0x2, 0x2, 0x2, 0x181, 0x182, 0x3, 0x2, + 0x2, 0x2, 0x182, 0x184, 0x3, 0x2, 0x2, 0x2, 0x183, 0x181, 0x3, 0x2, + 0x2, 0x2, 0x184, 0x185, 0x7, 0x45, 0x2, 0x2, 0x185, 0x187, 0x3, 0x2, + 0x2, 0x2, 0x186, 0x17b, 0x3, 0x2, 0x2, 0x2, 0x186, 0x187, 0x3, 0x2, + 0x2, 0x2, 0x187, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x188, 0x18c, 0x7, 0x20, + 0x2, 0x2, 0x189, 0x18d, 0x5, 0x54, 0x2b, 0x2, 0x18a, 0x18d, 0x7, 0x1a, + 0x2, 0x2, 0x18b, 0x18d, 0x7, 0x34, 0x2, 0x2, 0x18c, 0x189, 0x3, 0x2, + 0x2, 0x2, 0x18c, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x18c, 0x18b, 0x3, 0x2, + 0x2, 0x2, 0x18d, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x18e, 0x190, 0x7, 0x44, + 0x2, 0x2, 0x18f, 0x191, 0x5, 0x24, 0x13, 0x2, 0x190, 0x18f, 0x3, 0x2, + 0x2, 0x2, 0x190, 0x191, 0x3, 0x2, 0x2, 0x2, 0x191, 0x192, 0x3, 0x2, + 0x2, 0x2, 0x192, 0x1a5, 0x7, 0x45, 0x2, 0x2, 0x193, 0x194, 0x6, 0x18, + 0x5, 0x3, 0x194, 0x195, 0x5, 0x22, 0x12, 0x2, 0x195, 0x196, 0x8, 0x18, + 0x1, 0x2, 0x196, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x197, 0x198, 0x6, 0x18, + 0x6, 0x3, 0x198, 0x199, 0x5, 0x2a, 0x16, 0x2, 0x199, 0x19a, 0x8, 0x18, + 0x1, 0x2, 0x19a, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x19b, 0x1a4, 0x5, 0x20, + 0x11, 0x2, 0x19c, 0x19d, 0x6, 0x18, 0x7, 0x3, 0x19d, 0x19e, 0x7, 0x42, + 0x2, 0x2, 0x19e, 0x1a4, 0x8, 0x18, 0x1, 0x2, 0x19f, 0x1a0, 0x6, 0x18, + 0x8, 0x3, 0x1a0, 0x1a1, 0x5, 0x2c, 0x17, 0x2, 0x1a1, 0x1a2, 0x8, 0x18, + 0x1, 0x2, 0x1a2, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x193, 0x3, 0x2, + 0x2, 0x2, 0x1a3, 0x197, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x19b, 0x3, 0x2, + 0x2, 0x2, 0x1a3, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x19f, 0x3, 0x2, + 0x2, 0x2, 0x1a4, 0x1a7, 0x3, 0x2, 0x2, 0x2, 0x1a5, 0x1a3, 0x3, 0x2, + 0x2, 0x2, 0x1a5, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1ad, 0x3, 0x2, + 0x2, 0x2, 0x1a7, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x1a9, 0x7, 0x36, + 0x2, 0x2, 0x1a9, 0x1aa, 0x7, 0x44, 0x2, 0x2, 0x1aa, 0x1ab, 0x5, 0x24, + 0x13, 0x2, 0x1ab, 0x1ac, 0x7, 0x45, 0x2, 0x2, 0x1ac, 0x1ae, 0x3, 0x2, + 0x2, 0x2, 0x1ad, 0x1a8, 0x3, 0x2, 0x2, 0x2, 0x1ad, 0x1ae, 0x3, 0x2, + 0x2, 0x2, 0x1ae, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b2, 0x7, 0x4b, + 0x2, 0x2, 0x1b0, 0x1b2, 0x5, 0x62, 0x32, 0x2, 0x1b1, 0x1af, 0x3, 0x2, + 0x2, 0x2, 0x1b1, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x2f, 0x3, 0x2, 0x2, + 0x2, 0x1b3, 0x1b4, 0x7, 0x2c, 0x2, 0x2, 0x1b4, 0x1ba, 0x5, 0x54, 0x2b, + 0x2, 0x1b5, 0x1b7, 0x7, 0x44, 0x2, 0x2, 0x1b6, 0x1b8, 0x5, 0x24, 0x13, + 0x2, 0x1b7, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1b8, 0x3, 0x2, 0x2, + 0x2, 0x1b8, 0x1b9, 0x3, 0x2, 0x2, 0x2, 0x1b9, 0x1bb, 0x7, 0x45, 0x2, + 0x2, 0x1ba, 0x1b5, 0x3, 0x2, 0x2, 0x2, 0x1ba, 0x1bb, 0x3, 0x2, 0x2, + 0x2, 0x1bb, 0x1c5, 0x3, 0x2, 0x2, 0x2, 0x1bc, 0x1bd, 0x6, 0x19, 0x9, + 0x3, 0x1bd, 0x1be, 0x7, 0x42, 0x2, 0x2, 0x1be, 0x1c4, 0x8, 0x19, 0x1, + 0x2, 0x1bf, 0x1c0, 0x6, 0x19, 0xa, 0x3, 0x1c0, 0x1c1, 0x5, 0x2c, 0x17, + 0x2, 0x1c1, 0x1c2, 0x8, 0x19, 0x1, 0x2, 0x1c2, 0x1c4, 0x3, 0x2, 0x2, + 0x2, 0x1c3, 0x1bc, 0x3, 0x2, 0x2, 0x2, 0x1c3, 0x1bf, 0x3, 0x2, 0x2, + 0x2, 0x1c4, 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1c3, 0x3, 0x2, 0x2, + 0x2, 0x1c5, 0x1c6, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1ca, 0x3, 0x2, 0x2, + 0x2, 0x1c7, 0x1c5, 0x3, 0x2, 0x2, 0x2, 0x1c8, 0x1cb, 0x7, 0x4b, 0x2, + 0x2, 0x1c9, 0x1cb, 0x5, 0x62, 0x32, 0x2, 0x1ca, 0x1c8, 0x3, 0x2, 0x2, + 0x2, 0x1ca, 0x1c9, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x31, 0x3, 0x2, 0x2, 0x2, + 0x1cc, 0x1cd, 0x9, 0x4, 0x2, 0x2, 0x1cd, 0x1ce, 0x7, 0x44, 0x2, 0x2, + 0x1ce, 0x1e1, 0x7, 0x45, 0x2, 0x2, 0x1cf, 0x1d0, 0x6, 0x1a, 0xb, 0x3, + 0x1d0, 0x1d1, 0x5, 0x22, 0x12, 0x2, 0x1d1, 0x1d2, 0x8, 0x1a, 0x1, 0x2, + 0x1d2, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1d3, 0x1d4, 0x6, 0x1a, 0xc, 0x3, + 0x1d4, 0x1d5, 0x5, 0x2a, 0x16, 0x2, 0x1d5, 0x1d6, 0x8, 0x1a, 0x1, 0x2, + 0x1d6, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1d7, 0x1e0, 0x5, 0x20, 0x11, 0x2, + 0x1d8, 0x1d9, 0x6, 0x1a, 0xd, 0x3, 0x1d9, 0x1da, 0x7, 0x42, 0x2, 0x2, + 0x1da, 0x1e0, 0x8, 0x1a, 0x1, 0x2, 0x1db, 0x1dc, 0x6, 0x1a, 0xe, 0x3, + 0x1dc, 0x1dd, 0x5, 0x2c, 0x17, 0x2, 0x1dd, 0x1de, 0x8, 0x1a, 0x1, 0x2, + 0x1de, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1cf, 0x3, 0x2, 0x2, 0x2, + 0x1df, 0x1d3, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1d7, 0x3, 0x2, 0x2, 0x2, + 0x1df, 0x1d8, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1db, 0x3, 0x2, 0x2, 0x2, + 0x1e0, 0x1e3, 0x3, 0x2, 0x2, 0x2, 0x1e1, 0x1df, 0x3, 0x2, 0x2, 0x2, + 0x1e1, 0x1e2, 0x3, 0x2, 0x2, 0x2, 0x1e2, 0x1e6, 0x3, 0x2, 0x2, 0x2, + 0x1e3, 0x1e1, 0x3, 0x2, 0x2, 0x2, 0x1e4, 0x1e7, 0x7, 0x4b, 0x2, 0x2, + 0x1e5, 0x1e7, 0x5, 0x62, 0x32, 0x2, 0x1e6, 0x1e4, 0x3, 0x2, 0x2, 0x2, + 0x1e6, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e7, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1e8, + 0x1e9, 0x7, 0x3a, 0x2, 0x2, 0x1e9, 0x1ea, 0x5, 0x54, 0x2b, 0x2, 0x1ea, + 0x1ec, 0x7, 0x48, 0x2, 0x2, 0x1eb, 0x1ed, 0x5, 0x36, 0x1c, 0x2, 0x1ec, + 0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1ed, 0x1ee, 0x3, 0x2, 0x2, 0x2, 0x1ee, + 0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1ee, 0x1ef, 0x3, 0x2, 0x2, 0x2, 0x1ef, + 0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x1f1, 0x7, 0x49, 0x2, 0x2, 0x1f1, + 0x35, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f3, 0x5, 0x42, 0x22, 0x2, 0x1f3, + 0x1f4, 0x5, 0x54, 0x2b, 0x2, 0x1f4, 0x1f5, 0x7, 0x4b, 0x2, 0x2, 0x1f5, + 0x37, 0x3, 0x2, 0x2, 0x2, 0x1f6, 0x1f7, 0x7, 0x17, 0x2, 0x2, 0x1f7, + 0x1f8, 0x5, 0x54, 0x2b, 0x2, 0x1f8, 0x1f9, 0x7, 0x48, 0x2, 0x2, 0x1f9, + 0x1fe, 0x5, 0x54, 0x2b, 0x2, 0x1fa, 0x1fb, 0x7, 0x5b, 0x2, 0x2, 0x1fb, + 0x1fd, 0x5, 0x54, 0x2b, 0x2, 0x1fc, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1fd, + 0x200, 0x3, 0x2, 0x2, 0x2, 0x1fe, 0x1fc, 0x3, 0x2, 0x2, 0x2, 0x1fe, + 0x1ff, 0x3, 0x2, 0x2, 0x2, 0x1ff, 0x201, 0x3, 0x2, 0x2, 0x2, 0x200, + 0x1fe, 0x3, 0x2, 0x2, 0x2, 0x201, 0x202, 0x7, 0x49, 0x2, 0x2, 0x202, + 0x39, 0x3, 0x2, 0x2, 0x2, 0x203, 0x219, 0x5, 0x42, 0x22, 0x2, 0x204, + 0x205, 0x6, 0x1e, 0xf, 0x3, 0x205, 0x206, 0x7, 0x32, 0x2, 0x2, 0x206, + 0x218, 0x8, 0x1e, 0x1, 0x2, 0x207, 0x208, 0x6, 0x1e, 0x10, 0x3, 0x208, + 0x209, 0x7, 0x31, 0x2, 0x2, 0x209, 0x218, 0x8, 0x1e, 0x1, 0x2, 0x20a, + 0x20b, 0x6, 0x1e, 0x11, 0x3, 0x20b, 0x20c, 0x7, 0x27, 0x2, 0x2, 0x20c, + 0x218, 0x8, 0x1e, 0x1, 0x2, 0x20d, 0x20e, 0x6, 0x1e, 0x12, 0x3, 0x20e, + 0x20f, 0x7, 0xf, 0x2, 0x2, 0x20f, 0x218, 0x8, 0x1e, 0x1, 0x2, 0x210, + 0x211, 0x6, 0x1e, 0x13, 0x3, 0x211, 0x212, 0x5, 0x2c, 0x17, 0x2, 0x212, + 0x213, 0x8, 0x1e, 0x1, 0x2, 0x213, 0x218, 0x3, 0x2, 0x2, 0x2, 0x214, + 0x215, 0x6, 0x1e, 0x14, 0x3, 0x215, 0x216, 0x7, 0x23, 0x2, 0x2, 0x216, + 0x218, 0x8, 0x1e, 0x1, 0x2, 0x217, 0x204, 0x3, 0x2, 0x2, 0x2, 0x217, + 0x207, 0x3, 0x2, 0x2, 0x2, 0x217, 0x20a, 0x3, 0x2, 0x2, 0x2, 0x217, + 0x20d, 0x3, 0x2, 0x2, 0x2, 0x217, 0x210, 0x3, 0x2, 0x2, 0x2, 0x217, + 0x214, 0x3, 0x2, 0x2, 0x2, 0x218, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x219, + 0x217, 0x3, 0x2, 0x2, 0x2, 0x219, 0x21a, 0x3, 0x2, 0x2, 0x2, 0x21a, + 0x21c, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x219, 0x3, 0x2, 0x2, 0x2, 0x21c, + 0x21f, 0x5, 0x54, 0x2b, 0x2, 0x21d, 0x21e, 0x7, 0x4f, 0x2, 0x2, 0x21e, + 0x220, 0x5, 0x4c, 0x27, 0x2, 0x21f, 0x21d, 0x3, 0x2, 0x2, 0x2, 0x21f, + 0x220, 0x3, 0x2, 0x2, 0x2, 0x220, 0x221, 0x3, 0x2, 0x2, 0x2, 0x221, + 0x222, 0x7, 0x4b, 0x2, 0x2, 0x222, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x223, + 0x225, 0x5, 0x42, 0x22, 0x2, 0x224, 0x226, 0x7, 0x25, 0x2, 0x2, 0x225, + 0x224, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x3, 0x2, 0x2, 0x2, 0x226, + 0x228, 0x3, 0x2, 0x2, 0x2, 0x227, 0x229, 0x5, 0x54, 0x2b, 0x2, 0x228, + 0x227, 0x3, 0x2, 0x2, 0x2, 0x228, 0x229, 0x3, 0x2, 0x2, 0x2, 0x229, + 0x3d, 0x3, 0x2, 0x2, 0x2, 0x22a, 0x22b, 0x7, 0x18, 0x2, 0x2, 0x22b, + 0x22c, 0x5, 0x54, 0x2b, 0x2, 0x22c, 0x235, 0x7, 0x44, 0x2, 0x2, 0x22d, + 0x232, 0x5, 0x3c, 0x1f, 0x2, 0x22e, 0x22f, 0x7, 0x5b, 0x2, 0x2, 0x22f, + 0x231, 0x5, 0x3c, 0x1f, 0x2, 0x230, 0x22e, 0x3, 0x2, 0x2, 0x2, 0x231, + 0x234, 0x3, 0x2, 0x2, 0x2, 0x232, 0x230, 0x3, 0x2, 0x2, 0x2, 0x232, + 0x233, 0x3, 0x2, 0x2, 0x2, 0x233, 0x236, 0x3, 0x2, 0x2, 0x2, 0x234, + 0x232, 0x3, 0x2, 0x2, 0x2, 0x235, 0x22d, 0x3, 0x2, 0x2, 0x2, 0x235, + 0x236, 0x3, 0x2, 0x2, 0x2, 0x236, 0x237, 0x3, 0x2, 0x2, 0x2, 0x237, + 0x239, 0x7, 0x45, 0x2, 0x2, 0x238, 0x23a, 0x7, 0x6, 0x2, 0x2, 0x239, + 0x238, 0x3, 0x2, 0x2, 0x2, 0x239, 0x23a, 0x3, 0x2, 0x2, 0x2, 0x23a, + 0x23b, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x23c, 0x7, 0x4b, 0x2, 0x2, 0x23c, + 0x3f, 0x3, 0x2, 0x2, 0x2, 0x23d, 0x23e, 0x7, 0x40, 0x2, 0x2, 0x23e, + 0x23f, 0x5, 0x1e, 0x10, 0x2, 0x23f, 0x242, 0x7, 0x1f, 0x2, 0x2, 0x240, + 0x243, 0x7, 0x66, 0x2, 0x2, 0x241, 0x243, 0x5, 0x42, 0x22, 0x2, 0x242, + 0x240, 0x3, 0x2, 0x2, 0x2, 0x242, 0x241, 0x3, 0x2, 0x2, 0x2, 0x243, + 0x244, 0x3, 0x2, 0x2, 0x2, 0x244, 0x245, 0x7, 0x4b, 0x2, 0x2, 0x245, + 0x41, 0x3, 0x2, 0x2, 0x2, 0x246, 0x247, 0x8, 0x22, 0x1, 0x2, 0x247, + 0x24c, 0x5, 0x44, 0x23, 0x2, 0x248, 0x24c, 0x5, 0x46, 0x24, 0x2, 0x249, + 0x24c, 0x5, 0x86, 0x44, 0x2, 0x24a, 0x24c, 0x5, 0x1e, 0x10, 0x2, 0x24b, + 0x246, 0x3, 0x2, 0x2, 0x2, 0x24b, 0x248, 0x3, 0x2, 0x2, 0x2, 0x24b, + 0x249, 0x3, 0x2, 0x2, 0x2, 0x24b, 0x24a, 0x3, 0x2, 0x2, 0x2, 0x24c, + 0x255, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x24e, 0xc, 0x3, 0x2, 0x2, 0x24e, + 0x250, 0x7, 0x46, 0x2, 0x2, 0x24f, 0x251, 0x5, 0x4c, 0x27, 0x2, 0x250, + 0x24f, 0x3, 0x2, 0x2, 0x2, 0x250, 0x251, 0x3, 0x2, 0x2, 0x2, 0x251, + 0x252, 0x3, 0x2, 0x2, 0x2, 0x252, 0x254, 0x7, 0x47, 0x2, 0x2, 0x253, + 0x24d, 0x3, 0x2, 0x2, 0x2, 0x254, 0x257, 0x3, 0x2, 0x2, 0x2, 0x255, + 0x253, 0x3, 0x2, 0x2, 0x2, 0x255, 0x256, 0x3, 0x2, 0x2, 0x2, 0x256, + 0x43, 0x3, 0x2, 0x2, 0x2, 0x257, 0x255, 0x3, 0x2, 0x2, 0x2, 0x258, 0x265, + 0x7, 0x7, 0x2, 0x2, 0x259, 0x25a, 0x6, 0x23, 0x16, 0x3, 0x25a, 0x25b, + 0x7, 0x7, 0x2, 0x2, 0x25b, 0x265, 0x7, 0x30, 0x2, 0x2, 0x25c, 0x265, + 0x7, 0xa, 0x2, 0x2, 0x25d, 0x265, 0x7, 0x39, 0x2, 0x2, 0x25e, 0x265, + 0x7, 0xc, 0x2, 0x2, 0x25f, 0x265, 0x7, 0x37, 0x2, 0x2, 0x260, 0x265, + 0x7, 0x3f, 0x2, 0x2, 0x261, 0x265, 0x7, 0x1e, 0x2, 0x2, 0x262, 0x265, + 0x7, 0x1c, 0x2, 0x2, 0x263, 0x265, 0x7, 0x3e, 0x2, 0x2, 0x264, 0x258, + 0x3, 0x2, 0x2, 0x2, 0x264, 0x259, 0x3, 0x2, 0x2, 0x2, 0x264, 0x25c, + 0x3, 0x2, 0x2, 0x2, 0x264, 0x25d, 0x3, 0x2, 0x2, 0x2, 0x264, 0x25e, + 0x3, 0x2, 0x2, 0x2, 0x264, 0x25f, 0x3, 0x2, 0x2, 0x2, 0x264, 0x260, + 0x3, 0x2, 0x2, 0x2, 0x264, 0x261, 0x3, 0x2, 0x2, 0x2, 0x264, 0x262, + 0x3, 0x2, 0x2, 0x2, 0x264, 0x263, 0x3, 0x2, 0x2, 0x2, 0x265, 0x45, 0x3, + 0x2, 0x2, 0x2, 0x266, 0x267, 0x7, 0x20, 0x2, 0x2, 0x267, 0x269, 0x7, + 0x44, 0x2, 0x2, 0x268, 0x26a, 0x5, 0x24, 0x13, 0x2, 0x269, 0x268, 0x3, + 0x2, 0x2, 0x2, 0x269, 0x26a, 0x3, 0x2, 0x2, 0x2, 0x26a, 0x26b, 0x3, + 0x2, 0x2, 0x2, 0x26b, 0x276, 0x7, 0x45, 0x2, 0x2, 0x26c, 0x26d, 0x6, + 0x24, 0x17, 0x3, 0x26d, 0x26e, 0x5, 0x22, 0x12, 0x2, 0x26e, 0x26f, 0x8, + 0x24, 0x1, 0x2, 0x26f, 0x275, 0x3, 0x2, 0x2, 0x2, 0x270, 0x271, 0x6, + 0x24, 0x18, 0x3, 0x271, 0x272, 0x5, 0x2a, 0x16, 0x2, 0x272, 0x273, 0x8, + 0x24, 0x1, 0x2, 0x273, 0x275, 0x3, 0x2, 0x2, 0x2, 0x274, 0x26c, 0x3, + 0x2, 0x2, 0x2, 0x274, 0x270, 0x3, 0x2, 0x2, 0x2, 0x275, 0x278, 0x3, + 0x2, 0x2, 0x2, 0x276, 0x274, 0x3, 0x2, 0x2, 0x2, 0x276, 0x277, 0x3, + 0x2, 0x2, 0x2, 0x277, 0x27e, 0x3, 0x2, 0x2, 0x2, 0x278, 0x276, 0x3, + 0x2, 0x2, 0x2, 0x279, 0x27a, 0x7, 0x36, 0x2, 0x2, 0x27a, 0x27b, 0x7, + 0x44, 0x2, 0x2, 0x27b, 0x27c, 0x5, 0x24, 0x13, 0x2, 0x27c, 0x27d, 0x7, + 0x45, 0x2, 0x2, 0x27d, 0x27f, 0x3, 0x2, 0x2, 0x2, 0x27e, 0x279, 0x3, + 0x2, 0x2, 0x2, 0x27e, 0x27f, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x47, 0x3, 0x2, + 0x2, 0x2, 0x280, 0x282, 0x5, 0x42, 0x22, 0x2, 0x281, 0x283, 0x5, 0x4a, + 0x26, 0x2, 0x282, 0x281, 0x3, 0x2, 0x2, 0x2, 0x282, 0x283, 0x3, 0x2, + 0x2, 0x2, 0x283, 0x284, 0x3, 0x2, 0x2, 0x2, 0x284, 0x285, 0x5, 0x54, + 0x2b, 0x2, 0x285, 0x49, 0x3, 0x2, 0x2, 0x2, 0x286, 0x287, 0x9, 0x5, + 0x2, 0x2, 0x287, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x288, 0x289, 0x8, 0x27, + 0x1, 0x2, 0x289, 0x28a, 0x7, 0x30, 0x2, 0x2, 0x28a, 0x29d, 0x5, 0x1c, + 0xf, 0x2, 0x28b, 0x28c, 0x7, 0x3d, 0x2, 0x2, 0x28c, 0x28d, 0x7, 0x44, + 0x2, 0x2, 0x28d, 0x28e, 0x5, 0x42, 0x22, 0x2, 0x28e, 0x28f, 0x7, 0x45, + 0x2, 0x2, 0x28f, 0x29d, 0x3, 0x2, 0x2, 0x2, 0x290, 0x291, 0x9, 0x6, + 0x2, 0x2, 0x291, 0x29d, 0x5, 0x4c, 0x27, 0x15, 0x292, 0x293, 0x7, 0x2d, + 0x2, 0x2, 0x293, 0x29d, 0x5, 0x42, 0x22, 0x2, 0x294, 0x29d, 0x5, 0x50, + 0x29, 0x2, 0x295, 0x29d, 0x5, 0x52, 0x2a, 0x2, 0x296, 0x29b, 0x5, 0x54, + 0x2b, 0x2, 0x297, 0x29b, 0x5, 0x56, 0x2c, 0x2, 0x298, 0x29b, 0x5, 0x44, + 0x23, 0x2, 0x299, 0x29b, 0x5, 0x1e, 0x10, 0x2, 0x29a, 0x296, 0x3, 0x2, + 0x2, 0x2, 0x29a, 0x297, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x298, 0x3, 0x2, + 0x2, 0x2, 0x29a, 0x299, 0x3, 0x2, 0x2, 0x2, 0x29b, 0x29d, 0x3, 0x2, + 0x2, 0x2, 0x29c, 0x288, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x28b, 0x3, 0x2, + 0x2, 0x2, 0x29c, 0x290, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x292, 0x3, 0x2, + 0x2, 0x2, 0x29c, 0x294, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x295, 0x3, 0x2, + 0x2, 0x2, 0x29c, 0x29a, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x2f2, 0x3, 0x2, + 0x2, 0x2, 0x29e, 0x29f, 0xc, 0x13, 0x2, 0x2, 0x29f, 0x2a0, 0x7, 0x69, + 0x2, 0x2, 0x2a0, 0x2f1, 0x5, 0x4c, 0x27, 0x13, 0x2a1, 0x2a2, 0xc, 0x12, + 0x2, 0x2, 0x2a2, 0x2a3, 0x9, 0x7, 0x2, 0x2, 0x2a3, 0x2f1, 0x5, 0x4c, + 0x27, 0x13, 0x2a4, 0x2a5, 0xc, 0x11, 0x2, 0x2, 0x2a5, 0x2a6, 0x9, 0x8, + 0x2, 0x2, 0x2a6, 0x2f1, 0x5, 0x4c, 0x27, 0x12, 0x2a7, 0x2a8, 0xc, 0x10, + 0x2, 0x2, 0x2a8, 0x2a9, 0x9, 0x9, 0x2, 0x2, 0x2a9, 0x2f1, 0x5, 0x4c, + 0x27, 0x11, 0x2aa, 0x2ab, 0xc, 0xf, 0x2, 0x2, 0x2ab, 0x2ac, 0x7, 0x60, + 0x2, 0x2, 0x2ac, 0x2f1, 0x5, 0x4c, 0x27, 0x10, 0x2ad, 0x2ae, 0xc, 0xe, + 0x2, 0x2, 0x2ae, 0x2af, 0x7, 0x5f, 0x2, 0x2, 0x2af, 0x2f1, 0x5, 0x4c, + 0x27, 0xf, 0x2b0, 0x2b1, 0xc, 0xd, 0x2, 0x2, 0x2b1, 0x2b2, 0x7, 0x5e, + 0x2, 0x2, 0x2b2, 0x2f1, 0x5, 0x4c, 0x27, 0xe, 0x2b3, 0x2b4, 0xc, 0xc, + 0x2, 0x2, 0x2b4, 0x2b5, 0x9, 0xa, 0x2, 0x2, 0x2b5, 0x2f1, 0x5, 0x4c, + 0x27, 0xd, 0x2b6, 0x2b7, 0xc, 0xb, 0x2, 0x2, 0x2b7, 0x2b8, 0x9, 0xb, + 0x2, 0x2, 0x2b8, 0x2f1, 0x5, 0x4c, 0x27, 0xc, 0x2b9, 0x2ba, 0xc, 0xa, + 0x2, 0x2, 0x2ba, 0x2bb, 0x7, 0x5d, 0x2, 0x2, 0x2bb, 0x2f1, 0x5, 0x4c, + 0x27, 0xb, 0x2bc, 0x2bd, 0xc, 0x9, 0x2, 0x2, 0x2bd, 0x2be, 0x7, 0x5c, + 0x2, 0x2, 0x2be, 0x2f1, 0x5, 0x4c, 0x27, 0xa, 0x2bf, 0x2c0, 0xc, 0x8, + 0x2, 0x2, 0x2c0, 0x2c1, 0x7, 0x4d, 0x2, 0x2, 0x2c1, 0x2c2, 0x5, 0x4c, + 0x27, 0x2, 0x2c2, 0x2c3, 0x7, 0x4a, 0x2, 0x2, 0x2c3, 0x2c4, 0x5, 0x4c, + 0x27, 0x8, 0x2c4, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2c5, 0x2c6, 0xc, 0x7, + 0x2, 0x2, 0x2c6, 0x2c7, 0x5, 0x4e, 0x28, 0x2, 0x2c7, 0x2c8, 0x5, 0x4c, + 0x27, 0x7, 0x2c8, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2c9, 0x2ca, 0xc, 0x1c, + 0x2, 0x2, 0x2ca, 0x2cc, 0x7, 0x46, 0x2, 0x2, 0x2cb, 0x2cd, 0x5, 0x4c, + 0x27, 0x2, 0x2cc, 0x2cb, 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2cd, 0x3, 0x2, + 0x2, 0x2, 0x2cd, 0x2ce, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2f1, 0x7, 0x47, + 0x2, 0x2, 0x2cf, 0x2d0, 0xc, 0x1b, 0x2, 0x2, 0x2d0, 0x2d2, 0x7, 0x46, + 0x2, 0x2, 0x2d1, 0x2d3, 0x5, 0x4c, 0x27, 0x2, 0x2d2, 0x2d1, 0x3, 0x2, + 0x2, 0x2, 0x2d2, 0x2d3, 0x3, 0x2, 0x2, 0x2, 0x2d3, 0x2d4, 0x3, 0x2, + 0x2, 0x2, 0x2d4, 0x2d6, 0x7, 0x4a, 0x2, 0x2, 0x2d5, 0x2d7, 0x5, 0x4c, + 0x27, 0x2, 0x2d6, 0x2d5, 0x3, 0x2, 0x2, 0x2, 0x2d6, 0x2d7, 0x3, 0x2, + 0x2, 0x2, 0x2d7, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2f1, 0x7, 0x47, + 0x2, 0x2, 0x2d9, 0x2da, 0xc, 0x1a, 0x2, 0x2, 0x2da, 0x2dd, 0x7, 0x4c, + 0x2, 0x2, 0x2db, 0x2de, 0x5, 0x54, 0x2b, 0x2, 0x2dc, 0x2de, 0x7, 0x7, + 0x2, 0x2, 0x2dd, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x2dd, 0x2dc, 0x3, 0x2, + 0x2, 0x2, 0x2de, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2df, 0x2e0, 0xc, 0x19, + 0x2, 0x2, 0x2e0, 0x2e9, 0x7, 0x48, 0x2, 0x2, 0x2e1, 0x2e6, 0x5, 0x1a, + 0xe, 0x2, 0x2e2, 0x2e3, 0x7, 0x5b, 0x2, 0x2, 0x2e3, 0x2e5, 0x5, 0x1a, + 0xe, 0x2, 0x2e4, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2e5, 0x2e8, 0x3, 0x2, + 0x2, 0x2, 0x2e6, 0x2e4, 0x3, 0x2, 0x2, 0x2, 0x2e6, 0x2e7, 0x3, 0x2, + 0x2, 0x2, 0x2e7, 0x2ea, 0x3, 0x2, 0x2, 0x2, 0x2e8, 0x2e6, 0x3, 0x2, + 0x2, 0x2, 0x2e9, 0x2e1, 0x3, 0x2, 0x2, 0x2, 0x2e9, 0x2ea, 0x3, 0x2, + 0x2, 0x2, 0x2ea, 0x2eb, 0x3, 0x2, 0x2, 0x2, 0x2eb, 0x2f1, 0x7, 0x49, + 0x2, 0x2, 0x2ec, 0x2ed, 0xc, 0x18, 0x2, 0x2, 0x2ed, 0x2f1, 0x5, 0x1c, + 0xf, 0x2, 0x2ee, 0x2ef, 0xc, 0x14, 0x2, 0x2, 0x2ef, 0x2f1, 0x9, 0xc, + 0x2, 0x2, 0x2f0, 0x29e, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2a1, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2a4, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2a7, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2aa, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2ad, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2b3, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2b6, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2b9, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2bc, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2bf, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2c5, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2c9, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2d9, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2df, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2ec, 0x3, 0x2, + 0x2, 0x2, 0x2f0, 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f4, 0x3, 0x2, + 0x2, 0x2, 0x2f2, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f2, 0x2f3, 0x3, 0x2, + 0x2, 0x2, 0x2f3, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x2f2, 0x3, 0x2, 0x2, + 0x2, 0x2f5, 0x2f6, 0x9, 0xd, 0x2, 0x2, 0x2f6, 0x4f, 0x3, 0x2, 0x2, 0x2, + 0x2f7, 0x2f9, 0x7, 0x44, 0x2, 0x2, 0x2f8, 0x2fa, 0x5, 0x4c, 0x27, 0x2, + 0x2f9, 0x2f8, 0x3, 0x2, 0x2, 0x2, 0x2f9, 0x2fa, 0x3, 0x2, 0x2, 0x2, + 0x2fa, 0x301, 0x3, 0x2, 0x2, 0x2, 0x2fb, 0x2fd, 0x7, 0x5b, 0x2, 0x2, + 0x2fc, 0x2fe, 0x5, 0x4c, 0x27, 0x2, 0x2fd, 0x2fc, 0x3, 0x2, 0x2, 0x2, + 0x2fd, 0x2fe, 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x300, 0x3, 0x2, 0x2, 0x2, + 0x2ff, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x300, 0x303, 0x3, 0x2, 0x2, 0x2, + 0x301, 0x2ff, 0x3, 0x2, 0x2, 0x2, 0x301, 0x302, 0x3, 0x2, 0x2, 0x2, + 0x302, 0x304, 0x3, 0x2, 0x2, 0x2, 0x303, 0x301, 0x3, 0x2, 0x2, 0x2, + 0x304, 0x305, 0x7, 0x45, 0x2, 0x2, 0x305, 0x51, 0x3, 0x2, 0x2, 0x2, + 0x306, 0x307, 0x7, 0x46, 0x2, 0x2, 0x307, 0x30c, 0x5, 0x4c, 0x27, 0x2, + 0x308, 0x309, 0x7, 0x5b, 0x2, 0x2, 0x309, 0x30b, 0x5, 0x4c, 0x27, 0x2, + 0x30a, 0x308, 0x3, 0x2, 0x2, 0x2, 0x30b, 0x30e, 0x3, 0x2, 0x2, 0x2, + 0x30c, 0x30a, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x30d, 0x3, 0x2, 0x2, 0x2, + 0x30d, 0x30f, 0x3, 0x2, 0x2, 0x2, 0x30e, 0x30c, 0x3, 0x2, 0x2, 0x2, + 0x30f, 0x310, 0x7, 0x47, 0x2, 0x2, 0x310, 0x53, 0x3, 0x2, 0x2, 0x2, + 0x311, 0x312, 0x9, 0xe, 0x2, 0x2, 0x312, 0x55, 0x3, 0x2, 0x2, 0x2, 0x313, + 0x319, 0x5, 0x5a, 0x2e, 0x2, 0x314, 0x319, 0x5, 0x60, 0x31, 0x2, 0x315, + 0x319, 0x5, 0x58, 0x2d, 0x2, 0x316, 0x319, 0x5, 0x5c, 0x2f, 0x2, 0x317, + 0x319, 0x5, 0x5e, 0x30, 0x2, 0x318, 0x313, 0x3, 0x2, 0x2, 0x2, 0x318, + 0x314, 0x3, 0x2, 0x2, 0x2, 0x318, 0x315, 0x3, 0x2, 0x2, 0x2, 0x318, + 0x316, 0x3, 0x2, 0x2, 0x2, 0x318, 0x317, 0x3, 0x2, 0x2, 0x2, 0x319, + 0x57, 0x3, 0x2, 0x2, 0x2, 0x31a, 0x31b, 0x9, 0xf, 0x2, 0x2, 0x31b, 0x59, + 0x3, 0x2, 0x2, 0x2, 0x31c, 0x31e, 0x7, 0x74, 0x2, 0x2, 0x31d, 0x31c, + 0x3, 0x2, 0x2, 0x2, 0x31e, 0x31f, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x31d, + 0x3, 0x2, 0x2, 0x2, 0x31f, 0x320, 0x3, 0x2, 0x2, 0x2, 0x320, 0x5b, 0x3, + 0x2, 0x2, 0x2, 0x321, 0x323, 0x7, 0x77, 0x2, 0x2, 0x322, 0x321, 0x3, + 0x2, 0x2, 0x2, 0x323, 0x324, 0x3, 0x2, 0x2, 0x2, 0x324, 0x322, 0x3, + 0x2, 0x2, 0x2, 0x324, 0x325, 0x3, 0x2, 0x2, 0x2, 0x325, 0x5d, 0x3, 0x2, + 0x2, 0x2, 0x326, 0x328, 0x7, 0x76, 0x2, 0x2, 0x327, 0x326, 0x3, 0x2, + 0x2, 0x2, 0x328, 0x329, 0x3, 0x2, 0x2, 0x2, 0x329, 0x327, 0x3, 0x2, + 0x2, 0x2, 0x329, 0x32a, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x5f, 0x3, 0x2, 0x2, + 0x2, 0x32b, 0x32d, 0x9, 0x10, 0x2, 0x2, 0x32c, 0x32e, 0x7, 0x2e, 0x2, + 0x2, 0x32d, 0x32c, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32e, 0x3, 0x2, 0x2, + 0x2, 0x32e, 0x61, 0x3, 0x2, 0x2, 0x2, 0x32f, 0x333, 0x7, 0x48, 0x2, + 0x2, 0x330, 0x332, 0x5, 0x64, 0x33, 0x2, 0x331, 0x330, 0x3, 0x2, 0x2, + 0x2, 0x332, 0x335, 0x3, 0x2, 0x2, 0x2, 0x333, 0x331, 0x3, 0x2, 0x2, + 0x2, 0x333, 0x334, 0x3, 0x2, 0x2, 0x2, 0x334, 0x336, 0x3, 0x2, 0x2, + 0x2, 0x335, 0x333, 0x3, 0x2, 0x2, 0x2, 0x336, 0x337, 0x7, 0x49, 0x2, + 0x2, 0x337, 0x63, 0x3, 0x2, 0x2, 0x2, 0x338, 0x345, 0x5, 0x62, 0x32, + 0x2, 0x339, 0x345, 0x5, 0x66, 0x34, 0x2, 0x33a, 0x345, 0x5, 0x68, 0x35, + 0x2, 0x33b, 0x345, 0x5, 0x6a, 0x36, 0x2, 0x33c, 0x345, 0x5, 0x6c, 0x37, + 0x2, 0x33d, 0x345, 0x5, 0x6e, 0x38, 0x2, 0x33e, 0x345, 0x5, 0x70, 0x39, + 0x2, 0x33f, 0x345, 0x5, 0x72, 0x3a, 0x2, 0x340, 0x345, 0x5, 0x74, 0x3b, + 0x2, 0x341, 0x345, 0x5, 0x78, 0x3d, 0x2, 0x342, 0x345, 0x5, 0x7a, 0x3e, + 0x2, 0x343, 0x345, 0x5, 0x7c, 0x3f, 0x2, 0x344, 0x338, 0x3, 0x2, 0x2, + 0x2, 0x344, 0x339, 0x3, 0x2, 0x2, 0x2, 0x344, 0x33a, 0x3, 0x2, 0x2, + 0x2, 0x344, 0x33b, 0x3, 0x2, 0x2, 0x2, 0x344, 0x33c, 0x3, 0x2, 0x2, + 0x2, 0x344, 0x33d, 0x3, 0x2, 0x2, 0x2, 0x344, 0x33e, 0x3, 0x2, 0x2, + 0x2, 0x344, 0x33f, 0x3, 0x2, 0x2, 0x2, 0x344, 0x340, 0x3, 0x2, 0x2, + 0x2, 0x344, 0x341, 0x3, 0x2, 0x2, 0x2, 0x344, 0x342, 0x3, 0x2, 0x2, + 0x2, 0x344, 0x343, 0x3, 0x2, 0x2, 0x2, 0x345, 0x65, 0x3, 0x2, 0x2, 0x2, + 0x346, 0x349, 0x5, 0x82, 0x42, 0x2, 0x347, 0x349, 0x5, 0x84, 0x43, 0x2, + 0x348, 0x346, 0x3, 0x2, 0x2, 0x2, 0x348, 0x347, 0x3, 0x2, 0x2, 0x2, + 0x349, 0x67, 0x3, 0x2, 0x2, 0x2, 0x34a, 0x34b, 0x7, 0x22, 0x2, 0x2, + 0x34b, 0x34c, 0x7, 0x44, 0x2, 0x2, 0x34c, 0x34d, 0x5, 0x4c, 0x27, 0x2, + 0x34d, 0x34e, 0x7, 0x45, 0x2, 0x2, 0x34e, 0x351, 0x5, 0x64, 0x33, 0x2, + 0x34f, 0x350, 0x7, 0x15, 0x2, 0x2, 0x350, 0x352, 0x5, 0x64, 0x33, 0x2, + 0x351, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x351, 0x352, 0x3, 0x2, 0x2, 0x2, + 0x352, 0x69, 0x3, 0x2, 0x2, 0x2, 0x353, 0x354, 0x7, 0x1f, 0x2, 0x2, + 0x354, 0x357, 0x7, 0x44, 0x2, 0x2, 0x355, 0x358, 0x5, 0x66, 0x34, 0x2, + 0x356, 0x358, 0x7, 0x4b, 0x2, 0x2, 0x357, 0x355, 0x3, 0x2, 0x2, 0x2, + 0x357, 0x356, 0x3, 0x2, 0x2, 0x2, 0x358, 0x35b, 0x3, 0x2, 0x2, 0x2, + 0x359, 0x35c, 0x5, 0x84, 0x43, 0x2, 0x35a, 0x35c, 0x7, 0x4b, 0x2, 0x2, + 0x35b, 0x359, 0x3, 0x2, 0x2, 0x2, 0x35b, 0x35a, 0x3, 0x2, 0x2, 0x2, + 0x35c, 0x35e, 0x3, 0x2, 0x2, 0x2, 0x35d, 0x35f, 0x5, 0x4c, 0x27, 0x2, + 0x35e, 0x35d, 0x3, 0x2, 0x2, 0x2, 0x35e, 0x35f, 0x3, 0x2, 0x2, 0x2, + 0x35f, 0x360, 0x3, 0x2, 0x2, 0x2, 0x360, 0x361, 0x7, 0x45, 0x2, 0x2, + 0x361, 0x362, 0x5, 0x64, 0x33, 0x2, 0x362, 0x6b, 0x3, 0x2, 0x2, 0x2, + 0x363, 0x364, 0x7, 0x43, 0x2, 0x2, 0x364, 0x365, 0x7, 0x44, 0x2, 0x2, + 0x365, 0x366, 0x5, 0x4c, 0x27, 0x2, 0x366, 0x367, 0x7, 0x45, 0x2, 0x2, + 0x367, 0x368, 0x5, 0x64, 0x33, 0x2, 0x368, 0x6d, 0x3, 0x2, 0x2, 0x2, + 0x369, 0x36a, 0x7, 0x14, 0x2, 0x2, 0x36a, 0x36b, 0x5, 0x64, 0x33, 0x2, + 0x36b, 0x36c, 0x7, 0x43, 0x2, 0x2, 0x36c, 0x36d, 0x7, 0x44, 0x2, 0x2, + 0x36d, 0x36e, 0x5, 0x4c, 0x27, 0x2, 0x36e, 0x36f, 0x7, 0x45, 0x2, 0x2, + 0x36f, 0x370, 0x7, 0x4b, 0x2, 0x2, 0x370, 0x6f, 0x3, 0x2, 0x2, 0x2, + 0x371, 0x372, 0x7, 0x11, 0x2, 0x2, 0x372, 0x373, 0x7, 0x4b, 0x2, 0x2, + 0x373, 0x71, 0x3, 0x2, 0x2, 0x2, 0x374, 0x375, 0x7, 0xb, 0x2, 0x2, 0x375, + 0x376, 0x7, 0x4b, 0x2, 0x2, 0x376, 0x73, 0x3, 0x2, 0x2, 0x2, 0x377, + 0x378, 0x7, 0x3c, 0x2, 0x2, 0x378, 0x37e, 0x5, 0x4c, 0x27, 0x2, 0x379, + 0x37a, 0x7, 0x36, 0x2, 0x2, 0x37a, 0x37b, 0x7, 0x44, 0x2, 0x2, 0x37b, + 0x37c, 0x5, 0x24, 0x13, 0x2, 0x37c, 0x37d, 0x7, 0x45, 0x2, 0x2, 0x37d, + 0x37f, 0x3, 0x2, 0x2, 0x2, 0x37e, 0x379, 0x3, 0x2, 0x2, 0x2, 0x37e, + 0x37f, 0x3, 0x2, 0x2, 0x2, 0x37f, 0x380, 0x3, 0x2, 0x2, 0x2, 0x380, + 0x382, 0x5, 0x62, 0x32, 0x2, 0x381, 0x383, 0x5, 0x76, 0x3c, 0x2, 0x382, + 0x381, 0x3, 0x2, 0x2, 0x2, 0x383, 0x384, 0x3, 0x2, 0x2, 0x2, 0x384, + 0x382, 0x3, 0x2, 0x2, 0x2, 0x384, 0x385, 0x3, 0x2, 0x2, 0x2, 0x385, + 0x75, 0x3, 0x2, 0x2, 0x2, 0x386, 0x38e, 0x7, 0xe, 0x2, 0x2, 0x387, 0x389, + 0x5, 0x54, 0x2b, 0x2, 0x388, 0x387, 0x3, 0x2, 0x2, 0x2, 0x388, 0x389, + 0x3, 0x2, 0x2, 0x2, 0x389, 0x38a, 0x3, 0x2, 0x2, 0x2, 0x38a, 0x38b, + 0x7, 0x44, 0x2, 0x2, 0x38b, 0x38c, 0x5, 0x24, 0x13, 0x2, 0x38c, 0x38d, + 0x7, 0x45, 0x2, 0x2, 0x38d, 0x38f, 0x3, 0x2, 0x2, 0x2, 0x38e, 0x388, + 0x3, 0x2, 0x2, 0x2, 0x38e, 0x38f, 0x3, 0x2, 0x2, 0x2, 0x38f, 0x390, + 0x3, 0x2, 0x2, 0x2, 0x390, 0x391, 0x5, 0x62, 0x32, 0x2, 0x391, 0x77, + 0x3, 0x2, 0x2, 0x2, 0x392, 0x394, 0x7, 0x35, 0x2, 0x2, 0x393, 0x395, + 0x5, 0x4c, 0x27, 0x2, 0x394, 0x393, 0x3, 0x2, 0x2, 0x2, 0x394, 0x395, + 0x3, 0x2, 0x2, 0x2, 0x395, 0x396, 0x3, 0x2, 0x2, 0x2, 0x396, 0x397, + 0x7, 0x4b, 0x2, 0x2, 0x397, 0x79, 0x3, 0x2, 0x2, 0x2, 0x398, 0x399, + 0x7, 0x16, 0x2, 0x2, 0x399, 0x39a, 0x5, 0x4c, 0x27, 0x2, 0x39a, 0x39b, + 0x5, 0x1c, 0xf, 0x2, 0x39b, 0x39c, 0x7, 0x4b, 0x2, 0x2, 0x39c, 0x7b, + 0x3, 0x2, 0x2, 0x2, 0x39d, 0x39f, 0x7, 0x9, 0x2, 0x2, 0x39e, 0x3a0, + 0x7, 0x7e, 0x2, 0x2, 0x39f, 0x39e, 0x3, 0x2, 0x2, 0x2, 0x39f, 0x3a0, + 0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x3, 0x2, 0x2, 0x2, 0x3a1, 0x3a5, + 0x7, 0x7f, 0x2, 0x2, 0x3a2, 0x3a4, 0x5, 0x8a, 0x46, 0x2, 0x3a3, 0x3a2, + 0x3, 0x2, 0x2, 0x2, 0x3a4, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x3a5, 0x3a3, + 0x3, 0x2, 0x2, 0x2, 0x3a5, 0x3a6, 0x3, 0x2, 0x2, 0x2, 0x3a6, 0x3a8, + 0x3, 0x2, 0x2, 0x2, 0x3a7, 0x3a5, 0x3, 0x2, 0x2, 0x2, 0x3a8, 0x3a9, + 0x7, 0x91, 0x2, 0x2, 0x3a9, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x3aa, 0x3af, + 0x5, 0x48, 0x25, 0x2, 0x3ab, 0x3ac, 0x7, 0x5b, 0x2, 0x2, 0x3ac, 0x3ae, + 0x5, 0x48, 0x25, 0x2, 0x3ad, 0x3ab, 0x3, 0x2, 0x2, 0x2, 0x3ae, 0x3b1, + 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3ad, 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3b0, + 0x3, 0x2, 0x2, 0x2, 0x3b0, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x3b1, 0x3af, 0x3, + 0x2, 0x2, 0x2, 0x3b2, 0x3b6, 0x7, 0x44, 0x2, 0x2, 0x3b3, 0x3b5, 0x7, + 0x5b, 0x2, 0x2, 0x3b4, 0x3b3, 0x3, 0x2, 0x2, 0x2, 0x3b5, 0x3b8, 0x3, + 0x2, 0x2, 0x2, 0x3b6, 0x3b4, 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b7, 0x3, + 0x2, 0x2, 0x2, 0x3b7, 0x3b9, 0x3, 0x2, 0x2, 0x2, 0x3b8, 0x3b6, 0x3, + 0x2, 0x2, 0x2, 0x3b9, 0x3ba, 0x5, 0x48, 0x25, 0x2, 0x3ba, 0x3c1, 0x3, + 0x2, 0x2, 0x2, 0x3bb, 0x3bd, 0x7, 0x5b, 0x2, 0x2, 0x3bc, 0x3be, 0x5, + 0x48, 0x25, 0x2, 0x3bd, 0x3bc, 0x3, 0x2, 0x2, 0x2, 0x3bd, 0x3be, 0x3, + 0x2, 0x2, 0x2, 0x3be, 0x3c0, 0x3, 0x2, 0x2, 0x2, 0x3bf, 0x3bb, 0x3, + 0x2, 0x2, 0x2, 0x3c0, 0x3c3, 0x3, 0x2, 0x2, 0x2, 0x3c1, 0x3bf, 0x3, + 0x2, 0x2, 0x2, 0x3c1, 0x3c2, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c4, 0x3, + 0x2, 0x2, 0x2, 0x3c3, 0x3c1, 0x3, 0x2, 0x2, 0x2, 0x3c4, 0x3c5, 0x7, + 0x45, 0x2, 0x2, 0x3c5, 0x81, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3c9, 0x5, + 0x48, 0x25, 0x2, 0x3c7, 0x3c8, 0x7, 0x4f, 0x2, 0x2, 0x3c8, 0x3ca, 0x5, + 0x4c, 0x27, 0x2, 0x3c9, 0x3c7, 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3ca, 0x3, + 0x2, 0x2, 0x2, 0x3ca, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0x3cb, 0x3cc, 0x5, + 0x80, 0x41, 0x2, 0x3cc, 0x3cd, 0x7, 0x4f, 0x2, 0x2, 0x3cd, 0x3ce, 0x5, + 0x4c, 0x27, 0x2, 0x3ce, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0x3cf, 0x3c6, 0x3, + 0x2, 0x2, 0x2, 0x3cf, 0x3cb, 0x3, 0x2, 0x2, 0x2, 0x3d0, 0x3d1, 0x3, + 0x2, 0x2, 0x2, 0x3d1, 0x3d2, 0x7, 0x4b, 0x2, 0x2, 0x3d2, 0x83, 0x3, + 0x2, 0x2, 0x2, 0x3d3, 0x3d4, 0x5, 0x4c, 0x27, 0x2, 0x3d4, 0x3d5, 0x7, + 0x4b, 0x2, 0x2, 0x3d5, 0x85, 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d7, 0x7, + 0x2a, 0x2, 0x2, 0x3d7, 0x3d8, 0x7, 0x44, 0x2, 0x2, 0x3d8, 0x3d9, 0x5, + 0x88, 0x45, 0x2, 0x3d9, 0x3da, 0x7, 0x4e, 0x2, 0x2, 0x3da, 0x3db, 0x5, + 0x42, 0x22, 0x2, 0x3db, 0x3dc, 0x7, 0x45, 0x2, 0x2, 0x3dc, 0x87, 0x3, + 0x2, 0x2, 0x2, 0x3dd, 0x3e0, 0x5, 0x44, 0x23, 0x2, 0x3de, 0x3e0, 0x5, + 0x1e, 0x10, 0x2, 0x3df, 0x3dd, 0x3, 0x2, 0x2, 0x2, 0x3df, 0x3de, 0x3, + 0x2, 0x2, 0x2, 0x3e0, 0x89, 0x3, 0x2, 0x2, 0x2, 0x3e1, 0x3ed, 0x5, 0x8c, + 0x47, 0x2, 0x3e2, 0x3ed, 0x5, 0x8e, 0x48, 0x2, 0x3e3, 0x3ed, 0x5, 0x90, + 0x49, 0x2, 0x3e4, 0x3ed, 0x5, 0x9e, 0x50, 0x2, 0x3e5, 0x3ed, 0x5, 0x92, + 0x4a, 0x2, 0x3e6, 0x3ed, 0x5, 0x94, 0x4b, 0x2, 0x3e7, 0x3ed, 0x5, 0x98, + 0x4d, 0x2, 0x3e8, 0x3ed, 0x7, 0x8b, 0x2, 0x2, 0x3e9, 0x3ed, 0x7, 0x83, + 0x2, 0x2, 0x3ea, 0x3ed, 0x7, 0x85, 0x2, 0x2, 0x3eb, 0x3ed, 0x5, 0x9a, + 0x4e, 0x2, 0x3ec, 0x3e1, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e2, 0x3, 0x2, + 0x2, 0x2, 0x3ec, 0x3e3, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e4, 0x3, 0x2, + 0x2, 0x2, 0x3ec, 0x3e5, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e6, 0x3, 0x2, + 0x2, 0x2, 0x3ec, 0x3e7, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e8, 0x3, 0x2, + 0x2, 0x2, 0x3ec, 0x3e9, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3ea, 0x3, 0x2, + 0x2, 0x2, 0x3ec, 0x3eb, 0x3, 0x2, 0x2, 0x2, 0x3ed, 0x8b, 0x3, 0x2, 0x2, + 0x2, 0x3ee, 0x3f2, 0x7, 0x90, 0x2, 0x2, 0x3ef, 0x3f1, 0x5, 0x8a, 0x46, + 0x2, 0x3f0, 0x3ef, 0x3, 0x2, 0x2, 0x2, 0x3f1, 0x3f4, 0x3, 0x2, 0x2, + 0x2, 0x3f2, 0x3f0, 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f3, 0x3, 0x2, 0x2, + 0x2, 0x3f3, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0x3f4, 0x3f2, 0x3, 0x2, 0x2, + 0x2, 0x3f5, 0x3f6, 0x7, 0x91, 0x2, 0x2, 0x3f6, 0x8d, 0x3, 0x2, 0x2, + 0x2, 0x3f7, 0x3f8, 0x7, 0x8c, 0x2, 0x2, 0x3f8, 0x3fb, 0x7, 0x98, 0x2, + 0x2, 0x3f9, 0x3fa, 0x7, 0x94, 0x2, 0x2, 0x3fa, 0x3fc, 0x5, 0xa4, 0x53, + 0x2, 0x3fb, 0x3f9, 0x3, 0x2, 0x2, 0x2, 0x3fb, 0x3fc, 0x3, 0x2, 0x2, + 0x2, 0x3fc, 0x40b, 0x3, 0x2, 0x2, 0x2, 0x3fd, 0x3fe, 0x7, 0x8c, 0x2, + 0x2, 0x3fe, 0x403, 0x7, 0x98, 0x2, 0x2, 0x3ff, 0x400, 0x7, 0x96, 0x2, + 0x2, 0x400, 0x402, 0x7, 0x98, 0x2, 0x2, 0x401, 0x3ff, 0x3, 0x2, 0x2, + 0x2, 0x402, 0x405, 0x3, 0x2, 0x2, 0x2, 0x403, 0x401, 0x3, 0x2, 0x2, + 0x2, 0x403, 0x404, 0x3, 0x2, 0x2, 0x2, 0x404, 0x408, 0x3, 0x2, 0x2, + 0x2, 0x405, 0x403, 0x3, 0x2, 0x2, 0x2, 0x406, 0x407, 0x7, 0x94, 0x2, + 0x2, 0x407, 0x409, 0x5, 0x9e, 0x50, 0x2, 0x408, 0x406, 0x3, 0x2, 0x2, + 0x2, 0x408, 0x409, 0x3, 0x2, 0x2, 0x2, 0x409, 0x40b, 0x3, 0x2, 0x2, + 0x2, 0x40a, 0x3f7, 0x3, 0x2, 0x2, 0x2, 0x40a, 0x3fd, 0x3, 0x2, 0x2, + 0x2, 0x40b, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x40c, 0x40d, 0x5, 0x9c, 0x4f, + 0x2, 0x40d, 0x40e, 0x7, 0x94, 0x2, 0x2, 0x40e, 0x40f, 0x5, 0xa4, 0x53, + 0x2, 0x40f, 0x41b, 0x3, 0x2, 0x2, 0x2, 0x410, 0x413, 0x5, 0x9c, 0x4f, + 0x2, 0x411, 0x412, 0x7, 0x96, 0x2, 0x2, 0x412, 0x414, 0x5, 0x9c, 0x4f, + 0x2, 0x413, 0x411, 0x3, 0x2, 0x2, 0x2, 0x414, 0x415, 0x3, 0x2, 0x2, + 0x2, 0x415, 0x413, 0x3, 0x2, 0x2, 0x2, 0x415, 0x416, 0x3, 0x2, 0x2, + 0x2, 0x416, 0x417, 0x3, 0x2, 0x2, 0x2, 0x417, 0x418, 0x7, 0x94, 0x2, + 0x2, 0x418, 0x419, 0x5, 0x9e, 0x50, 0x2, 0x419, 0x41b, 0x3, 0x2, 0x2, + 0x2, 0x41a, 0x40c, 0x3, 0x2, 0x2, 0x2, 0x41a, 0x410, 0x3, 0x2, 0x2, + 0x2, 0x41b, 0x91, 0x3, 0x2, 0x2, 0x2, 0x41c, 0x41d, 0x7, 0x8a, 0x2, + 0x2, 0x41d, 0x41e, 0x5, 0xa4, 0x53, 0x2, 0x41e, 0x41f, 0x5, 0x8c, 0x47, + 0x2, 0x41f, 0x93, 0x3, 0x2, 0x2, 0x2, 0x420, 0x421, 0x7, 0x88, 0x2, + 0x2, 0x421, 0x422, 0x5, 0x8c, 0x47, 0x2, 0x422, 0x423, 0x5, 0xa4, 0x53, + 0x2, 0x423, 0x424, 0x5, 0x8c, 0x47, 0x2, 0x424, 0x425, 0x5, 0x8c, 0x47, + 0x2, 0x425, 0x95, 0x3, 0x2, 0x2, 0x2, 0x426, 0x427, 0x7, 0x84, 0x2, + 0x2, 0x427, 0x428, 0x5, 0xa2, 0x52, 0x2, 0x428, 0x429, 0x5, 0x8c, 0x47, + 0x2, 0x429, 0x97, 0x3, 0x2, 0x2, 0x2, 0x42a, 0x42b, 0x7, 0x8d, 0x2, + 0x2, 0x42b, 0x437, 0x5, 0xa4, 0x53, 0x2, 0x42c, 0x42e, 0x5, 0x96, 0x4c, + 0x2, 0x42d, 0x42c, 0x3, 0x2, 0x2, 0x2, 0x42e, 0x42f, 0x3, 0x2, 0x2, + 0x2, 0x42f, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x42f, 0x430, 0x3, 0x2, 0x2, + 0x2, 0x430, 0x433, 0x3, 0x2, 0x2, 0x2, 0x431, 0x432, 0x7, 0x86, 0x2, + 0x2, 0x432, 0x434, 0x5, 0x8c, 0x47, 0x2, 0x433, 0x431, 0x3, 0x2, 0x2, + 0x2, 0x433, 0x434, 0x3, 0x2, 0x2, 0x2, 0x434, 0x438, 0x3, 0x2, 0x2, + 0x2, 0x435, 0x436, 0x7, 0x86, 0x2, 0x2, 0x436, 0x438, 0x5, 0x8c, 0x47, + 0x2, 0x437, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x437, 0x435, 0x3, 0x2, 0x2, + 0x2, 0x438, 0x99, 0x3, 0x2, 0x2, 0x2, 0x439, 0x43a, 0x7, 0x89, 0x2, + 0x2, 0x43a, 0x43b, 0x7, 0x98, 0x2, 0x2, 0x43b, 0x444, 0x7, 0x92, 0x2, + 0x2, 0x43c, 0x441, 0x7, 0x98, 0x2, 0x2, 0x43d, 0x43e, 0x7, 0x96, 0x2, + 0x2, 0x43e, 0x440, 0x7, 0x98, 0x2, 0x2, 0x43f, 0x43d, 0x3, 0x2, 0x2, + 0x2, 0x440, 0x443, 0x3, 0x2, 0x2, 0x2, 0x441, 0x43f, 0x3, 0x2, 0x2, + 0x2, 0x441, 0x442, 0x3, 0x2, 0x2, 0x2, 0x442, 0x445, 0x3, 0x2, 0x2, + 0x2, 0x443, 0x441, 0x3, 0x2, 0x2, 0x2, 0x444, 0x43c, 0x3, 0x2, 0x2, + 0x2, 0x444, 0x445, 0x3, 0x2, 0x2, 0x2, 0x445, 0x446, 0x3, 0x2, 0x2, + 0x2, 0x446, 0x450, 0x7, 0x93, 0x2, 0x2, 0x447, 0x448, 0x7, 0x97, 0x2, + 0x2, 0x448, 0x44d, 0x7, 0x98, 0x2, 0x2, 0x449, 0x44a, 0x7, 0x96, 0x2, + 0x2, 0x44a, 0x44c, 0x7, 0x98, 0x2, 0x2, 0x44b, 0x449, 0x3, 0x2, 0x2, + 0x2, 0x44c, 0x44f, 0x3, 0x2, 0x2, 0x2, 0x44d, 0x44b, 0x3, 0x2, 0x2, + 0x2, 0x44d, 0x44e, 0x3, 0x2, 0x2, 0x2, 0x44e, 0x451, 0x3, 0x2, 0x2, + 0x2, 0x44f, 0x44d, 0x3, 0x2, 0x2, 0x2, 0x450, 0x447, 0x3, 0x2, 0x2, + 0x2, 0x450, 0x451, 0x3, 0x2, 0x2, 0x2, 0x451, 0x452, 0x3, 0x2, 0x2, + 0x2, 0x452, 0x453, 0x5, 0x8c, 0x47, 0x2, 0x453, 0x9b, 0x3, 0x2, 0x2, + 0x2, 0x454, 0x459, 0x7, 0x98, 0x2, 0x2, 0x455, 0x456, 0x7, 0x95, 0x2, + 0x2, 0x456, 0x458, 0x7, 0x98, 0x2, 0x2, 0x457, 0x455, 0x3, 0x2, 0x2, + 0x2, 0x458, 0x45b, 0x3, 0x2, 0x2, 0x2, 0x459, 0x457, 0x3, 0x2, 0x2, + 0x2, 0x459, 0x45a, 0x3, 0x2, 0x2, 0x2, 0x45a, 0x9d, 0x3, 0x2, 0x2, 0x2, + 0x45b, 0x459, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x45d, 0x9, 0x11, 0x2, 0x2, + 0x45d, 0x466, 0x7, 0x92, 0x2, 0x2, 0x45e, 0x463, 0x5, 0xa4, 0x53, 0x2, + 0x45f, 0x460, 0x7, 0x96, 0x2, 0x2, 0x460, 0x462, 0x5, 0xa4, 0x53, 0x2, + 0x461, 0x45f, 0x3, 0x2, 0x2, 0x2, 0x462, 0x465, 0x3, 0x2, 0x2, 0x2, + 0x463, 0x461, 0x3, 0x2, 0x2, 0x2, 0x463, 0x464, 0x3, 0x2, 0x2, 0x2, + 0x464, 0x467, 0x3, 0x2, 0x2, 0x2, 0x465, 0x463, 0x3, 0x2, 0x2, 0x2, + 0x466, 0x45e, 0x3, 0x2, 0x2, 0x2, 0x466, 0x467, 0x3, 0x2, 0x2, 0x2, + 0x467, 0x468, 0x3, 0x2, 0x2, 0x2, 0x468, 0x469, 0x7, 0x93, 0x2, 0x2, + 0x469, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x46a, 0x46b, 0x9, 0x12, 0x2, 0x2, + 0x46b, 0xa1, 0x3, 0x2, 0x2, 0x2, 0x46c, 0x471, 0x7, 0x9a, 0x2, 0x2, + 0x46d, 0x471, 0x7, 0x9b, 0x2, 0x2, 0x46e, 0x471, 0x7, 0x99, 0x2, 0x2, + 0x46f, 0x471, 0x5, 0xa0, 0x51, 0x2, 0x470, 0x46c, 0x3, 0x2, 0x2, 0x2, + 0x470, 0x46d, 0x3, 0x2, 0x2, 0x2, 0x470, 0x46e, 0x3, 0x2, 0x2, 0x2, + 0x470, 0x46f, 0x3, 0x2, 0x2, 0x2, 0x471, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x472, + 0x476, 0x5, 0x9c, 0x4f, 0x2, 0x473, 0x476, 0x5, 0x9e, 0x50, 0x2, 0x474, + 0x476, 0x5, 0xa2, 0x52, 0x2, 0x475, 0x472, 0x3, 0x2, 0x2, 0x2, 0x475, + 0x473, 0x3, 0x2, 0x2, 0x2, 0x475, 0x474, 0x3, 0x2, 0x2, 0x2, 0x476, + 0xa5, 0x3, 0x2, 0x2, 0x2, 0x7f, 0xae, 0xb0, 0xb9, 0xc1, 0xcd, 0xd4, + 0xde, 0xe4, 0xe9, 0xef, 0xf7, 0xfd, 0x108, 0x113, 0x118, 0x123, 0x12f, + 0x132, 0x13a, 0x13d, 0x140, 0x149, 0x14e, 0x157, 0x15c, 0x15f, 0x164, + 0x171, 0x173, 0x181, 0x186, 0x18c, 0x190, 0x1a3, 0x1a5, 0x1ad, 0x1b1, + 0x1b7, 0x1ba, 0x1c3, 0x1c5, 0x1ca, 0x1df, 0x1e1, 0x1e6, 0x1ee, 0x1fe, + 0x217, 0x219, 0x21f, 0x225, 0x228, 0x232, 0x235, 0x239, 0x242, 0x24b, + 0x250, 0x255, 0x264, 0x269, 0x274, 0x276, 0x27e, 0x282, 0x29a, 0x29c, + 0x2cc, 0x2d2, 0x2d6, 0x2dd, 0x2e6, 0x2e9, 0x2f0, 0x2f2, 0x2f9, 0x2fd, + 0x301, 0x30c, 0x318, 0x31f, 0x324, 0x329, 0x32d, 0x333, 0x344, 0x348, + 0x351, 0x357, 0x35b, 0x35e, 0x37e, 0x384, 0x388, 0x38e, 0x394, 0x39f, + 0x3a5, 0x3af, 0x3b6, 0x3bd, 0x3c1, 0x3c9, 0x3cf, 0x3df, 0x3ec, 0x3f2, + 0x3fb, 0x403, 0x408, 0x40a, 0x415, 0x41a, 0x42f, 0x433, 0x437, 0x441, + 0x444, 0x44d, 0x450, 0x459, 0x463, 0x466, 0x470, 0x475, + }; + + atn::ATNDeserializer deserializer; + _atn = deserializer.deserialize(_serializedATN); + + size_t count = _atn.getNumberOfDecisions(); + _decisionToDFA.reserve(count); + for (size_t i = 0; i < count; i++) { + _decisionToDFA.emplace_back(_atn.getDecisionState(i), i); + } +} + +SolidityParser::Initializer SolidityParser::_init; diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityParser.h b/test/tools/ossfuzz/antlr4-runtime/SolidityParser.h new file mode 100644 index 000000000..296b14637 --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityParser.h @@ -0,0 +1,2074 @@ + +// Generated from Solidity.g4 by ANTLR 4.8 + +#pragma once + + +#include "antlr4-runtime.h" + + + + +class SolidityParser : public antlr4::Parser { +public: + enum { + ReservedKeywords = 1, Pragma = 2, Abstract = 3, Anonymous = 4, Address = 5, + As = 6, Assembly = 7, Bool = 8, Break = 9, Bytes = 10, Calldata = 11, + Catch = 12, Constant = 13, Constructor = 14, Continue = 15, Contract = 16, + Delete = 17, Do = 18, Else = 19, Emit = 20, Enum = 21, Event = 22, External = 23, + Fallback = 24, False = 25, Fixed = 26, From = 27, FixedBytes = 28, For = 29, + Function = 30, Hex = 31, If = 32, Immutable = 33, Import = 34, Indexed = 35, + Interface = 36, Internal = 37, Is = 38, Library = 39, Mapping = 40, + Memory = 41, Modifier = 42, New = 43, NumberUnit = 44, Override = 45, + Payable = 46, Private = 47, Public = 48, Pure = 49, Receive = 50, Return = 51, + Returns = 52, SignedIntegerType = 53, Storage = 54, String = 55, Struct = 56, + True = 57, Try = 58, Type = 59, Ufixed = 60, UnsignedIntegerType = 61, + Using = 62, View = 63, Virtual = 64, While = 65, LParen = 66, RParen = 67, + LBrack = 68, RBrack = 69, LBrace = 70, RBrace = 71, Colon = 72, Semicolon = 73, + Period = 74, Conditional = 75, Arrow = 76, Assign = 77, AssignBitOr = 78, + AssignBitXor = 79, AssignBitAnd = 80, AssignShl = 81, AssignSar = 82, + AssignShr = 83, AssignAdd = 84, AssignSub = 85, AssignMul = 86, AssignDiv = 87, + AssignMod = 88, Comma = 89, Or = 90, And = 91, BitOr = 92, BitXor = 93, + BitAnd = 94, Shl = 95, Sar = 96, Shr = 97, Add = 98, Sub = 99, Mul = 100, + Div = 101, Mod = 102, Exp = 103, Equal = 104, NotEqual = 105, LessThan = 106, + GreaterThan = 107, LessThanOrEqual = 108, GreaterThanOrEqual = 109, + Not = 110, BitNot = 111, Inc = 112, Dec = 113, StringLiteral = 114, + NonEmptyStringLiteral = 115, UnicodeStringLiteral = 116, HexString = 117, + HexNumber = 118, DecimalNumber = 119, Identifier = 120, WS = 121, COMMENT = 122, + LINE_COMMENT = 123, AssemblyDialect = 124, AssemblyLBrace = 125, AssemblyBlockWS = 126, + AssemblyBlockCOMMENT = 127, AssemblyBlockLINE_COMMENT = 128, YulBreak = 129, + YulCase = 130, YulContinue = 131, YulDefault = 132, YulFalse = 133, + YulFor = 134, YulFunction = 135, YulIf = 136, YulLeave = 137, YulLet = 138, + YulSwitch = 139, YulTrue = 140, YulEVMBuiltin = 141, YulLBrace = 142, + YulRBrace = 143, YulLParen = 144, YulRParen = 145, YulAssign = 146, + YulPeriod = 147, YulComma = 148, YulArrow = 149, YulIdentifier = 150, + YulHexNumber = 151, YulDecimalNumber = 152, YulStringLiteral = 153, + YulWS = 154, YulCOMMENT = 155, YulLINE_COMMENT = 156, PragmaToken = 157, + PragmaSemicolon = 158, PragmaWS = 159, PragmaCOMMENT = 160, PragmaLINE_COMMENT = 161 + }; + + enum { + RuleSourceUnit = 0, RulePragmaDirective = 1, RuleImportDirective = 2, + RuleImportAliases = 3, RulePath = 4, RuleSymbolAliases = 5, RuleContractDefinition = 6, + RuleInterfaceDefinition = 7, RuleLibraryDefinition = 8, RuleInheritanceSpecifierList = 9, + RuleInheritanceSpecifier = 10, RuleContractBodyElement = 11, RuleNamedArgument = 12, + RuleCallArgumentList = 13, RuleUserDefinedTypeName = 14, RuleModifierInvocation = 15, + RuleVisibility = 16, RuleParameterList = 17, RuleParameterDeclaration = 18, + RuleConstructorDefinition = 19, RuleStateMutability = 20, RuleOverrideSpecifier = 21, + RuleFunctionDefinition = 22, RuleModifierDefinition = 23, RuleFallbackReceiveFunctionDefinition = 24, + RuleStructDefinition = 25, RuleStructMember = 26, RuleEnumDefinition = 27, + RuleStateVariableDeclaration = 28, RuleEventParameter = 29, RuleEventDefinition = 30, + RuleUsingDirective = 31, RuleTypeName = 32, RuleElementaryTypeName = 33, + RuleFunctionTypeName = 34, RuleVariableDeclaration = 35, RuleDataLocation = 36, + RuleExpression = 37, RuleAssignOp = 38, RuleTupleExpression = 39, RuleInlineArrayExpression = 40, + RuleIdentifier = 41, RuleLiteral = 42, RuleboolLiteral = 43, RuleStringLiteral = 44, + RuleHexStringLiteral = 45, RuleUnicodeStringLiteral = 46, RuleNumberLiteral = 47, + RuleBlock = 48, RuleStatement = 49, RuleSimpleStatement = 50, RuleIfStatement = 51, + RuleForStatement = 52, RuleWhileStatement = 53, RuleDoWhileStatement = 54, + RuleContinueStatement = 55, RuleBreakStatement = 56, RuleTryStatement = 57, + RuleCatchClause = 58, RuleReturnStatement = 59, RuleEmitStatement = 60, + RuleAssemblyStatement = 61, RuleVariableDeclarationList = 62, RuleVariableDeclarationTuple = 63, + RuleVariableDeclarationStatement = 64, RuleExpressionStatement = 65, + RuleMappingType = 66, RuleMappingKeyType = 67, RuleYulStatement = 68, + RuleYulBlock = 69, RuleYulVariableDeclaration = 70, RuleYulAssignment = 71, + RuleYulIfStatement = 72, RuleYulForStatement = 73, RuleYulSwitchCase = 74, + RuleYulSwitchStatement = 75, RuleYulFunctionDefinition = 76, RuleYulPath = 77, + RuleYulFunctionCall = 78, RuleYulbool = 79, RuleYulLiteral = 80, + RuleYulExpression = 81 + }; + + SolidityParser(antlr4::TokenStream *input); + ~SolidityParser(); + + virtual std::string getGrammarFileName() const override; + virtual const antlr4::atn::ATN& getATN() const override { return _atn; }; + virtual const std::vector& getTokenNames() const override { return _tokenNames; }; // deprecated: use vocabulary instead. + virtual const std::vector& getRuleNames() const override; + virtual antlr4::dfa::Vocabulary& getVocabulary() const override; + + + class SourceUnitContext; + class PragmaDirectiveContext; + class ImportDirectiveContext; + class ImportAliasesContext; + class PathContext; + class SymbolAliasesContext; + class ContractDefinitionContext; + class InterfaceDefinitionContext; + class LibraryDefinitionContext; + class InheritanceSpecifierListContext; + class InheritanceSpecifierContext; + class ContractBodyElementContext; + class NamedArgumentContext; + class CallArgumentListContext; + class UserDefinedTypeNameContext; + class ModifierInvocationContext; + class VisibilityContext; + class ParameterListContext; + class ParameterDeclarationContext; + class ConstructorDefinitionContext; + class StateMutabilityContext; + class OverrideSpecifierContext; + class FunctionDefinitionContext; + class ModifierDefinitionContext; + class FallbackReceiveFunctionDefinitionContext; + class StructDefinitionContext; + class StructMemberContext; + class EnumDefinitionContext; + class StateVariableDeclarationContext; + class EventParameterContext; + class EventDefinitionContext; + class UsingDirectiveContext; + class TypeNameContext; + class ElementaryTypeNameContext; + class FunctionTypeNameContext; + class VariableDeclarationContext; + class DataLocationContext; + class ExpressionContext; + class AssignOpContext; + class TupleExpressionContext; + class InlineArrayExpressionContext; + class IdentifierContext; + class LiteralContext; + class boolLiteralContext; + class StringLiteralContext; + class HexStringLiteralContext; + class UnicodeStringLiteralContext; + class NumberLiteralContext; + class BlockContext; + class StatementContext; + class SimpleStatementContext; + class IfStatementContext; + class ForStatementContext; + class WhileStatementContext; + class DoWhileStatementContext; + class ContinueStatementContext; + class BreakStatementContext; + class TryStatementContext; + class CatchClauseContext; + class ReturnStatementContext; + class EmitStatementContext; + class AssemblyStatementContext; + class VariableDeclarationListContext; + class VariableDeclarationTupleContext; + class VariableDeclarationStatementContext; + class ExpressionStatementContext; + class MappingTypeContext; + class MappingKeyTypeContext; + class YulStatementContext; + class YulBlockContext; + class YulVariableDeclarationContext; + class YulAssignmentContext; + class YulIfStatementContext; + class YulForStatementContext; + class YulSwitchCaseContext; + class YulSwitchStatementContext; + class YulFunctionDefinitionContext; + class YulPathContext; + class YulFunctionCallContext; + class YulboolContext; + class YulLiteralContext; + class YulExpressionContext; + + class SourceUnitContext : public antlr4::ParserRuleContext { + public: + SourceUnitContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *EOF(); + std::vector pragmaDirective(); + PragmaDirectiveContext* pragmaDirective(size_t i); + std::vector importDirective(); + ImportDirectiveContext* importDirective(size_t i); + std::vector contractDefinition(); + ContractDefinitionContext* contractDefinition(size_t i); + std::vector interfaceDefinition(); + InterfaceDefinitionContext* interfaceDefinition(size_t i); + std::vector libraryDefinition(); + LibraryDefinitionContext* libraryDefinition(size_t i); + std::vector functionDefinition(); + FunctionDefinitionContext* functionDefinition(size_t i); + std::vector structDefinition(); + StructDefinitionContext* structDefinition(size_t i); + std::vector enumDefinition(); + EnumDefinitionContext* enumDefinition(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + SourceUnitContext* sourceUnit(); + + class PragmaDirectiveContext : public antlr4::ParserRuleContext { + public: + PragmaDirectiveContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Pragma(); + antlr4::tree::TerminalNode *PragmaSemicolon(); + std::vector PragmaToken(); + antlr4::tree::TerminalNode* PragmaToken(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + PragmaDirectiveContext* pragmaDirective(); + + class ImportDirectiveContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *unitAlias = nullptr; + ImportDirectiveContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Import(); + antlr4::tree::TerminalNode *Semicolon(); + PathContext *path(); + SymbolAliasesContext *symbolAliases(); + antlr4::tree::TerminalNode *From(); + antlr4::tree::TerminalNode *Mul(); + antlr4::tree::TerminalNode *As(); + IdentifierContext *identifier(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ImportDirectiveContext* importDirective(); + + class ImportAliasesContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *symbol = nullptr; + SolidityParser::IdentifierContext *alias = nullptr; + ImportAliasesContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector identifier(); + IdentifierContext* identifier(size_t i); + antlr4::tree::TerminalNode *As(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ImportAliasesContext* importAliases(); + + class PathContext : public antlr4::ParserRuleContext { + public: + PathContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *NonEmptyStringLiteral(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + PathContext* path(); + + class SymbolAliasesContext : public antlr4::ParserRuleContext { + public: + SolidityParser::ImportAliasesContext *importAliasesContext = nullptr; + std::vector aliases; + SymbolAliasesContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + std::vector importAliases(); + ImportAliasesContext* importAliases(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + SymbolAliasesContext* symbolAliases(); + + class ContractDefinitionContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + ContractDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Contract(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + IdentifierContext *identifier(); + antlr4::tree::TerminalNode *Abstract(); + InheritanceSpecifierListContext *inheritanceSpecifierList(); + std::vector contractBodyElement(); + ContractBodyElementContext* contractBodyElement(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ContractDefinitionContext* contractDefinition(); + + class InterfaceDefinitionContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + InterfaceDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Interface(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + IdentifierContext *identifier(); + InheritanceSpecifierListContext *inheritanceSpecifierList(); + std::vector contractBodyElement(); + ContractBodyElementContext* contractBodyElement(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InterfaceDefinitionContext* interfaceDefinition(); + + class LibraryDefinitionContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + LibraryDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Library(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + IdentifierContext *identifier(); + std::vector contractBodyElement(); + ContractBodyElementContext* contractBodyElement(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LibraryDefinitionContext* libraryDefinition(); + + class InheritanceSpecifierListContext : public antlr4::ParserRuleContext { + public: + SolidityParser::InheritanceSpecifierContext *inheritanceSpecifierContext = nullptr; + std::vector inheritanceSpecifiers; + InheritanceSpecifierListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Is(); + std::vector inheritanceSpecifier(); + InheritanceSpecifierContext* inheritanceSpecifier(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InheritanceSpecifierListContext* inheritanceSpecifierList(); + + class InheritanceSpecifierContext : public antlr4::ParserRuleContext { + public: + SolidityParser::UserDefinedTypeNameContext *name = nullptr; + SolidityParser::CallArgumentListContext *arguments = nullptr; + InheritanceSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + UserDefinedTypeNameContext *userDefinedTypeName(); + CallArgumentListContext *callArgumentList(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InheritanceSpecifierContext* inheritanceSpecifier(); + + class ContractBodyElementContext : public antlr4::ParserRuleContext { + public: + ContractBodyElementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ConstructorDefinitionContext *constructorDefinition(); + FunctionDefinitionContext *functionDefinition(); + ModifierDefinitionContext *modifierDefinition(); + FallbackReceiveFunctionDefinitionContext *fallbackReceiveFunctionDefinition(); + StructDefinitionContext *structDefinition(); + EnumDefinitionContext *enumDefinition(); + StateVariableDeclarationContext *stateVariableDeclaration(); + EventDefinitionContext *eventDefinition(); + UsingDirectiveContext *usingDirective(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ContractBodyElementContext* contractBodyElement(); + + class NamedArgumentContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + SolidityParser::ExpressionContext *value = nullptr; + NamedArgumentContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Colon(); + IdentifierContext *identifier(); + ExpressionContext *expression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NamedArgumentContext* namedArgument(); + + class CallArgumentListContext : public antlr4::ParserRuleContext { + public: + CallArgumentListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + std::vector expression(); + ExpressionContext* expression(size_t i); + std::vector namedArgument(); + NamedArgumentContext* namedArgument(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CallArgumentListContext* callArgumentList(); + + class UserDefinedTypeNameContext : public antlr4::ParserRuleContext { + public: + UserDefinedTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector identifier(); + IdentifierContext* identifier(size_t i); + std::vector Period(); + antlr4::tree::TerminalNode* Period(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UserDefinedTypeNameContext* userDefinedTypeName(); + + class ModifierInvocationContext : public antlr4::ParserRuleContext { + public: + ModifierInvocationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + IdentifierContext *identifier(); + CallArgumentListContext *callArgumentList(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ModifierInvocationContext* modifierInvocation(); + + class VisibilityContext : public antlr4::ParserRuleContext { + public: + VisibilityContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Internal(); + antlr4::tree::TerminalNode *External(); + antlr4::tree::TerminalNode *Private(); + antlr4::tree::TerminalNode *Public(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VisibilityContext* visibility(); + + class ParameterListContext : public antlr4::ParserRuleContext { + public: + SolidityParser::ParameterDeclarationContext *parameterDeclarationContext = nullptr; + std::vector parameters; + ParameterListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector parameterDeclaration(); + ParameterDeclarationContext* parameterDeclaration(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ParameterListContext* parameterList(); + + class ParameterDeclarationContext : public antlr4::ParserRuleContext { + public: + SolidityParser::TypeNameContext *type = nullptr; + SolidityParser::DataLocationContext *location = nullptr; + SolidityParser::IdentifierContext *name = nullptr; + ParameterDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeNameContext *typeName(); + DataLocationContext *dataLocation(); + IdentifierContext *identifier(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ParameterDeclarationContext* parameterDeclaration(); + + class ConstructorDefinitionContext : public antlr4::ParserRuleContext { + public: + bool payableSet = false; + bool visibilitySet = false; + SolidityParser::ParameterListContext *arguments = nullptr; + SolidityParser::BlockContext *body = nullptr; + ConstructorDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Constructor(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + BlockContext *block(); + std::vector modifierInvocation(); + ModifierInvocationContext* modifierInvocation(size_t i); + std::vector Payable(); + antlr4::tree::TerminalNode* Payable(size_t i); + std::vector Internal(); + antlr4::tree::TerminalNode* Internal(size_t i); + std::vector Public(); + antlr4::tree::TerminalNode* Public(size_t i); + ParameterListContext *parameterList(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ConstructorDefinitionContext* constructorDefinition(); + + class StateMutabilityContext : public antlr4::ParserRuleContext { + public: + StateMutabilityContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Pure(); + antlr4::tree::TerminalNode *View(); + antlr4::tree::TerminalNode *Payable(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StateMutabilityContext* stateMutability(); + + class OverrideSpecifierContext : public antlr4::ParserRuleContext { + public: + SolidityParser::UserDefinedTypeNameContext *userDefinedTypeNameContext = nullptr; + std::vector overrides; + OverrideSpecifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Override(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + std::vector userDefinedTypeName(); + UserDefinedTypeNameContext* userDefinedTypeName(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + OverrideSpecifierContext* overrideSpecifier(); + + class FunctionDefinitionContext : public antlr4::ParserRuleContext { + public: + bool visibilitySet = false; + bool mutabilitySet = false; + bool virtualSet = false; + bool overrideSpecifierSet = false; + SolidityParser::ParameterListContext *arguments = nullptr; + SolidityParser::ParameterListContext *returnParameters = nullptr; + SolidityParser::BlockContext *body = nullptr; + FunctionDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Function(); + std::vector LParen(); + antlr4::tree::TerminalNode* LParen(size_t i); + std::vector RParen(); + antlr4::tree::TerminalNode* RParen(size_t i); + IdentifierContext *identifier(); + antlr4::tree::TerminalNode *Fallback(); + antlr4::tree::TerminalNode *Receive(); + antlr4::tree::TerminalNode *Semicolon(); + std::vector visibility(); + VisibilityContext* visibility(size_t i); + std::vector stateMutability(); + StateMutabilityContext* stateMutability(size_t i); + std::vector modifierInvocation(); + ModifierInvocationContext* modifierInvocation(size_t i); + std::vector Virtual(); + antlr4::tree::TerminalNode* Virtual(size_t i); + std::vector overrideSpecifier(); + OverrideSpecifierContext* overrideSpecifier(size_t i); + antlr4::tree::TerminalNode *Returns(); + BlockContext *block(); + std::vector parameterList(); + ParameterListContext* parameterList(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FunctionDefinitionContext* functionDefinition(); + + class ModifierDefinitionContext : public antlr4::ParserRuleContext { + public: + bool virtualSet = false; + bool overrideSpecifierSet = false; + SolidityParser::IdentifierContext *name = nullptr; + SolidityParser::ParameterListContext *arguments = nullptr; + SolidityParser::BlockContext *body = nullptr; + ModifierDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Modifier(); + IdentifierContext *identifier(); + antlr4::tree::TerminalNode *Semicolon(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + std::vector Virtual(); + antlr4::tree::TerminalNode* Virtual(size_t i); + std::vector overrideSpecifier(); + OverrideSpecifierContext* overrideSpecifier(size_t i); + BlockContext *block(); + ParameterListContext *parameterList(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ModifierDefinitionContext* modifierDefinition(); + + class FallbackReceiveFunctionDefinitionContext : public antlr4::ParserRuleContext { + public: + bool visibilitySet = false; + bool mutabilitySet = false; + bool virtualSet = false; + bool overrideSpecifierSet = false; + antlr4::Token *kind = nullptr; + SolidityParser::BlockContext *body = nullptr; + FallbackReceiveFunctionDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + antlr4::tree::TerminalNode *Fallback(); + antlr4::tree::TerminalNode *Receive(); + antlr4::tree::TerminalNode *Semicolon(); + std::vector visibility(); + VisibilityContext* visibility(size_t i); + std::vector stateMutability(); + StateMutabilityContext* stateMutability(size_t i); + std::vector modifierInvocation(); + ModifierInvocationContext* modifierInvocation(size_t i); + std::vector Virtual(); + antlr4::tree::TerminalNode* Virtual(size_t i); + std::vector overrideSpecifier(); + OverrideSpecifierContext* overrideSpecifier(size_t i); + BlockContext *block(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FallbackReceiveFunctionDefinitionContext* fallbackReceiveFunctionDefinition(); + + class StructDefinitionContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + SolidityParser::StructMemberContext *members = nullptr; + StructDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Struct(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + IdentifierContext *identifier(); + std::vector structMember(); + StructMemberContext* structMember(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StructDefinitionContext* structDefinition(); + + class StructMemberContext : public antlr4::ParserRuleContext { + public: + SolidityParser::TypeNameContext *type = nullptr; + SolidityParser::IdentifierContext *name = nullptr; + StructMemberContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semicolon(); + TypeNameContext *typeName(); + IdentifierContext *identifier(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StructMemberContext* structMember(); + + class EnumDefinitionContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + SolidityParser::IdentifierContext *identifierContext = nullptr; + std::vector enumValues; + EnumDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Enum(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + std::vector identifier(); + IdentifierContext* identifier(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EnumDefinitionContext* enumDefinition(); + + class StateVariableDeclarationContext : public antlr4::ParserRuleContext { + public: + bool constantnessSet = false; + bool visibilitySet = false; + bool overrideSpecifierSet = false; + SolidityParser::TypeNameContext *type = nullptr; + SolidityParser::IdentifierContext *name = nullptr; + SolidityParser::ExpressionContext *initialValue = nullptr; + StateVariableDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semicolon(); + TypeNameContext *typeName(); + IdentifierContext *identifier(); + std::vector Public(); + antlr4::tree::TerminalNode* Public(size_t i); + std::vector Private(); + antlr4::tree::TerminalNode* Private(size_t i); + std::vector Internal(); + antlr4::tree::TerminalNode* Internal(size_t i); + std::vector Constant(); + antlr4::tree::TerminalNode* Constant(size_t i); + std::vector overrideSpecifier(); + OverrideSpecifierContext* overrideSpecifier(size_t i); + std::vector Immutable(); + antlr4::tree::TerminalNode* Immutable(size_t i); + antlr4::tree::TerminalNode *Assign(); + ExpressionContext *expression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StateVariableDeclarationContext* stateVariableDeclaration(); + + class EventParameterContext : public antlr4::ParserRuleContext { + public: + SolidityParser::TypeNameContext *type = nullptr; + SolidityParser::IdentifierContext *name = nullptr; + EventParameterContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeNameContext *typeName(); + antlr4::tree::TerminalNode *Indexed(); + IdentifierContext *identifier(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EventParameterContext* eventParameter(); + + class EventDefinitionContext : public antlr4::ParserRuleContext { + public: + SolidityParser::IdentifierContext *name = nullptr; + SolidityParser::EventParameterContext *eventParameterContext = nullptr; + std::vector parameters; + EventDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Event(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + antlr4::tree::TerminalNode *Semicolon(); + IdentifierContext *identifier(); + antlr4::tree::TerminalNode *Anonymous(); + std::vector eventParameter(); + EventParameterContext* eventParameter(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EventDefinitionContext* eventDefinition(); + + class UsingDirectiveContext : public antlr4::ParserRuleContext { + public: + UsingDirectiveContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Using(); + UserDefinedTypeNameContext *userDefinedTypeName(); + antlr4::tree::TerminalNode *For(); + antlr4::tree::TerminalNode *Semicolon(); + antlr4::tree::TerminalNode *Mul(); + TypeNameContext *typeName(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UsingDirectiveContext* usingDirective(); + + class TypeNameContext : public antlr4::ParserRuleContext { + public: + TypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ElementaryTypeNameContext *elementaryTypeName(); + FunctionTypeNameContext *functionTypeName(); + MappingTypeContext *mappingType(); + UserDefinedTypeNameContext *userDefinedTypeName(); + TypeNameContext *typeName(); + antlr4::tree::TerminalNode *LBrack(); + antlr4::tree::TerminalNode *RBrack(); + ExpressionContext *expression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + TypeNameContext* typeName(); + TypeNameContext* typeName(int precedence); + class ElementaryTypeNameContext : public antlr4::ParserRuleContext { + public: + bool allowAddressPayable; + ElementaryTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + ElementaryTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState, bool allowAddressPayable); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Address(); + antlr4::tree::TerminalNode *Payable(); + antlr4::tree::TerminalNode *Bool(); + antlr4::tree::TerminalNode *String(); + antlr4::tree::TerminalNode *Bytes(); + antlr4::tree::TerminalNode *SignedIntegerType(); + antlr4::tree::TerminalNode *UnsignedIntegerType(); + antlr4::tree::TerminalNode *FixedBytes(); + antlr4::tree::TerminalNode *Fixed(); + antlr4::tree::TerminalNode *Ufixed(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ElementaryTypeNameContext* elementaryTypeName(bool allowAddressPayable); + + class FunctionTypeNameContext : public antlr4::ParserRuleContext { + public: + bool visibilitySet = false; + bool mutabilitySet = false; + SolidityParser::ParameterListContext *arguments = nullptr; + SolidityParser::ParameterListContext *returnParameters = nullptr; + FunctionTypeNameContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Function(); + std::vector LParen(); + antlr4::tree::TerminalNode* LParen(size_t i); + std::vector RParen(); + antlr4::tree::TerminalNode* RParen(size_t i); + std::vector visibility(); + VisibilityContext* visibility(size_t i); + std::vector stateMutability(); + StateMutabilityContext* stateMutability(size_t i); + antlr4::tree::TerminalNode *Returns(); + std::vector parameterList(); + ParameterListContext* parameterList(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + FunctionTypeNameContext* functionTypeName(); + + class VariableDeclarationContext : public antlr4::ParserRuleContext { + public: + SolidityParser::TypeNameContext *type = nullptr; + SolidityParser::DataLocationContext *location = nullptr; + SolidityParser::IdentifierContext *name = nullptr; + VariableDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + TypeNameContext *typeName(); + IdentifierContext *identifier(); + DataLocationContext *dataLocation(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VariableDeclarationContext* variableDeclaration(); + + class DataLocationContext : public antlr4::ParserRuleContext { + public: + DataLocationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Memory(); + antlr4::tree::TerminalNode *Storage(); + antlr4::tree::TerminalNode *Calldata(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + DataLocationContext* dataLocation(); + + class ExpressionContext : public antlr4::ParserRuleContext { + public: + ExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + + ExpressionContext() = default; + void copyFrom(ExpressionContext *context); + using antlr4::ParserRuleContext::copyFrom; + + virtual size_t getRuleIndex() const override; + + + }; + + class UnaryPrefixOperationContext : public ExpressionContext { + public: + UnaryPrefixOperationContext(ExpressionContext *ctx); + + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Inc(); + antlr4::tree::TerminalNode *Dec(); + antlr4::tree::TerminalNode *Not(); + antlr4::tree::TerminalNode *BitNot(); + antlr4::tree::TerminalNode *Delete(); + antlr4::tree::TerminalNode *Sub(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class PrimaryExpressionContext : public ExpressionContext { + public: + PrimaryExpressionContext(ExpressionContext *ctx); + + IdentifierContext *identifier(); + LiteralContext *literal(); + ElementaryTypeNameContext *elementaryTypeName(); + UserDefinedTypeNameContext *userDefinedTypeName(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class OrderComparisonContext : public ExpressionContext { + public: + OrderComparisonContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *LessThan(); + antlr4::tree::TerminalNode *GreaterThan(); + antlr4::tree::TerminalNode *LessThanOrEqual(); + antlr4::tree::TerminalNode *GreaterThanOrEqual(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ConditionalContext : public ExpressionContext { + public: + ConditionalContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Conditional(); + antlr4::tree::TerminalNode *Colon(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class PayableConversionContext : public ExpressionContext { + public: + PayableConversionContext(ExpressionContext *ctx); + + antlr4::tree::TerminalNode *Payable(); + CallArgumentListContext *callArgumentList(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class AssignmentContext : public ExpressionContext { + public: + AssignmentContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + AssignOpContext *assignOp(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class UnarySuffixOperationContext : public ExpressionContext { + public: + UnarySuffixOperationContext(ExpressionContext *ctx); + + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Inc(); + antlr4::tree::TerminalNode *Dec(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ShiftOperationContext : public ExpressionContext { + public: + ShiftOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Shl(); + antlr4::tree::TerminalNode *Sar(); + antlr4::tree::TerminalNode *Shr(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class BitAndOperationContext : public ExpressionContext { + public: + BitAndOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *BitAnd(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class FunctionCallContext : public ExpressionContext { + public: + FunctionCallContext(ExpressionContext *ctx); + + ExpressionContext *expression(); + CallArgumentListContext *callArgumentList(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class IndexRangeAccessContext : public ExpressionContext { + public: + IndexRangeAccessContext(ExpressionContext *ctx); + + SolidityParser::ExpressionContext *start = nullptr; + SolidityParser::ExpressionContext *end = nullptr; + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *LBrack(); + antlr4::tree::TerminalNode *Colon(); + antlr4::tree::TerminalNode *RBrack(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class NewExpressionContext : public ExpressionContext { + public: + NewExpressionContext(ExpressionContext *ctx); + + antlr4::tree::TerminalNode *New(); + TypeNameContext *typeName(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class IndexAccessContext : public ExpressionContext { + public: + IndexAccessContext(ExpressionContext *ctx); + + SolidityParser::ExpressionContext *index = nullptr; + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *LBrack(); + antlr4::tree::TerminalNode *RBrack(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class AddSubOperationContext : public ExpressionContext { + public: + AddSubOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Add(); + antlr4::tree::TerminalNode *Sub(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class BitOrOperationContext : public ExpressionContext { + public: + BitOrOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *BitOr(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class ExpOperationContext : public ExpressionContext { + public: + ExpOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Exp(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class AndOperationContext : public ExpressionContext { + public: + AndOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *And(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class InlineArrayContext : public ExpressionContext { + public: + InlineArrayContext(ExpressionContext *ctx); + + InlineArrayExpressionContext *inlineArrayExpression(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class OrOperationContext : public ExpressionContext { + public: + OrOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Or(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class MemberAccessContext : public ExpressionContext { + public: + MemberAccessContext(ExpressionContext *ctx); + + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Period(); + IdentifierContext *identifier(); + antlr4::tree::TerminalNode *Address(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class MulDivModOperationContext : public ExpressionContext { + public: + MulDivModOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Mul(); + antlr4::tree::TerminalNode *Div(); + antlr4::tree::TerminalNode *Mod(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class FunctionCallOptionsContext : public ExpressionContext { + public: + FunctionCallOptionsContext(ExpressionContext *ctx); + + ExpressionContext *expression(); + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + std::vector namedArgument(); + NamedArgumentContext* namedArgument(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class BitXorOperationContext : public ExpressionContext { + public: + BitXorOperationContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *BitXor(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class TupleContext : public ExpressionContext { + public: + TupleContext(ExpressionContext *ctx); + + TupleExpressionContext *tupleExpression(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class EqualityComparisonContext : public ExpressionContext { + public: + EqualityComparisonContext(ExpressionContext *ctx); + + std::vector expression(); + ExpressionContext* expression(size_t i); + antlr4::tree::TerminalNode *Equal(); + antlr4::tree::TerminalNode *NotEqual(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + class MetaTypeContext : public ExpressionContext { + public: + MetaTypeContext(ExpressionContext *ctx); + + antlr4::tree::TerminalNode *Type(); + antlr4::tree::TerminalNode *LParen(); + TypeNameContext *typeName(); + antlr4::tree::TerminalNode *RParen(); + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + }; + + ExpressionContext* expression(); + ExpressionContext* expression(int precedence); + class AssignOpContext : public antlr4::ParserRuleContext { + public: + AssignOpContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Assign(); + antlr4::tree::TerminalNode *AssignBitOr(); + antlr4::tree::TerminalNode *AssignBitXor(); + antlr4::tree::TerminalNode *AssignBitAnd(); + antlr4::tree::TerminalNode *AssignShl(); + antlr4::tree::TerminalNode *AssignSar(); + antlr4::tree::TerminalNode *AssignShr(); + antlr4::tree::TerminalNode *AssignAdd(); + antlr4::tree::TerminalNode *AssignSub(); + antlr4::tree::TerminalNode *AssignMul(); + antlr4::tree::TerminalNode *AssignDiv(); + antlr4::tree::TerminalNode *AssignMod(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AssignOpContext* assignOp(); + + class TupleExpressionContext : public antlr4::ParserRuleContext { + public: + TupleExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + std::vector expression(); + ExpressionContext* expression(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + TupleExpressionContext* tupleExpression(); + + class InlineArrayExpressionContext : public antlr4::ParserRuleContext { + public: + InlineArrayExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LBrack(); + antlr4::tree::TerminalNode *RBrack(); + std::vector expression(); + ExpressionContext* expression(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + InlineArrayExpressionContext* inlineArrayExpression(); + + class IdentifierContext : public antlr4::ParserRuleContext { + public: + IdentifierContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Identifier(); + antlr4::tree::TerminalNode *From(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + IdentifierContext* identifier(); + + class LiteralContext : public antlr4::ParserRuleContext { + public: + LiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + StringLiteralContext *stringLiteral(); + NumberLiteralContext *numberLiteral(); + boolLiteralContext *boolLiteral(); + HexStringLiteralContext *hexStringLiteral(); + UnicodeStringLiteralContext *unicodeStringLiteral(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + LiteralContext* literal(); + + class boolLiteralContext : public antlr4::ParserRuleContext { + public: + boolLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *True(); + antlr4::tree::TerminalNode *False(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + boolLiteralContext* boolLiteral(); + + class StringLiteralContext : public antlr4::ParserRuleContext { + public: + StringLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector StringLiteral(); + antlr4::tree::TerminalNode* StringLiteral(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StringLiteralContext* stringLiteral(); + + class HexStringLiteralContext : public antlr4::ParserRuleContext { + public: + HexStringLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector HexString(); + antlr4::tree::TerminalNode* HexString(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + HexStringLiteralContext* hexStringLiteral(); + + class UnicodeStringLiteralContext : public antlr4::ParserRuleContext { + public: + UnicodeStringLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector UnicodeStringLiteral(); + antlr4::tree::TerminalNode* UnicodeStringLiteral(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + UnicodeStringLiteralContext* unicodeStringLiteral(); + + class NumberLiteralContext : public antlr4::ParserRuleContext { + public: + NumberLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *DecimalNumber(); + antlr4::tree::TerminalNode *HexNumber(); + antlr4::tree::TerminalNode *NumberUnit(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + NumberLiteralContext* numberLiteral(); + + class BlockContext : public antlr4::ParserRuleContext { + public: + BlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LBrace(); + antlr4::tree::TerminalNode *RBrace(); + std::vector statement(); + StatementContext* statement(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BlockContext* block(); + + class StatementContext : public antlr4::ParserRuleContext { + public: + StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + BlockContext *block(); + SimpleStatementContext *simpleStatement(); + IfStatementContext *ifStatement(); + ForStatementContext *forStatement(); + WhileStatementContext *whileStatement(); + DoWhileStatementContext *doWhileStatement(); + ContinueStatementContext *continueStatement(); + BreakStatementContext *breakStatement(); + TryStatementContext *tryStatement(); + ReturnStatementContext *returnStatement(); + EmitStatementContext *emitStatement(); + AssemblyStatementContext *assemblyStatement(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + StatementContext* statement(); + + class SimpleStatementContext : public antlr4::ParserRuleContext { + public: + SimpleStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + VariableDeclarationStatementContext *variableDeclarationStatement(); + ExpressionStatementContext *expressionStatement(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + SimpleStatementContext* simpleStatement(); + + class IfStatementContext : public antlr4::ParserRuleContext { + public: + IfStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *If(); + antlr4::tree::TerminalNode *LParen(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *RParen(); + std::vector statement(); + StatementContext* statement(size_t i); + antlr4::tree::TerminalNode *Else(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + IfStatementContext* ifStatement(); + + class ForStatementContext : public antlr4::ParserRuleContext { + public: + ForStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *For(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + StatementContext *statement(); + SimpleStatementContext *simpleStatement(); + std::vector Semicolon(); + antlr4::tree::TerminalNode* Semicolon(size_t i); + ExpressionStatementContext *expressionStatement(); + ExpressionContext *expression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ForStatementContext* forStatement(); + + class WhileStatementContext : public antlr4::ParserRuleContext { + public: + WhileStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *While(); + antlr4::tree::TerminalNode *LParen(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *RParen(); + StatementContext *statement(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + WhileStatementContext* whileStatement(); + + class DoWhileStatementContext : public antlr4::ParserRuleContext { + public: + DoWhileStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Do(); + StatementContext *statement(); + antlr4::tree::TerminalNode *While(); + antlr4::tree::TerminalNode *LParen(); + ExpressionContext *expression(); + antlr4::tree::TerminalNode *RParen(); + antlr4::tree::TerminalNode *Semicolon(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + DoWhileStatementContext* doWhileStatement(); + + class ContinueStatementContext : public antlr4::ParserRuleContext { + public: + ContinueStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Continue(); + antlr4::tree::TerminalNode *Semicolon(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ContinueStatementContext* continueStatement(); + + class BreakStatementContext : public antlr4::ParserRuleContext { + public: + BreakStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Break(); + antlr4::tree::TerminalNode *Semicolon(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + BreakStatementContext* breakStatement(); + + class TryStatementContext : public antlr4::ParserRuleContext { + public: + SolidityParser::ParameterListContext *returnParameters = nullptr; + TryStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Try(); + ExpressionContext *expression(); + BlockContext *block(); + antlr4::tree::TerminalNode *Returns(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + std::vector catchClause(); + CatchClauseContext* catchClause(size_t i); + ParameterListContext *parameterList(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + TryStatementContext* tryStatement(); + + class CatchClauseContext : public antlr4::ParserRuleContext { + public: + SolidityParser::ParameterListContext *arguments = nullptr; + CatchClauseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Catch(); + BlockContext *block(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + IdentifierContext *identifier(); + ParameterListContext *parameterList(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + CatchClauseContext* catchClause(); + + class ReturnStatementContext : public antlr4::ParserRuleContext { + public: + ReturnStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Return(); + antlr4::tree::TerminalNode *Semicolon(); + ExpressionContext *expression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ReturnStatementContext* returnStatement(); + + class EmitStatementContext : public antlr4::ParserRuleContext { + public: + EmitStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Emit(); + ExpressionContext *expression(); + CallArgumentListContext *callArgumentList(); + antlr4::tree::TerminalNode *Semicolon(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + EmitStatementContext* emitStatement(); + + class AssemblyStatementContext : public antlr4::ParserRuleContext { + public: + AssemblyStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Assembly(); + antlr4::tree::TerminalNode *AssemblyLBrace(); + antlr4::tree::TerminalNode *YulRBrace(); + antlr4::tree::TerminalNode *AssemblyDialect(); + std::vector yulStatement(); + YulStatementContext* yulStatement(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + AssemblyStatementContext* assemblyStatement(); + + class VariableDeclarationListContext : public antlr4::ParserRuleContext { + public: + SolidityParser::VariableDeclarationContext *variableDeclarationContext = nullptr; + std::vector variableDeclarations; + VariableDeclarationListContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector variableDeclaration(); + VariableDeclarationContext* variableDeclaration(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VariableDeclarationListContext* variableDeclarationList(); + + class VariableDeclarationTupleContext : public antlr4::ParserRuleContext { + public: + SolidityParser::VariableDeclarationContext *variableDeclarationContext = nullptr; + std::vector variableDeclarations; + VariableDeclarationTupleContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *RParen(); + std::vector variableDeclaration(); + VariableDeclarationContext* variableDeclaration(size_t i); + std::vector Comma(); + antlr4::tree::TerminalNode* Comma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VariableDeclarationTupleContext* variableDeclarationTuple(); + + class VariableDeclarationStatementContext : public antlr4::ParserRuleContext { + public: + VariableDeclarationStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Semicolon(); + VariableDeclarationContext *variableDeclaration(); + VariableDeclarationTupleContext *variableDeclarationTuple(); + antlr4::tree::TerminalNode *Assign(); + ExpressionContext *expression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + VariableDeclarationStatementContext* variableDeclarationStatement(); + + class ExpressionStatementContext : public antlr4::ParserRuleContext { + public: + ExpressionStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ExpressionContext *expression(); + antlr4::tree::TerminalNode *Semicolon(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + ExpressionStatementContext* expressionStatement(); + + class MappingTypeContext : public antlr4::ParserRuleContext { + public: + SolidityParser::MappingKeyTypeContext *key = nullptr; + SolidityParser::TypeNameContext *value = nullptr; + MappingTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *Mapping(); + antlr4::tree::TerminalNode *LParen(); + antlr4::tree::TerminalNode *Arrow(); + antlr4::tree::TerminalNode *RParen(); + MappingKeyTypeContext *mappingKeyType(); + TypeNameContext *typeName(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MappingTypeContext* mappingType(); + + class MappingKeyTypeContext : public antlr4::ParserRuleContext { + public: + MappingKeyTypeContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + ElementaryTypeNameContext *elementaryTypeName(); + UserDefinedTypeNameContext *userDefinedTypeName(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + MappingKeyTypeContext* mappingKeyType(); + + class YulStatementContext : public antlr4::ParserRuleContext { + public: + YulStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + YulBlockContext *yulBlock(); + YulVariableDeclarationContext *yulVariableDeclaration(); + YulAssignmentContext *yulAssignment(); + YulFunctionCallContext *yulFunctionCall(); + YulIfStatementContext *yulIfStatement(); + YulForStatementContext *yulForStatement(); + YulSwitchStatementContext *yulSwitchStatement(); + antlr4::tree::TerminalNode *YulLeave(); + antlr4::tree::TerminalNode *YulBreak(); + antlr4::tree::TerminalNode *YulContinue(); + YulFunctionDefinitionContext *yulFunctionDefinition(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulStatementContext* yulStatement(); + + class YulBlockContext : public antlr4::ParserRuleContext { + public: + YulBlockContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulLBrace(); + antlr4::tree::TerminalNode *YulRBrace(); + std::vector yulStatement(); + YulStatementContext* yulStatement(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulBlockContext* yulBlock(); + + class YulVariableDeclarationContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *yulidentifierToken = nullptr; + std::vector variables; + YulVariableDeclarationContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulLet(); + std::vector YulIdentifier(); + antlr4::tree::TerminalNode* YulIdentifier(size_t i); + antlr4::tree::TerminalNode *YulAssign(); + YulExpressionContext *yulExpression(); + std::vector YulComma(); + antlr4::tree::TerminalNode* YulComma(size_t i); + YulFunctionCallContext *yulFunctionCall(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulVariableDeclarationContext* yulVariableDeclaration(); + + class YulAssignmentContext : public antlr4::ParserRuleContext { + public: + YulAssignmentContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector yulPath(); + YulPathContext* yulPath(size_t i); + antlr4::tree::TerminalNode *YulAssign(); + YulExpressionContext *yulExpression(); + YulFunctionCallContext *yulFunctionCall(); + std::vector YulComma(); + antlr4::tree::TerminalNode* YulComma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulAssignmentContext* yulAssignment(); + + class YulIfStatementContext : public antlr4::ParserRuleContext { + public: + SolidityParser::YulExpressionContext *cond = nullptr; + SolidityParser::YulBlockContext *body = nullptr; + YulIfStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulIf(); + YulExpressionContext *yulExpression(); + YulBlockContext *yulBlock(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulIfStatementContext* yulIfStatement(); + + class YulForStatementContext : public antlr4::ParserRuleContext { + public: + SolidityParser::YulBlockContext *init = nullptr; + SolidityParser::YulExpressionContext *cond = nullptr; + SolidityParser::YulBlockContext *post = nullptr; + SolidityParser::YulBlockContext *body = nullptr; + YulForStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulFor(); + std::vector yulBlock(); + YulBlockContext* yulBlock(size_t i); + YulExpressionContext *yulExpression(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulForStatementContext* yulForStatement(); + + class YulSwitchCaseContext : public antlr4::ParserRuleContext { + public: + YulSwitchCaseContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulCase(); + YulLiteralContext *yulLiteral(); + YulBlockContext *yulBlock(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulSwitchCaseContext* yulSwitchCase(); + + class YulSwitchStatementContext : public antlr4::ParserRuleContext { + public: + YulSwitchStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulSwitch(); + YulExpressionContext *yulExpression(); + antlr4::tree::TerminalNode *YulDefault(); + YulBlockContext *yulBlock(); + std::vector yulSwitchCase(); + YulSwitchCaseContext* yulSwitchCase(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulSwitchStatementContext* yulSwitchStatement(); + + class YulFunctionDefinitionContext : public antlr4::ParserRuleContext { + public: + antlr4::Token *yulidentifierToken = nullptr; + std::vector arguments; + std::vector returnParameters; + SolidityParser::YulBlockContext *body = nullptr; + YulFunctionDefinitionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulFunction(); + std::vector YulIdentifier(); + antlr4::tree::TerminalNode* YulIdentifier(size_t i); + antlr4::tree::TerminalNode *YulLParen(); + antlr4::tree::TerminalNode *YulRParen(); + YulBlockContext *yulBlock(); + antlr4::tree::TerminalNode *YulArrow(); + std::vector YulComma(); + antlr4::tree::TerminalNode* YulComma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulFunctionDefinitionContext* yulFunctionDefinition(); + + class YulPathContext : public antlr4::ParserRuleContext { + public: + YulPathContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector YulIdentifier(); + antlr4::tree::TerminalNode* YulIdentifier(size_t i); + std::vector YulPeriod(); + antlr4::tree::TerminalNode* YulPeriod(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulPathContext* yulPath(); + + class YulFunctionCallContext : public antlr4::ParserRuleContext { + public: + YulFunctionCallContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulLParen(); + antlr4::tree::TerminalNode *YulRParen(); + antlr4::tree::TerminalNode *YulIdentifier(); + antlr4::tree::TerminalNode *YulEVMBuiltin(); + std::vector yulExpression(); + YulExpressionContext* yulExpression(size_t i); + std::vector YulComma(); + antlr4::tree::TerminalNode* YulComma(size_t i); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulFunctionCallContext* yulFunctionCall(); + + class YulboolContext : public antlr4::ParserRuleContext { + public: + YulboolContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulTrue(); + antlr4::tree::TerminalNode *YulFalse(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulboolContext* yulbool(); + + class YulLiteralContext : public antlr4::ParserRuleContext { + public: + YulLiteralContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *YulDecimalNumber(); + antlr4::tree::TerminalNode *YulStringLiteral(); + antlr4::tree::TerminalNode *YulHexNumber(); + YulboolContext *yulbool(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulLiteralContext* yulLiteral(); + + class YulExpressionContext : public antlr4::ParserRuleContext { + public: + YulExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + YulPathContext *yulPath(); + YulFunctionCallContext *yulFunctionCall(); + YulLiteralContext *yulLiteral(); + + + virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override; + + }; + + YulExpressionContext* yulExpression(); + + + virtual bool sempred(antlr4::RuleContext *_localctx, size_t ruleIndex, size_t predicateIndex) override; + bool constructorDefinitionSempred(ConstructorDefinitionContext *_localctx, size_t predicateIndex); + bool functionDefinitionSempred(FunctionDefinitionContext *_localctx, size_t predicateIndex); + bool modifierDefinitionSempred(ModifierDefinitionContext *_localctx, size_t predicateIndex); + bool fallbackReceiveFunctionDefinitionSempred(FallbackReceiveFunctionDefinitionContext *_localctx, size_t predicateIndex); + bool stateVariableDeclarationSempred(StateVariableDeclarationContext *_localctx, size_t predicateIndex); + bool typeNameSempred(TypeNameContext *_localctx, size_t predicateIndex); + bool elementaryTypeNameSempred(ElementaryTypeNameContext *_localctx, size_t predicateIndex); + bool functionTypeNameSempred(FunctionTypeNameContext *_localctx, size_t predicateIndex); + bool expressionSempred(ExpressionContext *_localctx, size_t predicateIndex); + +private: + static std::vector _decisionToDFA; + static antlr4::atn::PredictionContextCache _sharedContextCache; + static std::vector _ruleNames; + static std::vector _tokenNames; + + static std::vector _literalNames; + static std::vector _symbolicNames; + static antlr4::dfa::Vocabulary _vocabulary; + static antlr4::atn::ATN _atn; + static std::vector _serializedATN; + + + struct Initializer { + Initializer(); + }; + static Initializer _init; +}; + diff --git a/test/tools/ossfuzz/antlr4-runtime/SolidityVisitor.h b/test/tools/ossfuzz/antlr4-runtime/SolidityVisitor.h new file mode 100644 index 000000000..38f4d7f7f --- /dev/null +++ b/test/tools/ossfuzz/antlr4-runtime/SolidityVisitor.h @@ -0,0 +1,238 @@ + +// Generated from Solidity.g4 by ANTLR 4.8 + +#pragma once + + +#include "antlr4-runtime.h" +#include + + + +/** + * This class defines an abstract visitor for a parse tree + * produced by SolidityParser. + */ +class SolidityVisitor : public antlr4::tree::AbstractParseTreeVisitor { +public: + + /** + * Visit parse trees produced by SolidityParser. + */ + virtual antlrcpp::Any visitSourceUnit(SolidityParser::SourceUnitContext *context) = 0; + + virtual antlrcpp::Any visitPragmaDirective(SolidityParser::PragmaDirectiveContext *context) = 0; + + virtual antlrcpp::Any visitImportDirective(SolidityParser::ImportDirectiveContext *context) = 0; + + virtual antlrcpp::Any visitImportAliases(SolidityParser::ImportAliasesContext *context) = 0; + + virtual antlrcpp::Any visitPath(SolidityParser::PathContext *context) = 0; + + virtual antlrcpp::Any visitSymbolAliases(SolidityParser::SymbolAliasesContext *context) = 0; + + virtual antlrcpp::Any visitContractDefinition(SolidityParser::ContractDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitInterfaceDefinition(SolidityParser::InterfaceDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitLibraryDefinition(SolidityParser::LibraryDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitInheritanceSpecifierList(SolidityParser::InheritanceSpecifierListContext *context) = 0; + + virtual antlrcpp::Any visitInheritanceSpecifier(SolidityParser::InheritanceSpecifierContext *context) = 0; + + virtual antlrcpp::Any visitContractBodyElement(SolidityParser::ContractBodyElementContext *context) = 0; + + virtual antlrcpp::Any visitNamedArgument(SolidityParser::NamedArgumentContext *context) = 0; + + virtual antlrcpp::Any visitCallArgumentList(SolidityParser::CallArgumentListContext *context) = 0; + + virtual antlrcpp::Any visitUserDefinedTypeName(SolidityParser::UserDefinedTypeNameContext *context) = 0; + + virtual antlrcpp::Any visitModifierInvocation(SolidityParser::ModifierInvocationContext *context) = 0; + + virtual antlrcpp::Any visitVisibility(SolidityParser::VisibilityContext *context) = 0; + + virtual antlrcpp::Any visitParameterList(SolidityParser::ParameterListContext *context) = 0; + + virtual antlrcpp::Any visitParameterDeclaration(SolidityParser::ParameterDeclarationContext *context) = 0; + + virtual antlrcpp::Any visitConstructorDefinition(SolidityParser::ConstructorDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitStateMutability(SolidityParser::StateMutabilityContext *context) = 0; + + virtual antlrcpp::Any visitOverrideSpecifier(SolidityParser::OverrideSpecifierContext *context) = 0; + + virtual antlrcpp::Any visitFunctionDefinition(SolidityParser::FunctionDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitModifierDefinition(SolidityParser::ModifierDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitFallbackReceiveFunctionDefinition(SolidityParser::FallbackReceiveFunctionDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitStructDefinition(SolidityParser::StructDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitStructMember(SolidityParser::StructMemberContext *context) = 0; + + virtual antlrcpp::Any visitEnumDefinition(SolidityParser::EnumDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitStateVariableDeclaration(SolidityParser::StateVariableDeclarationContext *context) = 0; + + virtual antlrcpp::Any visitEventParameter(SolidityParser::EventParameterContext *context) = 0; + + virtual antlrcpp::Any visitEventDefinition(SolidityParser::EventDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitUsingDirective(SolidityParser::UsingDirectiveContext *context) = 0; + + virtual antlrcpp::Any visitTypeName(SolidityParser::TypeNameContext *context) = 0; + + virtual antlrcpp::Any visitElementaryTypeName(SolidityParser::ElementaryTypeNameContext *context) = 0; + + virtual antlrcpp::Any visitFunctionTypeName(SolidityParser::FunctionTypeNameContext *context) = 0; + + virtual antlrcpp::Any visitVariableDeclaration(SolidityParser::VariableDeclarationContext *context) = 0; + + virtual antlrcpp::Any visitDataLocation(SolidityParser::DataLocationContext *context) = 0; + + virtual antlrcpp::Any visitUnaryPrefixOperation(SolidityParser::UnaryPrefixOperationContext *context) = 0; + + virtual antlrcpp::Any visitPrimaryExpression(SolidityParser::PrimaryExpressionContext *context) = 0; + + virtual antlrcpp::Any visitOrderComparison(SolidityParser::OrderComparisonContext *context) = 0; + + virtual antlrcpp::Any visitConditional(SolidityParser::ConditionalContext *context) = 0; + + virtual antlrcpp::Any visitPayableConversion(SolidityParser::PayableConversionContext *context) = 0; + + virtual antlrcpp::Any visitAssignment(SolidityParser::AssignmentContext *context) = 0; + + virtual antlrcpp::Any visitUnarySuffixOperation(SolidityParser::UnarySuffixOperationContext *context) = 0; + + virtual antlrcpp::Any visitShiftOperation(SolidityParser::ShiftOperationContext *context) = 0; + + virtual antlrcpp::Any visitBitAndOperation(SolidityParser::BitAndOperationContext *context) = 0; + + virtual antlrcpp::Any visitFunctionCall(SolidityParser::FunctionCallContext *context) = 0; + + virtual antlrcpp::Any visitIndexRangeAccess(SolidityParser::IndexRangeAccessContext *context) = 0; + + virtual antlrcpp::Any visitNewExpression(SolidityParser::NewExpressionContext *context) = 0; + + virtual antlrcpp::Any visitIndexAccess(SolidityParser::IndexAccessContext *context) = 0; + + virtual antlrcpp::Any visitAddSubOperation(SolidityParser::AddSubOperationContext *context) = 0; + + virtual antlrcpp::Any visitBitOrOperation(SolidityParser::BitOrOperationContext *context) = 0; + + virtual antlrcpp::Any visitExpOperation(SolidityParser::ExpOperationContext *context) = 0; + + virtual antlrcpp::Any visitAndOperation(SolidityParser::AndOperationContext *context) = 0; + + virtual antlrcpp::Any visitInlineArray(SolidityParser::InlineArrayContext *context) = 0; + + virtual antlrcpp::Any visitOrOperation(SolidityParser::OrOperationContext *context) = 0; + + virtual antlrcpp::Any visitMemberAccess(SolidityParser::MemberAccessContext *context) = 0; + + virtual antlrcpp::Any visitMulDivModOperation(SolidityParser::MulDivModOperationContext *context) = 0; + + virtual antlrcpp::Any visitFunctionCallOptions(SolidityParser::FunctionCallOptionsContext *context) = 0; + + virtual antlrcpp::Any visitBitXorOperation(SolidityParser::BitXorOperationContext *context) = 0; + + virtual antlrcpp::Any visitTuple(SolidityParser::TupleContext *context) = 0; + + virtual antlrcpp::Any visitEqualityComparison(SolidityParser::EqualityComparisonContext *context) = 0; + + virtual antlrcpp::Any visitMetaType(SolidityParser::MetaTypeContext *context) = 0; + + virtual antlrcpp::Any visitAssignOp(SolidityParser::AssignOpContext *context) = 0; + + virtual antlrcpp::Any visitTupleExpression(SolidityParser::TupleExpressionContext *context) = 0; + + virtual antlrcpp::Any visitInlineArrayExpression(SolidityParser::InlineArrayExpressionContext *context) = 0; + + virtual antlrcpp::Any visitIdentifier(SolidityParser::IdentifierContext *context) = 0; + + virtual antlrcpp::Any visitLiteral(SolidityParser::LiteralContext *context) = 0; + + virtual antlrcpp::Any visitBooleanLiteral(SolidityParser::boolLiteralContext *context) = 0; + + virtual antlrcpp::Any visitStringLiteral(SolidityParser::StringLiteralContext *context) = 0; + + virtual antlrcpp::Any visitHexStringLiteral(SolidityParser::HexStringLiteralContext *context) = 0; + + virtual antlrcpp::Any visitUnicodeStringLiteral(SolidityParser::UnicodeStringLiteralContext *context) = 0; + + virtual antlrcpp::Any visitNumberLiteral(SolidityParser::NumberLiteralContext *context) = 0; + + virtual antlrcpp::Any visitBlock(SolidityParser::BlockContext *context) = 0; + + virtual antlrcpp::Any visitStatement(SolidityParser::StatementContext *context) = 0; + + virtual antlrcpp::Any visitSimpleStatement(SolidityParser::SimpleStatementContext *context) = 0; + + virtual antlrcpp::Any visitIfStatement(SolidityParser::IfStatementContext *context) = 0; + + virtual antlrcpp::Any visitForStatement(SolidityParser::ForStatementContext *context) = 0; + + virtual antlrcpp::Any visitWhileStatement(SolidityParser::WhileStatementContext *context) = 0; + + virtual antlrcpp::Any visitDoWhileStatement(SolidityParser::DoWhileStatementContext *context) = 0; + + virtual antlrcpp::Any visitContinueStatement(SolidityParser::ContinueStatementContext *context) = 0; + + virtual antlrcpp::Any visitBreakStatement(SolidityParser::BreakStatementContext *context) = 0; + + virtual antlrcpp::Any visitTryStatement(SolidityParser::TryStatementContext *context) = 0; + + virtual antlrcpp::Any visitCatchClause(SolidityParser::CatchClauseContext *context) = 0; + + virtual antlrcpp::Any visitReturnStatement(SolidityParser::ReturnStatementContext *context) = 0; + + virtual antlrcpp::Any visitEmitStatement(SolidityParser::EmitStatementContext *context) = 0; + + virtual antlrcpp::Any visitAssemblyStatement(SolidityParser::AssemblyStatementContext *context) = 0; + + virtual antlrcpp::Any visitVariableDeclarationList(SolidityParser::VariableDeclarationListContext *context) = 0; + + virtual antlrcpp::Any visitVariableDeclarationTuple(SolidityParser::VariableDeclarationTupleContext *context) = 0; + + virtual antlrcpp::Any visitVariableDeclarationStatement(SolidityParser::VariableDeclarationStatementContext *context) = 0; + + virtual antlrcpp::Any visitExpressionStatement(SolidityParser::ExpressionStatementContext *context) = 0; + + virtual antlrcpp::Any visitMappingType(SolidityParser::MappingTypeContext *context) = 0; + + virtual antlrcpp::Any visitMappingKeyType(SolidityParser::MappingKeyTypeContext *context) = 0; + + virtual antlrcpp::Any visitYulStatement(SolidityParser::YulStatementContext *context) = 0; + + virtual antlrcpp::Any visitYulBlock(SolidityParser::YulBlockContext *context) = 0; + + virtual antlrcpp::Any visitYulVariableDeclaration(SolidityParser::YulVariableDeclarationContext *context) = 0; + + virtual antlrcpp::Any visitYulAssignment(SolidityParser::YulAssignmentContext *context) = 0; + + virtual antlrcpp::Any visitYulIfStatement(SolidityParser::YulIfStatementContext *context) = 0; + + virtual antlrcpp::Any visitYulForStatement(SolidityParser::YulForStatementContext *context) = 0; + + virtual antlrcpp::Any visitYulSwitchCase(SolidityParser::YulSwitchCaseContext *context) = 0; + + virtual antlrcpp::Any visitYulSwitchStatement(SolidityParser::YulSwitchStatementContext *context) = 0; + + virtual antlrcpp::Any visitYulFunctionDefinition(SolidityParser::YulFunctionDefinitionContext *context) = 0; + + virtual antlrcpp::Any visitYulPath(SolidityParser::YulPathContext *context) = 0; + + virtual antlrcpp::Any visitYulFunctionCall(SolidityParser::YulFunctionCallContext *context) = 0; + + virtual antlrcpp::Any visitYulBoolean(SolidityParser::YulboolContext *context) = 0; + + virtual antlrcpp::Any visitYulLiteral(SolidityParser::YulLiteralContext *context) = 0; + + virtual antlrcpp::Any visitYulExpression(SolidityParser::YulExpressionContext *context) = 0; + + +}; + diff --git a/test/tools/ossfuzz/libFuzzerMutator.cpp b/test/tools/ossfuzz/libFuzzerMutator.cpp new file mode 100644 index 000000000..9fc71a351 --- /dev/null +++ b/test/tools/ossfuzz/libFuzzerMutator.cpp @@ -0,0 +1,49 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ + +#include "libFuzzerMutator.h" + +#include +#include + +using namespace std; +using namespace antlr4; +using namespace solidity::test::fuzzer; + +size_t CustomMutator::mutation(Mutation _mut) +{ + if (MaxMutantSize <= Size || Size == 0) + return LLVMFuzzerMutate(Data, Size, MaxMutantSize); + + switch (_mut) + { + case Mutation::ANTLR: + { + string mutant = Visitor.toString(); + if (mutant.empty()) + return LLVMFuzzerMutate(Data, Size, MaxMutantSize); + else + { + size_t mutantSize = mutant.size() >= MaxMutantSize ? MaxMutantSize - 1 : mutant.size(); + mempcpy(Data, mutant.data(), mutantSize); + return mutantSize; + } + } + case Mutation::NUMMUTATIONS: + assert(false); + } +} \ No newline at end of file diff --git a/test/tools/ossfuzz/libFuzzerMutator.h b/test/tools/ossfuzz/libFuzzerMutator.h new file mode 100644 index 000000000..95ee2f5ea --- /dev/null +++ b/test/tools/ossfuzz/libFuzzerMutator.h @@ -0,0 +1,80 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ + +#pragma once + +#include +#include +#include + +#include +#include +#include +#include + +extern "C" size_t LLVMFuzzerMutate(uint8_t *Data, size_t Size, size_t MaxSize); + +namespace solidity::test::fuzzer +{ + struct CustomMutator + { + using RandomEngine = std::mt19937_64; + + explicit CustomMutator(uint8_t* _data, size_t _size, size_t _maxSize, unsigned _seed = 1337): + Rand(_seed), + Data(_data), + Size(_size), + In(std::string(_data, _data + _size)), + MaxMutantSize(_maxSize), + AStream(In), + Lexer(&AStream), + Tokens(&Lexer), + Parser(&Tokens) + { + Lexer.removeErrorListeners(); + Parser.removeErrorListeners(); + Parser.sourceUnit()->accept(&Visitor); + } + + enum class Mutation + { + ANTLR, + NUMMUTATIONS + }; + + size_t mutate() + { + return mutation(static_cast(Rand() % static_cast(Mutation::NUMMUTATIONS))); + } + + size_t mutation(Mutation _mut); + + RandomEngine Rand; + uint8_t* Data; + size_t Size; + std::string In; + std::string Out; + size_t MaxMutantSize; + + antlr4::ANTLRInputStream AStream; + SolidityLexer Lexer; + antlr4::CommonTokenStream Tokens; + SolidityParser Parser; + SolidityMutator Visitor; + }; + +} \ No newline at end of file diff --git a/test/tools/ossfuzz/solc_noopt_ossfuzz.cpp b/test/tools/ossfuzz/solc_noopt_ossfuzz.cpp index 8d615c0bd..cd467fdb3 100644 --- a/test/tools/ossfuzz/solc_noopt_ossfuzz.cpp +++ b/test/tools/ossfuzz/solc_noopt_ossfuzz.cpp @@ -14,17 +14,36 @@ You should have received a copy of the GNU General Public License along with solidity. If not, see . */ -// SPDX-License-Identifier: GPL-3.0 #include +#include + #include #include +using namespace solidity::test::fuzzer; using namespace solidity::frontend::test; using namespace std; +extern "C" size_t LLVMFuzzerCustomMutator( + uint8_t* _data, + size_t _size, + size_t _maxSize, + unsigned int _seed +) +{ + try + { + return CustomMutator(_data, _size, _maxSize, _seed).mutate(); + } + catch (range_error const&) + { + return LLVMFuzzerMutate(_data, _size, _maxSize); + } +} + extern "C" int LLVMFuzzerTestOneInput(uint8_t const* _data, size_t _size) { if (_size <= 600)