#include "cypher_parser.h"
using namespace antlrcpp;
using namespace antlr4;
namespace {
struct CypherParserStaticData final {
CypherParserStaticData(std::vector<std::string> ruleNames,
std::vector<std::string> literalNames,
std::vector<std::string> symbolicNames)
: ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
symbolicNames(std::move(symbolicNames)),
vocabulary(this->literalNames, this->symbolicNames) {}
CypherParserStaticData(const CypherParserStaticData&) = delete;
CypherParserStaticData(CypherParserStaticData&&) = delete;
CypherParserStaticData& operator=(const CypherParserStaticData&) = delete;
CypherParserStaticData& operator=(CypherParserStaticData&&) = delete;
std::vector<antlr4::dfa::DFA> decisionToDFA;
antlr4::atn::PredictionContextCache sharedContextCache;
const std::vector<std::string> ruleNames;
const std::vector<std::string> literalNames;
const std::vector<std::string> symbolicNames;
const antlr4::dfa::Vocabulary vocabulary;
antlr4::atn::SerializedATNView serializedATN;
std::unique_ptr<antlr4::atn::ATN> atn;
};
::antlr4::internal::OnceFlag cypherParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
CypherParserStaticData *cypherParserStaticData = nullptr;
void cypherParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
if (cypherParserStaticData != nullptr) {
return;
}
#else
assert(cypherParserStaticData == nullptr);
#endif
auto staticData = std::make_unique<CypherParserStaticData>(
std::vector<std::string>{
"iC_Statements", "oC_Cypher", "oC_Statement", "iC_CopyFrom", "iC_ColumnNames",
"iC_ScanSource", "iC_CopyFromByColumn", "iC_CopyTO", "iC_ExportDatabase",
"iC_ImportDatabase", "iC_AttachDatabase", "iC_Option", "iC_Options",
"iC_DetachDatabase", "iC_UseDatabase", "iC_CreateGraph", "iC_UseGraph",
"iC_StandaloneCall", "iC_CommentOn", "iC_CreateMacro", "iC_PositionalArgs",
"iC_DefaultArg", "iC_FilePaths", "iC_IfNotExists", "iC_CreateNodeTable",
"iC_CreateRelTable", "iC_FromToConnections", "iC_FromToConnection",
"iC_CreateSequence", "iC_CreateType", "iC_SequenceOptions", "iC_WithPasswd",
"iC_CreateUser", "iC_CreateRole", "iC_IncrementBy", "iC_MinValue",
"iC_MaxValue", "iC_StartWith", "iC_Cycle", "iC_IfExists", "iC_Drop",
"iC_AlterTable", "iC_AlterOptions", "iC_AddProperty", "iC_Default",
"iC_DropProperty", "iC_RenameTable", "iC_RenameProperty", "iC_AddFromToConnection",
"iC_DropFromToConnection", "iC_ColumnDefinitions", "iC_ColumnDefinition",
"iC_PropertyDefinitions", "iC_PropertyDefinition", "iC_CreateNodeConstraint",
"iC_UnionType", "iC_StructType", "iC_MapType", "iC_DecimalType", "iC_DataType",
"iC_ListIdentifiers", "iC_ListIdentifier", "oC_AnyCypherOption", "oC_Explain",
"oC_Profile", "iC_Transaction", "iC_Extension", "iC_LoadExtension",
"iC_InstallExtension", "iC_UninstallExtension", "iC_UpdateExtension",
"oC_Query", "oC_RegularQuery", "oC_Union", "oC_SingleQuery", "oC_SinglePartQuery",
"oC_MultiPartQuery", "iC_QueryPart", "oC_UpdatingClause", "oC_ReadingClause",
"iC_LoadFrom", "oC_YieldItem", "oC_YieldItems", "iC_InQueryCall",
"oC_Match", "iC_Hint", "iC_JoinNode", "oC_Unwind", "oC_Create", "oC_Merge",
"oC_MergeAction", "oC_Set", "oC_SetItem", "oC_Delete", "oC_With",
"oC_Return", "oC_ProjectionBody", "oC_ProjectionItems", "oC_ProjectionItem",
"oC_Order", "oC_Skip", "oC_Limit", "oC_SortItem", "oC_Where", "oC_Pattern",
"oC_PatternPart", "oC_AnonymousPatternPart", "oC_PatternElement",
"oC_NodePattern", "oC_PatternElementChain", "oC_RelationshipPattern",
"oC_RelationshipDetail", "iC_Properties", "oC_RelationshipTypes",
"oC_NodeLabels", "iC_RecursiveDetail", "iC_RecursiveType", "oC_RangeLiteral",
"iC_RecursiveComprehension", "iC_RecursiveProjectionItems", "oC_LowerBound",
"oC_UpperBound", "oC_LabelName", "oC_RelTypeName", "oC_Expression",
"oC_OrExpression", "oC_XorExpression", "oC_AndExpression", "oC_NotExpression",
"oC_ComparisonExpression", "iC_ComparisonOperator", "iC_BitwiseOrOperatorExpression",
"iC_BitwiseAndOperatorExpression", "iC_BitShiftOperatorExpression",
"iC_BitShiftOperator", "oC_AddOrSubtractExpression", "iC_AddOrSubtractOperator",
"oC_MultiplyDivideModuloExpression", "iC_MultiplyDivideModuloOperator",
"oC_PowerOfExpression", "oC_StringListNullOperatorExpression", "oC_ListOperatorExpression",
"oC_StringOperatorExpression", "oC_RegularExpression", "oC_NullOperatorExpression",
"oC_UnaryAddSubtractOrFactorialExpression", "oC_PropertyOrLabelsExpression",
"oC_Atom", "oC_Quantifier", "oC_FilterExpression", "oC_IdInColl",
"oC_Literal", "oC_BooleanLiteral", "oC_ListLiteral", "iC_ListEntry",
"iC_StructLiteral", "iC_StructField", "oC_ParenthesizedExpression",
"oC_FunctionInvocation", "oC_FunctionName", "iC_FunctionParameter",
"iC_LambdaParameter", "iC_LambdaVars", "oC_PathPatterns", "oC_ExistCountSubquery",
"oC_PropertyLookup", "oC_CaseExpression", "oC_CaseAlternative", "oC_Variable",
"oC_NumberLiteral", "oC_Parameter", "oC_PropertyExpression", "oC_PropertyKeyName",
"oC_IntegerLiteral", "oC_DoubleLiteral", "oC_SchemaName", "oC_SymbolicName",
"iC_NonReservedKeywords", "oC_LeftArrowHead", "oC_RightArrowHead",
"oC_Dash"
},
std::vector<std::string>{
"", "';'", "'('", "')'", "','", "'.'", "'='", "'['", "']'", "'{'",
"'}'", "'|'", "'<>'", "'<'", "'<='", "'>'", "'>='", "'&'", "'>>'",
"'<<'", "'+'", "'/'", "'%'", "'^'", "'=~'", "'$'", "'\\u27E8'", "'\\u3008'",
"'\\uFE64'", "'\\uFF1C'", "'\\u27E9'", "'\\u3009'", "'\\uFE65'", "'\\uFF1E'",
"'\\u00AD'", "'\\u2010'", "'\\u2011'", "'\\u2012'", "'\\u2013'", "'\\u2014'",
"'\\u2015'", "'\\u2212'", "'\\uFE58'", "'\\uFE63'", "'\\uFF0D'", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "'*'", "", "'!='",
"':'", "'..'", "'-'", "'!'", "", "", "", "", "", "", "", "", "'0'"
},
std::vector<std::string>{
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "", "ACYCLIC", "ANY", "ADD",
"ALL", "ALTER", "AND", "AS", "ASC", "ASCENDING", "ATTACH", "BEGIN",
"BY", "CALL", "CASE", "CAST", "CHECKPOINT", "COLUMN", "COMMENT", "COMMIT",
"COMMIT_SKIP_CHECKPOINT", "CONTAINS", "COPY", "COUNT", "CREATE", "CYCLE",
"DATABASE", "DBTYPE", "DEFAULT", "DELETE", "DESC", "DESCENDING", "DETACH",
"DISTINCT", "DROP", "ELSE", "END", "ENDS", "EXISTS", "EXPLAIN", "EXPORT",
"EXTENSION", "FALSE", "FROM", "FORCE", "GLOB", "GRAPH", "GROUP", "HEADERS",
"HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN",
"KEY", "LIMIT", "LOAD", "LOGICAL", "MACRO", "MATCH", "MAXVALUE", "MERGE",
"MINVALUE", "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON",
"ONLY", "OPTIONAL", "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT",
"READ", "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT",
"SEQUENCE", "SET", "SHORTEST", "START", "STARTS", "STRUCT", "TABLE",
"THEN", "TO", "TRAIL", "TRANSACTION", "TRUE", "TYPE", "UNION", "UNWIND",
"UNINSTALL", "UPDATE", "USE", "WHEN", "WHERE", "WITH", "WRITE", "WSHORTEST",
"XOR", "SINGLE", "YIELD", "USER", "PASSWORD", "ROLE", "MAP", "DECIMAL",
"STAR", "L_SKIP", "INVALID_NOT_EQUAL", "COLON", "DOTDOT", "MINUS",
"FACTORIAL", "StringLiteral", "EscapedChar", "DecimalInteger", "HexLetter",
"HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", "ZeroDigit",
"ExponentDecimalReal", "RegularDecimalReal", "UnescapedSymbolicName",
"IdentifierStart", "IdentifierPart", "EscapedSymbolicName", "SP",
"WHITESPACE", "CypherComment", "Unknown"
}
);
static const int32_t serializedATNSegment[] = {
4,1,186,2953,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,
7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,
7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,
7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122,
7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128,
7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134,
7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,
7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,
7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,
7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,
7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170,
7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,2,176,
7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,1,0,1,0,3,0,365,
8,0,1,0,1,0,3,0,369,8,0,1,0,5,0,372,8,0,10,0,12,0,375,9,0,1,0,3,0,378,
8,0,1,0,1,0,1,1,3,1,383,8,1,1,1,3,1,386,8,1,1,1,1,1,3,1,390,8,1,1,1,3,
1,393,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,3,2,419,8,2,1,3,1,3,1,3,1,3,3,3,425,
8,3,1,3,1,3,1,3,1,3,1,3,3,3,432,8,3,1,3,1,3,3,3,436,8,3,1,3,1,3,3,3,440,
8,3,1,3,1,3,3,3,444,8,3,1,4,3,4,447,8,4,1,4,1,4,3,4,451,8,4,1,4,1,4,3,
4,455,8,4,1,4,1,4,3,4,459,8,4,1,4,5,4,462,8,4,10,4,12,4,465,9,4,1,4,3,
4,468,8,4,3,4,470,8,4,1,4,1,4,1,5,1,5,1,5,3,5,477,8,5,1,5,1,5,3,5,481,
8,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,490,8,5,1,5,1,5,1,5,3,5,495,8,5,1,
6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,505,8,6,1,6,1,6,3,6,509,8,6,1,6,1,6,
3,6,513,8,6,1,6,5,6,516,8,6,10,6,12,6,519,9,6,1,6,1,6,1,6,1,6,1,6,1,6,
1,7,1,7,1,7,1,7,3,7,531,8,7,1,7,1,7,3,7,535,8,7,1,7,1,7,1,7,1,7,1,7,1,
7,3,7,543,8,7,1,7,1,7,3,7,547,8,7,1,7,1,7,3,7,551,8,7,1,7,1,7,3,7,555,
8,7,1,8,1,8,1,8,1,8,1,8,1,8,3,8,563,8,8,1,8,1,8,3,8,567,8,8,1,8,1,8,3,
8,571,8,8,1,8,1,8,3,8,575,8,8,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,
1,10,1,10,1,10,1,10,3,10,590,8,10,1,10,1,10,1,10,3,10,595,8,10,1,10,1,
10,1,10,1,10,3,10,601,8,10,1,10,1,10,3,10,605,8,10,1,10,3,10,608,8,10,
1,10,3,10,611,8,10,1,10,1,10,1,11,1,11,3,11,617,8,11,1,11,1,11,3,11,621,
8,11,1,11,5,11,624,8,11,10,11,12,11,627,9,11,3,11,629,8,11,1,11,1,11,
1,11,3,11,634,8,11,1,12,1,12,3,12,638,8,12,1,12,1,12,3,12,642,8,12,1,
12,5,12,645,8,12,10,12,12,12,648,9,12,1,13,1,13,1,13,1,13,1,14,1,14,1,
14,1,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,665,8,15,1,16,1,16,1,
16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,3,17,677,8,17,1,17,1,17,3,17,681,
8,17,1,17,1,17,1,17,1,17,1,17,3,17,688,8,17,1,18,1,18,1,18,1,18,1,18,
1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,19,1,19,1,19,1,19,1,19,1,19,3,19,
708,8,19,1,19,1,19,3,19,712,8,19,1,19,3,19,715,8,19,1,19,3,19,718,8,19,
1,19,3,19,721,8,19,1,19,3,19,724,8,19,1,19,1,19,3,19,728,8,19,1,19,5,
19,731,8,19,10,19,12,19,734,9,19,1,19,3,19,737,8,19,1,19,1,19,1,19,1,
19,1,19,1,19,1,20,1,20,3,20,747,8,20,1,20,1,20,3,20,751,8,20,1,20,5,20,
754,8,20,10,20,12,20,757,9,20,1,21,1,21,3,21,761,8,21,1,21,1,21,1,21,
3,21,766,8,21,1,21,1,21,1,22,1,22,3,22,772,8,22,1,22,1,22,3,22,776,8,
22,1,22,1,22,3,22,780,8,22,1,22,5,22,783,8,22,10,22,12,22,786,9,22,1,
22,1,22,1,22,1,22,3,22,792,8,22,1,22,1,22,3,22,796,8,22,1,22,1,22,3,22,
800,8,22,1,22,3,22,803,8,22,1,23,1,23,1,23,1,23,1,23,1,23,1,24,1,24,1,
24,1,24,1,24,1,24,1,24,1,24,1,24,3,24,820,8,24,1,24,1,24,3,24,824,8,24,
1,24,1,24,3,24,828,8,24,1,24,1,24,3,24,832,8,24,1,24,1,24,3,24,836,8,
24,1,24,3,24,839,8,24,1,24,3,24,842,8,24,1,24,1,24,1,24,1,24,1,24,1,24,
3,24,850,8,24,1,24,1,24,1,24,3,24,855,8,24,1,24,1,24,3,24,859,8,24,1,
24,1,24,3,24,863,8,24,1,24,1,24,3,24,867,8,24,1,25,1,25,1,25,1,25,1,25,
1,25,1,25,3,25,876,8,25,1,25,1,25,3,25,880,8,25,1,25,1,25,1,25,3,25,885,
8,25,1,25,1,25,3,25,889,8,25,1,25,1,25,3,25,893,8,25,1,25,1,25,3,25,897,
8,25,1,25,1,25,3,25,901,8,25,3,25,903,8,25,1,25,1,25,3,25,907,8,25,1,
25,1,25,3,25,911,8,25,3,25,913,8,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,
921,8,25,1,25,1,25,1,25,3,25,926,8,25,1,25,1,25,3,25,930,8,25,1,25,1,
25,3,25,934,8,25,1,25,1,25,3,25,938,8,25,1,26,1,26,3,26,942,8,26,1,26,
1,26,3,26,946,8,26,1,26,5,26,949,8,26,10,26,12,26,952,9,26,1,27,1,27,
1,27,1,27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,3,28,
969,8,28,1,28,1,28,1,28,5,28,974,8,28,10,28,12,28,977,9,28,1,29,1,29,
1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,989,8,29,1,30,1,30,1,30,
1,30,1,30,3,30,996,8,30,1,31,1,31,1,31,1,31,1,31,1,31,1,31,1,32,1,32,
1,32,1,32,1,32,1,32,1,32,3,32,1012,8,32,1,32,1,32,3,32,1016,8,32,1,33,
1,33,1,33,1,33,1,33,1,33,1,33,3,33,1025,8,33,1,33,1,33,1,34,1,34,1,34,
1,34,3,34,1033,8,34,1,34,3,34,1036,8,34,1,34,1,34,1,35,1,35,1,35,1,35,
1,35,1,35,3,35,1046,8,35,1,35,3,35,1049,8,35,1,36,1,36,1,36,1,36,1,36,
1,36,3,36,1057,8,36,1,36,3,36,1060,8,36,1,37,1,37,1,37,1,37,3,37,1066,
8,37,1,37,3,37,1069,8,37,1,37,1,37,1,38,1,38,3,38,1075,8,38,1,38,1,38,
1,39,1,39,1,39,1,39,1,40,1,40,1,40,1,40,1,40,1,40,1,40,3,40,1090,8,40,
1,40,1,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,1,42,1,42,1,42,1,42,
1,42,1,42,3,42,1108,8,42,1,43,1,43,1,43,1,43,1,43,3,43,1115,8,43,1,43,
1,43,1,43,1,43,1,43,3,43,1122,8,43,1,44,1,44,1,44,1,44,1,45,1,45,1,45,
1,45,1,45,3,45,1133,8,45,1,45,1,45,1,46,1,46,1,46,1,46,1,46,1,46,1,47,
1,47,1,47,1,47,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,3,48,1156,
8,48,1,48,1,48,1,49,1,49,1,49,1,49,1,49,3,49,1165,8,49,1,49,1,49,1,50,
1,50,3,50,1171,8,50,1,50,1,50,3,50,1175,8,50,1,50,5,50,1178,8,50,10,50,
12,50,1181,9,50,1,51,1,51,1,51,1,51,1,52,1,52,3,52,1189,8,52,1,52,1,52,
3,52,1193,8,52,1,52,5,52,1196,8,52,10,52,12,52,1199,9,52,1,53,1,53,1,
53,3,53,1204,8,53,1,53,1,53,1,53,1,53,3,53,1210,8,53,1,54,1,54,1,54,1,
54,3,54,1216,8,54,1,54,1,54,3,54,1220,8,54,1,54,1,54,3,54,1224,8,54,1,
54,1,54,1,55,1,55,3,55,1230,8,55,1,55,1,55,3,55,1234,8,55,1,55,1,55,3,
55,1238,8,55,1,55,1,55,1,56,1,56,3,56,1244,8,56,1,56,1,56,3,56,1248,8,
56,1,56,1,56,3,56,1252,8,56,1,56,1,56,1,57,1,57,3,57,1258,8,57,1,57,1,
57,3,57,1262,8,57,1,57,1,57,3,57,1266,8,57,1,57,1,57,3,57,1270,8,57,1,
57,1,57,3,57,1274,8,57,1,57,1,57,1,58,1,58,3,58,1280,8,58,1,58,1,58,3,
58,1284,8,58,1,58,1,58,3,58,1288,8,58,1,58,1,58,3,58,1292,8,58,1,58,1,
58,3,58,1296,8,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,3,59,1306,8,
59,1,59,1,59,5,59,1310,8,59,10,59,12,59,1313,9,59,1,60,1,60,5,60,1317,
8,60,10,60,12,60,1320,9,60,1,61,1,61,3,61,1324,8,61,1,61,1,61,1,62,1,
62,3,62,1330,8,62,1,63,1,63,1,63,3,63,1335,8,63,1,64,1,64,1,65,1,65,1,
65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,1,65,3,65,1352,8,65,1,
66,1,66,1,66,1,66,3,66,1358,8,66,1,67,1,67,1,67,1,67,3,67,1364,8,67,1,
67,1,67,3,67,1368,8,67,1,68,1,68,3,68,1372,8,68,1,68,1,68,1,68,1,68,1,
68,1,68,1,68,3,68,1381,8,68,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,
71,1,71,1,72,1,72,3,72,1395,8,72,1,72,5,72,1398,8,72,10,72,12,72,1401,
9,72,1,72,1,72,3,72,1405,8,72,4,72,1407,8,72,11,72,12,72,1408,1,72,1,
72,1,72,3,72,1414,8,72,1,73,1,73,1,73,1,73,3,73,1420,8,73,1,73,1,73,1,
73,3,73,1425,8,73,1,73,3,73,1428,8,73,1,74,1,74,3,74,1432,8,74,1,75,1,
75,3,75,1436,8,75,5,75,1438,8,75,10,75,12,75,1441,9,75,1,75,1,75,1,75,
3,75,1446,8,75,5,75,1448,8,75,10,75,12,75,1451,9,75,1,75,1,75,3,75,1455,
8,75,1,75,5,75,1458,8,75,10,75,12,75,1461,9,75,1,75,3,75,1464,8,75,1,
75,3,75,1467,8,75,3,75,1469,8,75,1,76,1,76,3,76,1473,8,76,4,76,1475,8,
76,11,76,12,76,1476,1,76,1,76,1,77,1,77,3,77,1483,8,77,5,77,1485,8,77,
10,77,12,77,1488,9,77,1,77,1,77,3,77,1492,8,77,5,77,1494,8,77,10,77,12,
77,1497,9,77,1,77,1,77,1,78,1,78,1,78,1,78,3,78,1505,8,78,1,79,1,79,1,
79,1,79,3,79,1511,8,79,1,80,1,80,1,80,1,80,1,80,1,80,3,80,1519,8,80,1,
80,1,80,3,80,1523,8,80,1,80,1,80,3,80,1527,8,80,1,80,1,80,3,80,1531,8,
80,1,80,1,80,1,80,1,80,1,80,3,80,1538,8,80,1,80,1,80,3,80,1542,8,80,1,
80,1,80,3,80,1546,8,80,1,80,1,80,3,80,1550,8,80,1,80,3,80,1553,8,80,1,
80,3,80,1556,8,80,1,81,1,81,1,81,1,81,1,81,3,81,1563,8,81,1,81,1,81,1,
82,1,82,3,82,1569,8,82,1,82,1,82,3,82,1573,8,82,1,82,5,82,1576,8,82,10,
82,12,82,1579,9,82,1,83,1,83,1,83,1,83,3,83,1585,8,83,1,83,3,83,1588,
8,83,1,83,3,83,1591,8,83,1,83,1,83,1,83,3,83,1596,8,83,1,84,1,84,3,84,
1600,8,84,1,84,1,84,3,84,1604,8,84,1,84,1,84,1,84,3,84,1609,8,84,1,84,
1,84,3,84,1613,8,84,1,85,1,85,1,85,1,85,1,86,1,86,1,86,3,86,1622,8,86,
1,86,1,86,3,86,1626,8,86,1,86,1,86,1,86,3,86,1631,8,86,1,86,1,86,1,86,
1,86,1,86,1,86,1,86,1,86,1,86,1,86,4,86,1643,8,86,11,86,12,86,1644,5,
86,1647,8,86,10,86,12,86,1650,9,86,1,87,1,87,3,87,1654,8,87,1,87,1,87,
1,87,1,87,1,87,1,87,1,88,1,88,3,88,1664,8,88,1,88,1,88,1,89,1,89,3,89,
1670,8,89,1,89,1,89,1,89,5,89,1675,8,89,10,89,12,89,1678,9,89,1,90,1,
90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,90,3,90,1690,8,90,1,91,1,91,3,
91,1694,8,91,1,91,1,91,3,91,1698,8,91,1,91,1,91,3,91,1702,8,91,1,91,5,
91,1705,8,91,10,91,12,91,1708,9,91,1,91,1,91,3,91,1712,8,91,1,91,1,91,
3,91,1716,8,91,1,91,1,91,3,91,1720,8,91,1,91,1,91,3,91,1724,8,91,1,92,
1,92,3,92,1728,8,92,1,92,1,92,3,92,1732,8,92,1,92,1,92,1,93,1,93,3,93,
1738,8,93,1,93,1,93,3,93,1742,8,93,1,93,1,93,3,93,1746,8,93,1,93,1,93,
3,93,1750,8,93,1,93,5,93,1753,8,93,10,93,12,93,1756,9,93,1,94,1,94,1,
94,3,94,1761,8,94,1,94,3,94,1764,8,94,1,95,1,95,1,95,1,96,3,96,1770,8,
96,1,96,3,96,1773,8,96,1,96,1,96,1,96,1,96,3,96,1779,8,96,1,96,1,96,3,
96,1783,8,96,1,96,1,96,3,96,1787,8,96,1,97,1,97,3,97,1791,8,97,1,97,1,
97,3,97,1795,8,97,1,97,5,97,1798,8,97,10,97,12,97,1801,9,97,1,97,1,97,
3,97,1805,8,97,1,97,1,97,3,97,1809,8,97,1,97,5,97,1812,8,97,10,97,12,
97,1815,9,97,3,97,1817,8,97,1,98,1,98,1,98,1,98,1,98,1,98,1,98,3,98,1826,
8,98,1,99,1,99,1,99,1,99,1,99,1,99,1,99,3,99,1835,8,99,1,99,5,99,1838,
8,99,10,99,12,99,1841,9,99,1,100,1,100,1,100,1,100,1,101,1,101,1,101,
1,101,1,102,1,102,3,102,1853,8,102,1,102,3,102,1856,8,102,1,103,1,103,
1,103,1,103,1,104,1,104,3,104,1864,8,104,1,104,1,104,3,104,1868,8,104,
1,104,5,104,1871,8,104,10,104,12,104,1874,9,104,1,105,1,105,3,105,1878,
8,105,1,105,1,105,3,105,1882,8,105,1,105,1,105,1,105,3,105,1887,8,105,
1,106,1,106,1,107,1,107,3,107,1893,8,107,1,107,5,107,1896,8,107,10,107,
12,107,1899,9,107,1,107,1,107,1,107,1,107,3,107,1905,8,107,1,108,1,108,
3,108,1909,8,108,1,108,1,108,3,108,1913,8,108,3,108,1915,8,108,1,108,
1,108,3,108,1919,8,108,3,108,1921,8,108,1,108,1,108,3,108,1925,8,108,
3,108,1927,8,108,1,108,1,108,1,109,1,109,3,109,1933,8,109,1,109,1,109,
1,110,1,110,3,110,1939,8,110,1,110,1,110,3,110,1943,8,110,1,110,3,110,
1946,8,110,1,110,3,110,1949,8,110,1,110,1,110,1,110,1,110,3,110,1955,
8,110,1,110,3,110,1958,8,110,1,110,3,110,1961,8,110,1,110,1,110,3,110,
1965,8,110,1,110,1,110,1,110,1,110,3,110,1971,8,110,1,110,3,110,1974,
8,110,1,110,3,110,1977,8,110,1,110,1,110,3,110,1981,8,110,1,111,1,111,
3,111,1985,8,111,1,111,1,111,3,111,1989,8,111,3,111,1991,8,111,1,111,
1,111,3,111,1995,8,111,3,111,1997,8,111,1,111,1,111,3,111,2001,8,111,
3,111,2003,8,111,1,111,1,111,3,111,2007,8,111,3,111,2009,8,111,1,111,
1,111,1,112,1,112,3,112,2015,8,112,1,112,1,112,3,112,2019,8,112,1,112,
1,112,3,112,2023,8,112,1,112,1,112,3,112,2027,8,112,1,112,1,112,3,112,
2031,8,112,1,112,1,112,3,112,2035,8,112,1,112,1,112,3,112,2039,8,112,
1,112,1,112,3,112,2043,8,112,5,112,2045,8,112,10,112,12,112,2048,9,112,
3,112,2050,8,112,1,112,1,112,1,113,1,113,3,113,2056,8,113,1,113,1,113,
3,113,2060,8,113,1,113,1,113,3,113,2064,8,113,1,113,3,113,2067,8,113,
1,113,5,113,2070,8,113,10,113,12,113,2073,9,113,1,114,1,114,3,114,2077,
8,114,1,114,1,114,3,114,2081,8,114,1,114,1,114,3,114,2085,8,114,1,114,
3,114,2088,8,114,1,114,3,114,2091,8,114,1,114,5,114,2094,8,114,10,114,
12,114,2097,9,114,1,115,1,115,3,115,2101,8,115,1,115,3,115,2104,8,115,
1,115,3,115,2107,8,115,1,115,3,115,2110,8,115,1,115,3,115,2113,8,115,
1,115,3,115,2116,8,115,1,116,1,116,3,116,2120,8,116,1,116,1,116,3,116,
2124,8,116,1,116,1,116,3,116,2128,8,116,1,116,1,116,3,116,2132,8,116,
1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,3,116,2142,8,116,1,117,
3,117,2145,8,117,1,117,3,117,2148,8,117,1,117,1,117,3,117,2152,8,117,
1,117,3,117,2155,8,117,1,117,3,117,2158,8,117,1,118,1,118,3,118,2162,
8,118,1,118,1,118,3,118,2166,8,118,1,118,1,118,3,118,2170,8,118,1,118,
1,118,3,118,2174,8,118,1,118,1,118,3,118,2178,8,118,1,118,1,118,3,118,
2182,8,118,3,118,2184,8,118,1,118,3,118,2187,8,118,1,118,1,118,3,118,
2191,8,118,1,118,1,118,3,118,2195,8,118,1,118,1,118,3,118,2199,8,118,
1,118,1,118,3,118,2203,8,118,3,118,2205,8,118,1,118,1,118,1,119,1,119,
3,119,2211,8,119,1,119,3,119,2214,8,119,1,119,3,119,2217,8,119,1,119,
1,119,1,120,1,120,1,121,1,121,1,122,1,122,1,122,3,122,2228,8,122,1,123,
1,123,1,124,1,124,1,125,1,125,1,125,1,125,1,125,5,125,2239,8,125,10,125,
12,125,2242,9,125,1,126,1,126,1,126,1,126,1,126,5,126,2249,8,126,10,126,
12,126,2252,9,126,1,127,1,127,1,127,1,127,1,127,5,127,2259,8,127,10,127,
12,127,2262,9,127,1,128,1,128,3,128,2266,8,128,5,128,2268,8,128,10,128,
12,128,2271,9,128,1,128,1,128,1,129,1,129,3,129,2277,8,129,1,129,1,129,
3,129,2281,8,129,1,129,1,129,3,129,2285,8,129,1,129,1,129,3,129,2289,
8,129,1,129,1,129,3,129,2293,8,129,1,129,1,129,1,129,1,129,1,129,1,129,
3,129,2301,8,129,1,129,1,129,3,129,2305,8,129,1,129,1,129,3,129,2309,
8,129,1,129,1,129,3,129,2313,8,129,1,129,1,129,4,129,2317,8,129,11,129,
12,129,2318,1,129,1,129,3,129,2323,8,129,1,130,1,130,1,131,1,131,3,131,
2329,8,131,1,131,1,131,3,131,2333,8,131,1,131,5,131,2336,8,131,10,131,
12,131,2339,9,131,1,132,1,132,3,132,2343,8,132,1,132,1,132,3,132,2347,
8,132,1,132,5,132,2350,8,132,10,132,12,132,2353,9,132,1,133,1,133,3,133,
2357,8,133,1,133,1,133,3,133,2361,8,133,1,133,1,133,5,133,2365,8,133,
10,133,12,133,2368,9,133,1,134,1,134,1,135,1,135,3,135,2374,8,135,1,135,
1,135,3,135,2378,8,135,1,135,1,135,5,135,2382,8,135,10,135,12,135,2385,
9,135,1,136,1,136,1,137,1,137,3,137,2391,8,137,1,137,1,137,3,137,2395,
8,137,1,137,1,137,5,137,2399,8,137,10,137,12,137,2402,9,137,1,138,1,138,
1,139,1,139,3,139,2408,8,139,1,139,1,139,3,139,2412,8,139,1,139,5,139,
2415,8,139,10,139,12,139,2418,9,139,1,140,1,140,1,140,4,140,2423,8,140,
11,140,12,140,2424,1,140,3,140,2428,8,140,1,141,1,141,1,141,3,141,2433,
8,141,1,141,1,141,1,141,1,141,1,141,1,141,1,141,3,141,2442,8,141,1,141,
1,141,3,141,2446,8,141,1,141,3,141,2449,8,141,1,142,1,142,1,142,1,142,
1,142,1,142,1,142,1,142,1,142,1,142,1,142,3,142,2462,8,142,1,142,3,142,
2465,8,142,1,142,1,142,1,143,3,143,2470,8,143,1,143,1,143,1,144,1,144,
1,144,1,144,1,144,1,144,1,144,1,144,1,144,1,144,3,144,2484,8,144,1,145,
1,145,3,145,2488,8,145,5,145,2490,8,145,10,145,12,145,2493,9,145,1,145,
1,145,3,145,2497,8,145,1,145,3,145,2500,8,145,1,146,1,146,3,146,2504,
8,146,1,146,5,146,2507,8,146,10,146,12,146,2510,9,146,1,147,1,147,1,147,
1,147,1,147,1,147,1,147,1,147,1,147,3,147,2521,8,147,1,148,1,148,3,148,
2525,8,148,1,148,1,148,3,148,2529,8,148,1,148,1,148,3,148,2533,8,148,
1,148,1,148,1,148,1,148,3,148,2539,8,148,1,148,1,148,3,148,2543,8,148,
1,148,1,148,3,148,2547,8,148,1,148,1,148,1,148,1,148,3,148,2553,8,148,
1,148,1,148,3,148,2557,8,148,1,148,1,148,3,148,2561,8,148,1,148,1,148,
1,148,1,148,3,148,2567,8,148,1,148,1,148,3,148,2571,8,148,1,148,1,148,
3,148,2575,8,148,1,148,1,148,3,148,2579,8,148,1,149,1,149,1,149,1,149,
1,150,1,150,1,150,1,150,1,150,1,150,1,151,1,151,1,151,1,151,1,151,1,151,
3,151,2597,8,151,1,152,1,152,1,153,1,153,3,153,2603,8,153,1,153,1,153,
3,153,2607,8,153,1,153,1,153,3,153,2611,8,153,5,153,2613,8,153,10,153,
12,153,2616,9,153,3,153,2618,8,153,1,153,1,153,1,154,1,154,3,154,2624,
8,154,1,154,3,154,2627,8,154,1,155,1,155,3,155,2631,8,155,1,155,1,155,
3,155,2635,8,155,1,155,1,155,3,155,2639,8,155,1,155,1,155,3,155,2643,
8,155,5,155,2645,8,155,10,155,12,155,2648,9,155,1,155,1,155,1,156,1,156,
3,156,2654,8,156,1,156,3,156,2657,8,156,1,156,1,156,3,156,2661,8,156,
1,156,1,156,1,157,1,157,3,157,2667,8,157,1,157,1,157,3,157,2671,8,157,
1,157,1,157,1,158,1,158,3,158,2677,8,158,1,158,1,158,3,158,2681,8,158,
1,158,1,158,3,158,2685,8,158,1,158,1,158,1,158,3,158,2690,8,158,1,158,
1,158,3,158,2694,8,158,1,158,1,158,3,158,2698,8,158,1,158,1,158,3,158,
2702,8,158,1,158,1,158,1,158,3,158,2707,8,158,1,158,3,158,2710,8,158,
1,158,3,158,2713,8,158,1,158,1,158,1,158,1,158,3,158,2719,8,158,1,158,
1,158,3,158,2723,8,158,1,158,1,158,3,158,2727,8,158,3,158,2729,8,158,
1,158,1,158,3,158,2733,8,158,1,158,1,158,3,158,2737,8,158,1,158,1,158,
3,158,2741,8,158,5,158,2743,8,158,10,158,12,158,2746,9,158,3,158,2748,
8,158,1,158,1,158,3,158,2752,8,158,1,159,1,159,1,160,1,160,3,160,2758,
8,160,1,160,1,160,1,160,3,160,2763,8,160,3,160,2765,8,160,1,160,1,160,
3,160,2769,8,160,1,161,1,161,3,161,2773,8,161,1,161,1,161,1,161,3,161,
2778,8,161,1,161,1,161,3,161,2782,8,161,1,162,1,162,1,162,3,162,2787,
8,162,1,162,1,162,3,162,2791,8,162,1,162,1,162,3,162,2795,8,162,1,162,
1,162,3,162,2799,8,162,5,162,2801,8,162,10,162,12,162,2804,9,162,1,162,
1,162,3,162,2808,8,162,1,163,1,163,3,163,2812,8,163,1,163,4,163,2815,
8,163,11,163,12,163,2816,1,164,1,164,3,164,2821,8,164,1,164,1,164,3,164,
2825,8,164,1,164,1,164,3,164,2829,8,164,1,164,1,164,3,164,2833,8,164,
1,164,3,164,2836,8,164,1,164,3,164,2839,8,164,1,164,3,164,2842,8,164,
1,164,3,164,2845,8,164,1,164,1,164,1,165,1,165,3,165,2851,8,165,1,165,
1,165,3,165,2855,8,165,1,166,1,166,3,166,2859,8,166,1,166,4,166,2862,
8,166,11,166,12,166,2863,1,166,1,166,3,166,2868,8,166,1,166,1,166,3,166,
2872,8,166,1,166,4,166,2875,8,166,11,166,12,166,2876,3,166,2879,8,166,
1,166,3,166,2882,8,166,1,166,1,166,3,166,2886,8,166,1,166,3,166,2889,
8,166,1,166,3,166,2892,8,166,1,166,1,166,1,167,1,167,3,167,2898,8,167,
1,167,1,167,3,167,2902,8,167,1,167,1,167,3,167,2906,8,167,1,167,1,167,
1,168,1,168,1,169,1,169,3,169,2914,8,169,1,170,1,170,1,170,3,170,2919,
8,170,1,171,1,171,3,171,2923,8,171,1,171,1,171,1,172,1,172,1,173,1,173,
1,174,1,174,1,175,1,175,1,175,3,175,2936,8,175,1,176,1,176,1,176,1,176,
1,176,3,176,2943,8,176,1,177,1,177,1,178,1,178,1,179,1,179,1,180,1,180,
1,180,0,2,118,172,181,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,
36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,80,
82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,120,
122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,156,
158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,192,
194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,228,
230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,264,
266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,300,
302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,
338,340,342,344,346,348,350,352,354,356,358,360,0,14,4,0,90,90,105,105,
130,130,136,136,2,0,52,53,74,75,2,0,6,6,12,16,1,0,18,19,2,0,20,20,166,
166,2,0,21,22,161,161,1,0,164,165,2,0,86,86,141,141,2,0,67,67,82,82,1,
0,177,178,31,0,47,47,49,49,51,51,54,57,60,60,62,63,65,67,69,70,73,73,
76,76,78,78,83,85,87,88,90,90,94,95,97,97,99,99,101,104,106,109,111,112,
123,128,130,131,133,133,135,135,138,138,140,140,142,142,145,147,151,151,
155,160,162,162,2,0,13,13,26,29,2,0,15,15,30,33,2,0,34,44,166,166,3345,
0,362,1,0,0,0,2,382,1,0,0,0,4,418,1,0,0,0,6,420,1,0,0,0,8,446,1,0,0,0,
10,494,1,0,0,0,12,496,1,0,0,0,14,526,1,0,0,0,16,556,1,0,0,0,18,576,1,
0,0,0,20,582,1,0,0,0,22,633,1,0,0,0,24,635,1,0,0,0,26,649,1,0,0,0,28,
653,1,0,0,0,30,657,1,0,0,0,32,666,1,0,0,0,34,687,1,0,0,0,36,689,1,0,0,
0,38,701,1,0,0,0,40,744,1,0,0,0,42,758,1,0,0,0,44,802,1,0,0,0,46,804,
1,0,0,0,48,810,1,0,0,0,50,868,1,0,0,0,52,939,1,0,0,0,54,953,1,0,0,0,56,
961,1,0,0,0,58,978,1,0,0,0,60,995,1,0,0,0,62,997,1,0,0,0,64,1004,1,0,
0,0,66,1017,1,0,0,0,68,1028,1,0,0,0,70,1048,1,0,0,0,72,1059,1,0,0,0,74,
1061,1,0,0,0,76,1074,1,0,0,0,78,1078,1,0,0,0,80,1082,1,0,0,0,82,1093,
1,0,0,0,84,1107,1,0,0,0,86,1109,1,0,0,0,88,1123,1,0,0,0,90,1127,1,0,0,
0,92,1136,1,0,0,0,94,1142,1,0,0,0,96,1150,1,0,0,0,98,1159,1,0,0,0,100,
1168,1,0,0,0,102,1182,1,0,0,0,104,1186,1,0,0,0,106,1200,1,0,0,0,108,1211,
1,0,0,0,110,1227,1,0,0,0,112,1241,1,0,0,0,114,1255,1,0,0,0,116,1277,1,
0,0,0,118,1305,1,0,0,0,120,1314,1,0,0,0,122,1321,1,0,0,0,124,1329,1,0,
0,0,126,1331,1,0,0,0,128,1336,1,0,0,0,130,1351,1,0,0,0,132,1357,1,0,0,
0,134,1359,1,0,0,0,136,1371,1,0,0,0,138,1382,1,0,0,0,140,1386,1,0,0,0,
142,1390,1,0,0,0,144,1413,1,0,0,0,146,1427,1,0,0,0,148,1431,1,0,0,0,150,
1468,1,0,0,0,152,1474,1,0,0,0,154,1486,1,0,0,0,156,1504,1,0,0,0,158,1510,
1,0,0,0,160,1512,1,0,0,0,162,1562,1,0,0,0,164,1566,1,0,0,0,166,1580,1,
0,0,0,168,1599,1,0,0,0,170,1614,1,0,0,0,172,1630,1,0,0,0,174,1651,1,0,
0,0,176,1661,1,0,0,0,178,1667,1,0,0,0,180,1689,1,0,0,0,182,1723,1,0,0,
0,184,1725,1,0,0,0,186,1737,1,0,0,0,188,1757,1,0,0,0,190,1765,1,0,0,0,
192,1772,1,0,0,0,194,1816,1,0,0,0,196,1825,1,0,0,0,198,1827,1,0,0,0,200,
1842,1,0,0,0,202,1846,1,0,0,0,204,1850,1,0,0,0,206,1857,1,0,0,0,208,1861,
1,0,0,0,210,1886,1,0,0,0,212,1888,1,0,0,0,214,1904,1,0,0,0,216,1906,1,
0,0,0,218,1930,1,0,0,0,220,1980,1,0,0,0,222,1982,1,0,0,0,224,2012,1,0,
0,0,226,2053,1,0,0,0,228,2074,1,0,0,0,230,2098,1,0,0,0,232,2141,1,0,0,
0,234,2157,1,0,0,0,236,2159,1,0,0,0,238,2208,1,0,0,0,240,2220,1,0,0,0,
242,2222,1,0,0,0,244,2224,1,0,0,0,246,2229,1,0,0,0,248,2231,1,0,0,0,250,
2233,1,0,0,0,252,2243,1,0,0,0,254,2253,1,0,0,0,256,2269,1,0,0,0,258,2322,
1,0,0,0,260,2324,1,0,0,0,262,2326,1,0,0,0,264,2340,1,0,0,0,266,2354,1,
0,0,0,268,2369,1,0,0,0,270,2371,1,0,0,0,272,2386,1,0,0,0,274,2388,1,0,
0,0,276,2403,1,0,0,0,278,2405,1,0,0,0,280,2419,1,0,0,0,282,2448,1,0,0,
0,284,2461,1,0,0,0,286,2469,1,0,0,0,288,2483,1,0,0,0,290,2491,1,0,0,0,
292,2501,1,0,0,0,294,2520,1,0,0,0,296,2578,1,0,0,0,298,2580,1,0,0,0,300,
2584,1,0,0,0,302,2596,1,0,0,0,304,2598,1,0,0,0,306,2600,1,0,0,0,308,2621,
1,0,0,0,310,2628,1,0,0,0,312,2653,1,0,0,0,314,2664,1,0,0,0,316,2751,1,
0,0,0,318,2753,1,0,0,0,320,2768,1,0,0,0,322,2770,1,0,0,0,324,2807,1,0,
0,0,326,2809,1,0,0,0,328,2818,1,0,0,0,330,2848,1,0,0,0,332,2878,1,0,0,
0,334,2895,1,0,0,0,336,2909,1,0,0,0,338,2913,1,0,0,0,340,2915,1,0,0,0,
342,2920,1,0,0,0,344,2926,1,0,0,0,346,2928,1,0,0,0,348,2930,1,0,0,0,350,
2932,1,0,0,0,352,2942,1,0,0,0,354,2944,1,0,0,0,356,2946,1,0,0,0,358,2948,
1,0,0,0,360,2950,1,0,0,0,362,373,3,2,1,0,363,365,5,183,0,0,364,363,1,
0,0,0,364,365,1,0,0,0,365,366,1,0,0,0,366,368,5,1,0,0,367,369,5,183,0,
0,368,367,1,0,0,0,368,369,1,0,0,0,369,370,1,0,0,0,370,372,3,2,1,0,371,
364,1,0,0,0,372,375,1,0,0,0,373,371,1,0,0,0,373,374,1,0,0,0,374,377,1,
0,0,0,375,373,1,0,0,0,376,378,5,183,0,0,377,376,1,0,0,0,377,378,1,0,0,
0,378,379,1,0,0,0,379,380,5,0,0,1,380,1,1,0,0,0,381,383,3,124,62,0,382,
381,1,0,0,0,382,383,1,0,0,0,383,385,1,0,0,0,384,386,5,183,0,0,385,384,
1,0,0,0,385,386,1,0,0,0,386,387,1,0,0,0,387,392,3,4,2,0,388,390,5,183,
0,0,389,388,1,0,0,0,389,390,1,0,0,0,390,391,1,0,0,0,391,393,5,1,0,0,392,
389,1,0,0,0,392,393,1,0,0,0,393,3,1,0,0,0,394,419,3,142,71,0,395,419,
3,64,32,0,396,419,3,66,33,0,397,419,3,48,24,0,398,419,3,50,25,0,399,419,
3,56,28,0,400,419,3,58,29,0,401,419,3,80,40,0,402,419,3,82,41,0,403,419,
3,6,3,0,404,419,3,12,6,0,405,419,3,14,7,0,406,419,3,34,17,0,407,419,3,
38,19,0,408,419,3,36,18,0,409,419,3,130,65,0,410,419,3,132,66,0,411,419,
3,16,8,0,412,419,3,18,9,0,413,419,3,20,10,0,414,419,3,26,13,0,415,419,
3,28,14,0,416,419,3,30,15,0,417,419,3,32,16,0,418,394,1,0,0,0,418,395,
1,0,0,0,418,396,1,0,0,0,418,397,1,0,0,0,418,398,1,0,0,0,418,399,1,0,0,
0,418,400,1,0,0,0,418,401,1,0,0,0,418,402,1,0,0,0,418,403,1,0,0,0,418,
404,1,0,0,0,418,405,1,0,0,0,418,406,1,0,0,0,418,407,1,0,0,0,418,408,1,
0,0,0,418,409,1,0,0,0,418,410,1,0,0,0,418,411,1,0,0,0,418,412,1,0,0,0,
418,413,1,0,0,0,418,414,1,0,0,0,418,415,1,0,0,0,418,416,1,0,0,0,418,417,
1,0,0,0,419,5,1,0,0,0,420,421,5,66,0,0,421,422,5,183,0,0,422,424,3,350,
175,0,423,425,3,8,4,0,424,423,1,0,0,0,424,425,1,0,0,0,425,426,1,0,0,0,
426,427,5,183,0,0,427,428,5,87,0,0,428,429,5,183,0,0,429,443,3,10,5,0,
430,432,5,183,0,0,431,430,1,0,0,0,431,432,1,0,0,0,432,433,1,0,0,0,433,
435,5,2,0,0,434,436,5,183,0,0,435,434,1,0,0,0,435,436,1,0,0,0,436,437,
1,0,0,0,437,439,3,24,12,0,438,440,5,183,0,0,439,438,1,0,0,0,439,440,1,
0,0,0,440,441,1,0,0,0,441,442,5,3,0,0,442,444,1,0,0,0,443,431,1,0,0,0,
443,444,1,0,0,0,444,7,1,0,0,0,445,447,5,183,0,0,446,445,1,0,0,0,446,447,
1,0,0,0,447,448,1,0,0,0,448,450,5,2,0,0,449,451,5,183,0,0,450,449,1,0,
0,0,450,451,1,0,0,0,451,469,1,0,0,0,452,463,3,350,175,0,453,455,5,183,
0,0,454,453,1,0,0,0,454,455,1,0,0,0,455,456,1,0,0,0,456,458,5,4,0,0,457,
459,5,183,0,0,458,457,1,0,0,0,458,459,1,0,0,0,459,460,1,0,0,0,460,462,
3,350,175,0,461,454,1,0,0,0,462,465,1,0,0,0,463,461,1,0,0,0,463,464,1,
0,0,0,464,467,1,0,0,0,465,463,1,0,0,0,466,468,5,183,0,0,467,466,1,0,0,
0,467,468,1,0,0,0,468,470,1,0,0,0,469,452,1,0,0,0,469,470,1,0,0,0,470,
471,1,0,0,0,471,472,5,3,0,0,472,9,1,0,0,0,473,495,3,44,22,0,474,476,5,
2,0,0,475,477,5,183,0,0,476,475,1,0,0,0,476,477,1,0,0,0,477,478,1,0,0,
0,478,480,3,142,71,0,479,481,5,183,0,0,480,479,1,0,0,0,480,481,1,0,0,
0,481,482,1,0,0,0,482,483,5,3,0,0,483,495,1,0,0,0,484,495,3,340,170,0,
485,495,3,336,168,0,486,487,3,336,168,0,487,489,5,5,0,0,488,490,5,183,
0,0,489,488,1,0,0,0,489,490,1,0,0,0,490,491,1,0,0,0,491,492,3,350,175,
0,492,495,1,0,0,0,493,495,3,316,158,0,494,473,1,0,0,0,494,474,1,0,0,0,
494,484,1,0,0,0,494,485,1,0,0,0,494,486,1,0,0,0,494,493,1,0,0,0,495,11,
1,0,0,0,496,497,5,66,0,0,497,498,5,183,0,0,498,499,3,350,175,0,499,500,
5,183,0,0,500,501,5,87,0,0,501,502,5,183,0,0,502,504,5,2,0,0,503,505,
5,183,0,0,504,503,1,0,0,0,504,505,1,0,0,0,505,506,1,0,0,0,506,517,5,168,
0,0,507,509,5,183,0,0,508,507,1,0,0,0,508,509,1,0,0,0,509,510,1,0,0,0,
510,512,5,4,0,0,511,513,5,183,0,0,512,511,1,0,0,0,512,513,1,0,0,0,513,
514,1,0,0,0,514,516,5,168,0,0,515,508,1,0,0,0,516,519,1,0,0,0,517,515,
1,0,0,0,517,518,1,0,0,0,518,520,1,0,0,0,519,517,1,0,0,0,520,521,5,3,0,
0,521,522,5,183,0,0,522,523,5,56,0,0,523,524,5,183,0,0,524,525,5,61,0,
0,525,13,1,0,0,0,526,527,5,66,0,0,527,528,5,183,0,0,528,530,5,2,0,0,529,
531,5,183,0,0,530,529,1,0,0,0,530,531,1,0,0,0,531,532,1,0,0,0,532,534,
3,142,71,0,533,535,5,183,0,0,534,533,1,0,0,0,534,535,1,0,0,0,535,536,
1,0,0,0,536,537,5,3,0,0,537,538,5,183,0,0,538,539,5,138,0,0,539,540,5,
183,0,0,540,554,5,168,0,0,541,543,5,183,0,0,542,541,1,0,0,0,542,543,1,
0,0,0,543,544,1,0,0,0,544,546,5,2,0,0,545,547,5,183,0,0,546,545,1,0,0,
0,546,547,1,0,0,0,547,548,1,0,0,0,548,550,3,24,12,0,549,551,5,183,0,0,
550,549,1,0,0,0,550,551,1,0,0,0,551,552,1,0,0,0,552,553,5,3,0,0,553,555,
1,0,0,0,554,542,1,0,0,0,554,555,1,0,0,0,555,15,1,0,0,0,556,557,5,84,0,
0,557,558,5,183,0,0,558,559,5,70,0,0,559,560,5,183,0,0,560,574,5,168,
0,0,561,563,5,183,0,0,562,561,1,0,0,0,562,563,1,0,0,0,563,564,1,0,0,0,
564,566,5,2,0,0,565,567,5,183,0,0,566,565,1,0,0,0,566,567,1,0,0,0,567,
568,1,0,0,0,568,570,3,24,12,0,569,571,5,183,0,0,570,569,1,0,0,0,570,571,
1,0,0,0,571,572,1,0,0,0,572,573,5,3,0,0,573,575,1,0,0,0,574,562,1,0,0,
0,574,575,1,0,0,0,575,17,1,0,0,0,576,577,5,94,0,0,577,578,5,183,0,0,578,
579,5,70,0,0,579,580,5,183,0,0,580,581,5,168,0,0,581,19,1,0,0,0,582,583,
5,54,0,0,583,584,5,183,0,0,584,589,5,168,0,0,585,586,5,183,0,0,586,587,
5,51,0,0,587,588,5,183,0,0,588,590,3,350,175,0,589,585,1,0,0,0,589,590,
1,0,0,0,590,591,1,0,0,0,591,592,5,183,0,0,592,594,5,2,0,0,593,595,5,183,
0,0,594,593,1,0,0,0,594,595,1,0,0,0,595,596,1,0,0,0,596,597,5,71,0,0,
597,598,5,183,0,0,598,607,3,352,176,0,599,601,5,183,0,0,600,599,1,0,0,
0,600,601,1,0,0,0,601,602,1,0,0,0,602,604,5,4,0,0,603,605,5,183,0,0,604,
603,1,0,0,0,604,605,1,0,0,0,605,606,1,0,0,0,606,608,3,24,12,0,607,600,
1,0,0,0,607,608,1,0,0,0,608,610,1,0,0,0,609,611,5,183,0,0,610,609,1,0,
0,0,610,611,1,0,0,0,611,612,1,0,0,0,612,613,5,3,0,0,613,21,1,0,0,0,614,
628,3,352,176,0,615,617,5,183,0,0,616,615,1,0,0,0,616,617,1,0,0,0,617,
618,1,0,0,0,618,620,5,6,0,0,619,621,5,183,0,0,620,619,1,0,0,0,620,621,
1,0,0,0,621,629,1,0,0,0,622,624,5,183,0,0,623,622,1,0,0,0,624,627,1,0,
0,0,625,623,1,0,0,0,625,626,1,0,0,0,626,629,1,0,0,0,627,625,1,0,0,0,628,
616,1,0,0,0,628,625,1,0,0,0,629,630,1,0,0,0,630,631,3,302,151,0,631,634,
1,0,0,0,632,634,3,352,176,0,633,614,1,0,0,0,633,632,1,0,0,0,634,23,1,
0,0,0,635,646,3,22,11,0,636,638,5,183,0,0,637,636,1,0,0,0,637,638,1,0,
0,0,638,639,1,0,0,0,639,641,5,4,0,0,640,642,5,183,0,0,641,640,1,0,0,0,
641,642,1,0,0,0,642,643,1,0,0,0,643,645,3,22,11,0,644,637,1,0,0,0,645,
648,1,0,0,0,646,644,1,0,0,0,646,647,1,0,0,0,647,25,1,0,0,0,648,646,1,
0,0,0,649,650,5,76,0,0,650,651,5,183,0,0,651,652,3,350,175,0,652,27,1,
0,0,0,653,654,5,147,0,0,654,655,5,183,0,0,655,656,3,350,175,0,656,29,
1,0,0,0,657,658,5,68,0,0,658,659,5,183,0,0,659,660,5,90,0,0,660,661,5,
183,0,0,661,664,3,350,175,0,662,663,5,183,0,0,663,665,5,46,0,0,664,662,
1,0,0,0,664,665,1,0,0,0,665,31,1,0,0,0,666,667,5,147,0,0,667,668,5,183,
0,0,668,669,5,90,0,0,669,670,5,183,0,0,670,671,3,350,175,0,671,33,1,0,
0,0,672,673,5,57,0,0,673,674,5,183,0,0,674,676,3,352,176,0,675,677,5,
183,0,0,676,675,1,0,0,0,676,677,1,0,0,0,677,678,1,0,0,0,678,680,5,6,0,
0,679,681,5,183,0,0,680,679,1,0,0,0,680,681,1,0,0,0,681,682,1,0,0,0,682,
683,3,248,124,0,683,688,1,0,0,0,684,685,5,57,0,0,685,686,5,183,0,0,686,
688,3,316,158,0,687,672,1,0,0,0,687,684,1,0,0,0,688,35,1,0,0,0,689,690,
5,62,0,0,690,691,5,183,0,0,691,692,5,116,0,0,692,693,5,183,0,0,693,694,
5,136,0,0,694,695,5,183,0,0,695,696,3,350,175,0,696,697,5,183,0,0,697,
698,5,99,0,0,698,699,5,183,0,0,699,700,5,168,0,0,700,37,1,0,0,0,701,702,
5,68,0,0,702,703,5,183,0,0,703,704,5,105,0,0,704,705,5,183,0,0,705,707,
3,318,159,0,706,708,5,183,0,0,707,706,1,0,0,0,707,708,1,0,0,0,708,709,
1,0,0,0,709,711,5,2,0,0,710,712,5,183,0,0,711,710,1,0,0,0,711,712,1,0,
0,0,712,714,1,0,0,0,713,715,3,40,20,0,714,713,1,0,0,0,714,715,1,0,0,0,
715,717,1,0,0,0,716,718,5,183,0,0,717,716,1,0,0,0,717,718,1,0,0,0,718,
720,1,0,0,0,719,721,3,42,21,0,720,719,1,0,0,0,720,721,1,0,0,0,721,732,
1,0,0,0,722,724,5,183,0,0,723,722,1,0,0,0,723,724,1,0,0,0,724,725,1,0,
0,0,725,727,5,4,0,0,726,728,5,183,0,0,727,726,1,0,0,0,727,728,1,0,0,0,
728,729,1,0,0,0,729,731,3,42,21,0,730,723,1,0,0,0,731,734,1,0,0,0,732,
730,1,0,0,0,732,733,1,0,0,0,733,736,1,0,0,0,734,732,1,0,0,0,735,737,5,
183,0,0,736,735,1,0,0,0,736,737,1,0,0,0,737,738,1,0,0,0,738,739,5,3,0,
0,739,740,5,183,0,0,740,741,5,51,0,0,741,742,5,183,0,0,742,743,3,248,
124,0,743,39,1,0,0,0,744,755,3,352,176,0,745,747,5,183,0,0,746,745,1,
0,0,0,746,747,1,0,0,0,747,748,1,0,0,0,748,750,5,4,0,0,749,751,5,183,0,
0,750,749,1,0,0,0,750,751,1,0,0,0,751,752,1,0,0,0,752,754,3,352,176,0,
753,746,1,0,0,0,754,757,1,0,0,0,755,753,1,0,0,0,755,756,1,0,0,0,756,41,
1,0,0,0,757,755,1,0,0,0,758,760,3,352,176,0,759,761,5,183,0,0,760,759,
1,0,0,0,760,761,1,0,0,0,761,762,1,0,0,0,762,763,5,164,0,0,763,765,5,6,
0,0,764,766,5,183,0,0,765,764,1,0,0,0,765,766,1,0,0,0,766,767,1,0,0,0,
767,768,3,302,151,0,768,43,1,0,0,0,769,771,5,7,0,0,770,772,5,183,0,0,
771,770,1,0,0,0,771,772,1,0,0,0,772,773,1,0,0,0,773,784,5,168,0,0,774,
776,5,183,0,0,775,774,1,0,0,0,775,776,1,0,0,0,776,777,1,0,0,0,777,779,
5,4,0,0,778,780,5,183,0,0,779,778,1,0,0,0,779,780,1,0,0,0,780,781,1,0,
0,0,781,783,5,168,0,0,782,775,1,0,0,0,783,786,1,0,0,0,784,782,1,0,0,0,
784,785,1,0,0,0,785,787,1,0,0,0,786,784,1,0,0,0,787,803,5,8,0,0,788,803,
5,168,0,0,789,791,5,89,0,0,790,792,5,183,0,0,791,790,1,0,0,0,791,792,
1,0,0,0,792,793,1,0,0,0,793,795,5,2,0,0,794,796,5,183,0,0,795,794,1,0,
0,0,795,796,1,0,0,0,796,797,1,0,0,0,797,799,5,168,0,0,798,800,5,183,0,
0,799,798,1,0,0,0,799,800,1,0,0,0,800,801,1,0,0,0,801,803,5,3,0,0,802,
769,1,0,0,0,802,788,1,0,0,0,802,789,1,0,0,0,803,45,1,0,0,0,804,805,5,
95,0,0,805,806,5,183,0,0,806,807,5,113,0,0,807,808,5,183,0,0,808,809,
5,82,0,0,809,47,1,0,0,0,810,811,5,68,0,0,811,812,5,183,0,0,812,813,5,
112,0,0,813,814,5,183,0,0,814,815,5,136,0,0,815,819,5,183,0,0,816,817,
3,46,23,0,817,818,5,183,0,0,818,820,1,0,0,0,819,816,1,0,0,0,819,820,1,
0,0,0,820,821,1,0,0,0,821,849,3,350,175,0,822,824,5,183,0,0,823,822,1,
0,0,0,823,824,1,0,0,0,824,825,1,0,0,0,825,827,5,2,0,0,826,828,5,183,0,
0,827,826,1,0,0,0,827,828,1,0,0,0,828,829,1,0,0,0,829,831,3,104,52,0,
830,832,5,183,0,0,831,830,1,0,0,0,831,832,1,0,0,0,832,838,1,0,0,0,833,
835,5,4,0,0,834,836,5,183,0,0,835,834,1,0,0,0,835,836,1,0,0,0,836,837,
1,0,0,0,837,839,3,108,54,0,838,833,1,0,0,0,838,839,1,0,0,0,839,841,1,
0,0,0,840,842,5,183,0,0,841,840,1,0,0,0,841,842,1,0,0,0,842,843,1,0,0,
0,843,844,5,3,0,0,844,850,1,0,0,0,845,846,5,183,0,0,846,847,5,51,0,0,
847,848,5,183,0,0,848,850,3,142,71,0,849,823,1,0,0,0,849,845,1,0,0,0,
850,866,1,0,0,0,851,852,5,183,0,0,852,854,5,150,0,0,853,855,5,183,0,0,
854,853,1,0,0,0,854,855,1,0,0,0,855,856,1,0,0,0,856,858,5,2,0,0,857,859,
5,183,0,0,858,857,1,0,0,0,858,859,1,0,0,0,859,860,1,0,0,0,860,862,3,24,
12,0,861,863,5,183,0,0,862,861,1,0,0,0,862,863,1,0,0,0,863,864,1,0,0,
0,864,865,5,3,0,0,865,867,1,0,0,0,866,851,1,0,0,0,866,867,1,0,0,0,867,
49,1,0,0,0,868,869,5,68,0,0,869,870,5,183,0,0,870,871,5,125,0,0,871,872,
5,183,0,0,872,875,5,136,0,0,873,874,5,183,0,0,874,876,5,91,0,0,875,873,
1,0,0,0,875,876,1,0,0,0,876,879,1,0,0,0,877,878,5,183,0,0,878,880,3,46,
23,0,879,877,1,0,0,0,879,880,1,0,0,0,880,881,1,0,0,0,881,882,5,183,0,
0,882,884,3,350,175,0,883,885,5,183,0,0,884,883,1,0,0,0,884,885,1,0,0,
0,885,886,1,0,0,0,886,888,5,2,0,0,887,889,5,183,0,0,888,887,1,0,0,0,888,
889,1,0,0,0,889,890,1,0,0,0,890,892,3,52,26,0,891,893,5,183,0,0,892,891,
1,0,0,0,892,893,1,0,0,0,893,920,1,0,0,0,894,896,5,4,0,0,895,897,5,183,
0,0,896,895,1,0,0,0,896,897,1,0,0,0,897,898,1,0,0,0,898,900,3,104,52,
0,899,901,5,183,0,0,900,899,1,0,0,0,900,901,1,0,0,0,901,903,1,0,0,0,902,
894,1,0,0,0,902,903,1,0,0,0,903,912,1,0,0,0,904,906,5,4,0,0,905,907,5,
183,0,0,906,905,1,0,0,0,906,907,1,0,0,0,907,908,1,0,0,0,908,910,3,352,
176,0,909,911,5,183,0,0,910,909,1,0,0,0,910,911,1,0,0,0,911,913,1,0,0,
0,912,904,1,0,0,0,912,913,1,0,0,0,913,914,1,0,0,0,914,921,5,3,0,0,915,
916,5,3,0,0,916,917,5,183,0,0,917,918,5,51,0,0,918,919,5,183,0,0,919,
921,3,142,71,0,920,902,1,0,0,0,920,915,1,0,0,0,921,937,1,0,0,0,922,923,
5,183,0,0,923,925,5,150,0,0,924,926,5,183,0,0,925,924,1,0,0,0,925,926,
1,0,0,0,926,927,1,0,0,0,927,929,5,2,0,0,928,930,5,183,0,0,929,928,1,0,
0,0,929,930,1,0,0,0,930,931,1,0,0,0,931,933,3,24,12,0,932,934,5,183,0,
0,933,932,1,0,0,0,933,934,1,0,0,0,934,935,1,0,0,0,935,936,5,3,0,0,936,
938,1,0,0,0,937,922,1,0,0,0,937,938,1,0,0,0,938,51,1,0,0,0,939,950,3,
54,27,0,940,942,5,183,0,0,941,940,1,0,0,0,941,942,1,0,0,0,942,943,1,0,
0,0,943,945,5,4,0,0,944,946,5,183,0,0,945,944,1,0,0,0,945,946,1,0,0,0,
946,947,1,0,0,0,947,949,3,54,27,0,948,941,1,0,0,0,949,952,1,0,0,0,950,
948,1,0,0,0,950,951,1,0,0,0,951,53,1,0,0,0,952,950,1,0,0,0,953,954,5,
87,0,0,954,955,5,183,0,0,955,956,3,350,175,0,956,957,5,183,0,0,957,958,
5,138,0,0,958,959,5,183,0,0,959,960,3,350,175,0,960,55,1,0,0,0,961,962,
5,68,0,0,962,963,5,183,0,0,963,964,5,130,0,0,964,968,5,183,0,0,965,966,
3,46,23,0,966,967,5,183,0,0,967,969,1,0,0,0,968,965,1,0,0,0,968,969,1,
0,0,0,969,970,1,0,0,0,970,975,3,350,175,0,971,972,5,183,0,0,972,974,3,
60,30,0,973,971,1,0,0,0,974,977,1,0,0,0,975,973,1,0,0,0,975,976,1,0,0,
0,976,57,1,0,0,0,977,975,1,0,0,0,978,979,5,68,0,0,979,980,5,183,0,0,980,
981,5,142,0,0,981,982,5,183,0,0,982,983,3,350,175,0,983,984,5,183,0,0,
984,985,5,51,0,0,985,986,5,183,0,0,986,988,3,118,59,0,987,989,5,183,0,
0,988,987,1,0,0,0,988,989,1,0,0,0,989,59,1,0,0,0,990,996,3,68,34,0,991,
996,3,70,35,0,992,996,3,72,36,0,993,996,3,74,37,0,994,996,3,76,38,0,995,
990,1,0,0,0,995,991,1,0,0,0,995,992,1,0,0,0,995,993,1,0,0,0,995,994,1,
0,0,0,996,61,1,0,0,0,997,998,5,183,0,0,998,999,5,150,0,0,999,1000,5,183,
0,0,1000,1001,5,157,0,0,1001,1002,5,183,0,0,1002,1003,5,168,0,0,1003,
63,1,0,0,0,1004,1005,5,68,0,0,1005,1006,5,183,0,0,1006,1007,5,156,0,0,
1007,1011,5,183,0,0,1008,1009,3,46,23,0,1009,1010,5,183,0,0,1010,1012,
1,0,0,0,1011,1008,1,0,0,0,1011,1012,1,0,0,0,1012,1013,1,0,0,0,1013,1015,
3,336,168,0,1014,1016,3,62,31,0,1015,1014,1,0,0,0,1015,1016,1,0,0,0,1016,
65,1,0,0,0,1017,1018,5,68,0,0,1018,1019,5,183,0,0,1019,1020,5,158,0,0,
1020,1024,5,183,0,0,1021,1022,3,46,23,0,1022,1023,5,183,0,0,1023,1025,
1,0,0,0,1024,1021,1,0,0,0,1024,1025,1,0,0,0,1025,1026,1,0,0,0,1026,1027,
3,336,168,0,1027,67,1,0,0,0,1028,1029,5,97,0,0,1029,1032,5,183,0,0,1030,
1031,5,56,0,0,1031,1033,5,183,0,0,1032,1030,1,0,0,0,1032,1033,1,0,0,0,
1033,1035,1,0,0,0,1034,1036,5,166,0,0,1035,1034,1,0,0,0,1035,1036,1,0,
0,0,1036,1037,1,0,0,0,1037,1038,3,346,173,0,1038,69,1,0,0,0,1039,1040,
5,111,0,0,1040,1041,5,183,0,0,1041,1049,5,109,0,0,1042,1043,5,109,0,0,
1043,1045,5,183,0,0,1044,1046,5,166,0,0,1045,1044,1,0,0,0,1045,1046,1,
0,0,0,1046,1047,1,0,0,0,1047,1049,3,346,173,0,1048,1039,1,0,0,0,1048,
1042,1,0,0,0,1049,71,1,0,0,0,1050,1051,5,111,0,0,1051,1052,5,183,0,0,
1052,1060,5,107,0,0,1053,1054,5,107,0,0,1054,1056,5,183,0,0,1055,1057,
5,166,0,0,1056,1055,1,0,0,0,1056,1057,1,0,0,0,1057,1058,1,0,0,0,1058,
1060,3,346,173,0,1059,1050,1,0,0,0,1059,1053,1,0,0,0,1060,73,1,0,0,0,
1061,1062,5,133,0,0,1062,1065,5,183,0,0,1063,1064,5,150,0,0,1064,1066,
5,183,0,0,1065,1063,1,0,0,0,1065,1066,1,0,0,0,1066,1068,1,0,0,0,1067,
1069,5,166,0,0,1068,1067,1,0,0,0,1068,1069,1,0,0,0,1069,1070,1,0,0,0,
1070,1071,3,346,173,0,1071,75,1,0,0,0,1072,1073,5,111,0,0,1073,1075,5,
183,0,0,1074,1072,1,0,0,0,1074,1075,1,0,0,0,1075,1076,1,0,0,0,1076,1077,
5,69,0,0,1077,77,1,0,0,0,1078,1079,5,95,0,0,1079,1080,5,183,0,0,1080,
1081,5,82,0,0,1081,79,1,0,0,0,1082,1083,5,78,0,0,1083,1084,5,183,0,0,
1084,1085,7,0,0,0,1085,1089,5,183,0,0,1086,1087,3,78,39,0,1087,1088,5,
183,0,0,1088,1090,1,0,0,0,1089,1086,1,0,0,0,1089,1090,1,0,0,0,1090,1091,
1,0,0,0,1091,1092,3,350,175,0,1092,81,1,0,0,0,1093,1094,5,49,0,0,1094,
1095,5,183,0,0,1095,1096,5,136,0,0,1096,1097,5,183,0,0,1097,1098,3,350,
175,0,1098,1099,5,183,0,0,1099,1100,3,84,42,0,1100,83,1,0,0,0,1101,1108,
3,86,43,0,1102,1108,3,90,45,0,1103,1108,3,92,46,0,1104,1108,3,94,47,0,
1105,1108,3,96,48,0,1106,1108,3,98,49,0,1107,1101,1,0,0,0,1107,1102,1,
0,0,0,1107,1103,1,0,0,0,1107,1104,1,0,0,0,1107,1105,1,0,0,0,1107,1106,
1,0,0,0,1108,85,1,0,0,0,1109,1110,5,47,0,0,1110,1114,5,183,0,0,1111,1112,
3,46,23,0,1112,1113,5,183,0,0,1113,1115,1,0,0,0,1114,1111,1,0,0,0,1114,
1115,1,0,0,0,1115,1116,1,0,0,0,1116,1117,3,344,172,0,1117,1118,5,183,
0,0,1118,1121,3,118,59,0,1119,1120,5,183,0,0,1120,1122,3,88,44,0,1121,
1119,1,0,0,0,1121,1122,1,0,0,0,1122,87,1,0,0,0,1123,1124,5,72,0,0,1124,
1125,5,183,0,0,1125,1126,3,248,124,0,1126,89,1,0,0,0,1127,1128,5,78,0,
0,1128,1132,5,183,0,0,1129,1130,3,78,39,0,1130,1131,5,183,0,0,1131,1133,
1,0,0,0,1132,1129,1,0,0,0,1132,1133,1,0,0,0,1133,1134,1,0,0,0,1134,1135,
3,344,172,0,1135,91,1,0,0,0,1136,1137,5,126,0,0,1137,1138,5,183,0,0,1138,
1139,5,138,0,0,1139,1140,5,183,0,0,1140,1141,3,350,175,0,1141,93,1,0,
0,0,1142,1143,5,126,0,0,1143,1144,5,183,0,0,1144,1145,3,344,172,0,1145,
1146,5,183,0,0,1146,1147,5,138,0,0,1147,1148,5,183,0,0,1148,1149,3,344,
172,0,1149,95,1,0,0,0,1150,1151,5,47,0,0,1151,1155,5,183,0,0,1152,1153,
3,46,23,0,1153,1154,5,183,0,0,1154,1156,1,0,0,0,1155,1152,1,0,0,0,1155,
1156,1,0,0,0,1156,1157,1,0,0,0,1157,1158,3,54,27,0,1158,97,1,0,0,0,1159,
1160,5,78,0,0,1160,1164,5,183,0,0,1161,1162,3,78,39,0,1162,1163,5,183,
0,0,1163,1165,1,0,0,0,1164,1161,1,0,0,0,1164,1165,1,0,0,0,1165,1166,1,
0,0,0,1166,1167,3,54,27,0,1167,99,1,0,0,0,1168,1179,3,102,51,0,1169,1171,
5,183,0,0,1170,1169,1,0,0,0,1170,1171,1,0,0,0,1171,1172,1,0,0,0,1172,
1174,5,4,0,0,1173,1175,5,183,0,0,1174,1173,1,0,0,0,1174,1175,1,0,0,0,
1175,1176,1,0,0,0,1176,1178,3,102,51,0,1177,1170,1,0,0,0,1178,1181,1,
0,0,0,1179,1177,1,0,0,0,1179,1180,1,0,0,0,1180,101,1,0,0,0,1181,1179,
1,0,0,0,1182,1183,3,344,172,0,1183,1184,5,183,0,0,1184,1185,3,118,59,
0,1185,103,1,0,0,0,1186,1197,3,106,53,0,1187,1189,5,183,0,0,1188,1187,
1,0,0,0,1188,1189,1,0,0,0,1189,1190,1,0,0,0,1190,1192,5,4,0,0,1191,1193,
5,183,0,0,1192,1191,1,0,0,0,1192,1193,1,0,0,0,1193,1194,1,0,0,0,1194,
1196,3,106,53,0,1195,1188,1,0,0,0,1196,1199,1,0,0,0,1197,1195,1,0,0,0,
1197,1198,1,0,0,0,1198,105,1,0,0,0,1199,1197,1,0,0,0,1200,1203,3,102,
51,0,1201,1202,5,183,0,0,1202,1204,3,88,44,0,1203,1201,1,0,0,0,1203,1204,
1,0,0,0,1204,1209,1,0,0,0,1205,1206,5,183,0,0,1206,1207,5,121,0,0,1207,
1208,5,183,0,0,1208,1210,5,101,0,0,1209,1205,1,0,0,0,1209,1210,1,0,0,
0,1210,107,1,0,0,0,1211,1212,5,121,0,0,1212,1213,5,183,0,0,1213,1215,
5,101,0,0,1214,1216,5,183,0,0,1215,1214,1,0,0,0,1215,1216,1,0,0,0,1216,
1217,1,0,0,0,1217,1219,5,2,0,0,1218,1220,5,183,0,0,1219,1218,1,0,0,0,
1219,1220,1,0,0,0,1220,1221,1,0,0,0,1221,1223,3,344,172,0,1222,1224,5,
183,0,0,1223,1222,1,0,0,0,1223,1224,1,0,0,0,1224,1225,1,0,0,0,1225,1226,
5,3,0,0,1226,109,1,0,0,0,1227,1229,5,143,0,0,1228,1230,5,183,0,0,1229,
1228,1,0,0,0,1229,1230,1,0,0,0,1230,1231,1,0,0,0,1231,1233,5,2,0,0,1232,
1234,5,183,0,0,1233,1232,1,0,0,0,1233,1234,1,0,0,0,1234,1235,1,0,0,0,
1235,1237,3,100,50,0,1236,1238,5,183,0,0,1237,1236,1,0,0,0,1237,1238,
1,0,0,0,1238,1239,1,0,0,0,1239,1240,5,3,0,0,1240,111,1,0,0,0,1241,1243,
5,135,0,0,1242,1244,5,183,0,0,1243,1242,1,0,0,0,1243,1244,1,0,0,0,1244,
1245,1,0,0,0,1245,1247,5,2,0,0,1246,1248,5,183,0,0,1247,1246,1,0,0,0,
1247,1248,1,0,0,0,1248,1249,1,0,0,0,1249,1251,3,100,50,0,1250,1252,5,
183,0,0,1251,1250,1,0,0,0,1251,1252,1,0,0,0,1252,1253,1,0,0,0,1253,1254,
5,3,0,0,1254,113,1,0,0,0,1255,1257,5,159,0,0,1256,1258,5,183,0,0,1257,
1256,1,0,0,0,1257,1258,1,0,0,0,1258,1259,1,0,0,0,1259,1261,5,2,0,0,1260,
1262,5,183,0,0,1261,1260,1,0,0,0,1261,1262,1,0,0,0,1262,1263,1,0,0,0,
1263,1265,3,118,59,0,1264,1266,5,183,0,0,1265,1264,1,0,0,0,1265,1266,
1,0,0,0,1266,1267,1,0,0,0,1267,1269,5,4,0,0,1268,1270,5,183,0,0,1269,
1268,1,0,0,0,1269,1270,1,0,0,0,1270,1271,1,0,0,0,1271,1273,3,118,59,0,
1272,1274,5,183,0,0,1273,1272,1,0,0,0,1273,1274,1,0,0,0,1274,1275,1,0,
0,0,1275,1276,5,3,0,0,1276,115,1,0,0,0,1277,1279,5,160,0,0,1278,1280,
5,183,0,0,1279,1278,1,0,0,0,1279,1280,1,0,0,0,1280,1281,1,0,0,0,1281,
1283,5,2,0,0,1282,1284,5,183,0,0,1283,1282,1,0,0,0,1283,1284,1,0,0,0,
1284,1285,1,0,0,0,1285,1287,3,346,173,0,1286,1288,5,183,0,0,1287,1286,
1,0,0,0,1287,1288,1,0,0,0,1288,1289,1,0,0,0,1289,1291,5,4,0,0,1290,1292,
5,183,0,0,1291,1290,1,0,0,0,1291,1292,1,0,0,0,1292,1293,1,0,0,0,1293,
1295,3,346,173,0,1294,1296,5,183,0,0,1295,1294,1,0,0,0,1295,1296,1,0,
0,0,1296,1297,1,0,0,0,1297,1298,5,3,0,0,1298,117,1,0,0,0,1299,1300,6,
59,-1,0,1300,1306,3,352,176,0,1301,1306,3,110,55,0,1302,1306,3,112,56,
0,1303,1306,3,114,57,0,1304,1306,3,116,58,0,1305,1299,1,0,0,0,1305,1301,
1,0,0,0,1305,1302,1,0,0,0,1305,1303,1,0,0,0,1305,1304,1,0,0,0,1306,1311,
1,0,0,0,1307,1308,10,5,0,0,1308,1310,3,120,60,0,1309,1307,1,0,0,0,1310,
1313,1,0,0,0,1311,1309,1,0,0,0,1311,1312,1,0,0,0,1312,119,1,0,0,0,1313,
1311,1,0,0,0,1314,1318,3,122,61,0,1315,1317,3,122,61,0,1316,1315,1,0,
0,0,1317,1320,1,0,0,0,1318,1316,1,0,0,0,1318,1319,1,0,0,0,1319,121,1,
0,0,0,1320,1318,1,0,0,0,1321,1323,5,7,0,0,1322,1324,3,346,173,0,1323,
1322,1,0,0,0,1323,1324,1,0,0,0,1324,1325,1,0,0,0,1325,1326,5,8,0,0,1326,
123,1,0,0,0,1327,1330,3,126,63,0,1328,1330,3,128,64,0,1329,1327,1,0,0,
0,1329,1328,1,0,0,0,1330,125,1,0,0,0,1331,1334,5,83,0,0,1332,1333,5,183,
0,0,1333,1335,5,104,0,0,1334,1332,1,0,0,0,1334,1335,1,0,0,0,1335,127,
1,0,0,0,1336,1337,5,122,0,0,1337,129,1,0,0,0,1338,1339,5,55,0,0,1339,
1340,5,183,0,0,1340,1352,5,140,0,0,1341,1342,5,55,0,0,1342,1343,5,183,
0,0,1343,1344,5,140,0,0,1344,1345,5,183,0,0,1345,1346,5,124,0,0,1346,
1347,5,183,0,0,1347,1352,5,117,0,0,1348,1352,5,63,0,0,1349,1352,5,128,
0,0,1350,1352,5,60,0,0,1351,1338,1,0,0,0,1351,1341,1,0,0,0,1351,1348,
1,0,0,0,1351,1349,1,0,0,0,1351,1350,1,0,0,0,1352,131,1,0,0,0,1353,1358,
3,134,67,0,1354,1358,3,136,68,0,1355,1358,3,138,69,0,1356,1358,3,140,
70,0,1357,1353,1,0,0,0,1357,1354,1,0,0,0,1357,1355,1,0,0,0,1357,1356,
1,0,0,0,1358,133,1,0,0,0,1359,1360,5,103,0,0,1360,1363,5,183,0,0,1361,
1362,5,85,0,0,1362,1364,5,183,0,0,1363,1361,1,0,0,0,1363,1364,1,0,0,0,
1364,1367,1,0,0,0,1365,1368,5,168,0,0,1366,1368,3,336,168,0,1367,1365,
1,0,0,0,1367,1366,1,0,0,0,1368,135,1,0,0,0,1369,1370,5,88,0,0,1370,1372,
5,183,0,0,1371,1369,1,0,0,0,1371,1372,1,0,0,0,1372,1373,1,0,0,0,1373,
1374,5,98,0,0,1374,1375,5,183,0,0,1375,1380,3,336,168,0,1376,1377,5,183,
0,0,1377,1378,5,87,0,0,1378,1379,5,183,0,0,1379,1381,5,168,0,0,1380,1376,
1,0,0,0,1380,1381,1,0,0,0,1381,137,1,0,0,0,1382,1383,5,145,0,0,1383,1384,
5,183,0,0,1384,1385,3,336,168,0,1385,139,1,0,0,0,1386,1387,5,146,0,0,
1387,1388,5,183,0,0,1388,1389,3,336,168,0,1389,141,1,0,0,0,1390,1391,
3,144,72,0,1391,143,1,0,0,0,1392,1399,3,148,74,0,1393,1395,5,183,0,0,
1394,1393,1,0,0,0,1394,1395,1,0,0,0,1395,1396,1,0,0,0,1396,1398,3,146,
73,0,1397,1394,1,0,0,0,1398,1401,1,0,0,0,1399,1397,1,0,0,0,1399,1400,
1,0,0,0,1400,1414,1,0,0,0,1401,1399,1,0,0,0,1402,1404,3,190,95,0,1403,
1405,5,183,0,0,1404,1403,1,0,0,0,1404,1405,1,0,0,0,1405,1407,1,0,0,0,
1406,1402,1,0,0,0,1407,1408,1,0,0,0,1408,1406,1,0,0,0,1408,1409,1,0,0,
0,1409,1410,1,0,0,0,1410,1411,3,148,74,0,1411,1412,6,72,-1,0,1412,1414,
1,0,0,0,1413,1392,1,0,0,0,1413,1406,1,0,0,0,1414,145,1,0,0,0,1415,1416,
5,143,0,0,1416,1417,5,183,0,0,1417,1419,5,48,0,0,1418,1420,5,183,0,0,
1419,1418,1,0,0,0,1419,1420,1,0,0,0,1420,1421,1,0,0,0,1421,1428,3,148,
74,0,1422,1424,5,143,0,0,1423,1425,5,183,0,0,1424,1423,1,0,0,0,1424,1425,
1,0,0,0,1425,1426,1,0,0,0,1426,1428,3,148,74,0,1427,1415,1,0,0,0,1427,
1422,1,0,0,0,1428,147,1,0,0,0,1429,1432,3,150,75,0,1430,1432,3,152,76,
0,1431,1429,1,0,0,0,1431,1430,1,0,0,0,1432,149,1,0,0,0,1433,1435,3,158,
79,0,1434,1436,5,183,0,0,1435,1434,1,0,0,0,1435,1436,1,0,0,0,1436,1438,
1,0,0,0,1437,1433,1,0,0,0,1438,1441,1,0,0,0,1439,1437,1,0,0,0,1439,1440,
1,0,0,0,1440,1442,1,0,0,0,1441,1439,1,0,0,0,1442,1469,3,190,95,0,1443,
1445,3,158,79,0,1444,1446,5,183,0,0,1445,1444,1,0,0,0,1445,1446,1,0,0,
0,1446,1448,1,0,0,0,1447,1443,1,0,0,0,1448,1451,1,0,0,0,1449,1447,1,0,
0,0,1449,1450,1,0,0,0,1450,1452,1,0,0,0,1451,1449,1,0,0,0,1452,1459,3,
156,78,0,1453,1455,5,183,0,0,1454,1453,1,0,0,0,1454,1455,1,0,0,0,1455,
1456,1,0,0,0,1456,1458,3,156,78,0,1457,1454,1,0,0,0,1458,1461,1,0,0,0,
1459,1457,1,0,0,0,1459,1460,1,0,0,0,1460,1466,1,0,0,0,1461,1459,1,0,0,
0,1462,1464,5,183,0,0,1463,1462,1,0,0,0,1463,1464,1,0,0,0,1464,1465,1,
0,0,0,1465,1467,3,190,95,0,1466,1463,1,0,0,0,1466,1467,1,0,0,0,1467,1469,
1,0,0,0,1468,1439,1,0,0,0,1468,1449,1,0,0,0,1469,151,1,0,0,0,1470,1472,
3,154,77,0,1471,1473,5,183,0,0,1472,1471,1,0,0,0,1472,1473,1,0,0,0,1473,
1475,1,0,0,0,1474,1470,1,0,0,0,1475,1476,1,0,0,0,1476,1474,1,0,0,0,1476,
1477,1,0,0,0,1477,1478,1,0,0,0,1478,1479,3,150,75,0,1479,153,1,0,0,0,
1480,1482,3,158,79,0,1481,1483,5,183,0,0,1482,1481,1,0,0,0,1482,1483,
1,0,0,0,1483,1485,1,0,0,0,1484,1480,1,0,0,0,1485,1488,1,0,0,0,1486,1484,
1,0,0,0,1486,1487,1,0,0,0,1487,1495,1,0,0,0,1488,1486,1,0,0,0,1489,1491,
3,156,78,0,1490,1492,5,183,0,0,1491,1490,1,0,0,0,1491,1492,1,0,0,0,1492,
1494,1,0,0,0,1493,1489,1,0,0,0,1494,1497,1,0,0,0,1495,1493,1,0,0,0,1495,
1496,1,0,0,0,1496,1498,1,0,0,0,1497,1495,1,0,0,0,1498,1499,3,188,94,0,
1499,155,1,0,0,0,1500,1505,3,176,88,0,1501,1505,3,178,89,0,1502,1505,
3,182,91,0,1503,1505,3,186,93,0,1504,1500,1,0,0,0,1504,1501,1,0,0,0,1504,
1502,1,0,0,0,1504,1503,1,0,0,0,1505,157,1,0,0,0,1506,1511,3,168,84,0,
1507,1511,3,174,87,0,1508,1511,3,166,83,0,1509,1511,3,160,80,0,1510,1506,
1,0,0,0,1510,1507,1,0,0,0,1510,1508,1,0,0,0,1510,1509,1,0,0,0,1511,159,
1,0,0,0,1512,1530,5,103,0,0,1513,1514,5,183,0,0,1514,1515,5,150,0,0,1515,
1516,5,183,0,0,1516,1518,5,92,0,0,1517,1519,5,183,0,0,1518,1517,1,0,0,
0,1518,1519,1,0,0,0,1519,1520,1,0,0,0,1520,1522,5,2,0,0,1521,1523,5,183,
0,0,1522,1521,1,0,0,0,1522,1523,1,0,0,0,1523,1524,1,0,0,0,1524,1526,3,
100,50,0,1525,1527,5,183,0,0,1526,1525,1,0,0,0,1526,1527,1,0,0,0,1527,
1528,1,0,0,0,1528,1529,5,3,0,0,1529,1531,1,0,0,0,1530,1513,1,0,0,0,1530,
1531,1,0,0,0,1531,1532,1,0,0,0,1532,1533,5,183,0,0,1533,1534,5,87,0,0,
1534,1535,5,183,0,0,1535,1549,3,10,5,0,1536,1538,5,183,0,0,1537,1536,
1,0,0,0,1537,1538,1,0,0,0,1538,1539,1,0,0,0,1539,1541,5,2,0,0,1540,1542,
5,183,0,0,1541,1540,1,0,0,0,1541,1542,1,0,0,0,1542,1543,1,0,0,0,1543,
1545,3,24,12,0,1544,1546,5,183,0,0,1545,1544,1,0,0,0,1545,1546,1,0,0,
0,1546,1547,1,0,0,0,1547,1548,5,3,0,0,1548,1550,1,0,0,0,1549,1537,1,0,
0,0,1549,1550,1,0,0,0,1550,1555,1,0,0,0,1551,1553,5,183,0,0,1552,1551,
1,0,0,0,1552,1553,1,0,0,0,1553,1554,1,0,0,0,1554,1556,3,206,103,0,1555,
1552,1,0,0,0,1555,1556,1,0,0,0,1556,161,1,0,0,0,1557,1558,3,336,168,0,
1558,1559,5,183,0,0,1559,1560,5,51,0,0,1560,1561,5,183,0,0,1561,1563,
1,0,0,0,1562,1557,1,0,0,0,1562,1563,1,0,0,0,1563,1564,1,0,0,0,1564,1565,
3,336,168,0,1565,163,1,0,0,0,1566,1577,3,162,81,0,1567,1569,5,183,0,0,
1568,1567,1,0,0,0,1568,1569,1,0,0,0,1569,1570,1,0,0,0,1570,1572,5,4,0,
0,1571,1573,5,183,0,0,1572,1571,1,0,0,0,1572,1573,1,0,0,0,1573,1574,1,
0,0,0,1574,1576,3,162,81,0,1575,1568,1,0,0,0,1576,1579,1,0,0,0,1577,1575,
1,0,0,0,1577,1578,1,0,0,0,1578,165,1,0,0,0,1579,1577,1,0,0,0,1580,1581,
5,57,0,0,1581,1582,5,183,0,0,1582,1587,3,316,158,0,1583,1585,5,183,0,
0,1584,1583,1,0,0,0,1584,1585,1,0,0,0,1585,1586,1,0,0,0,1586,1588,3,206,
103,0,1587,1584,1,0,0,0,1587,1588,1,0,0,0,1588,1595,1,0,0,0,1589,1591,
5,183,0,0,1590,1589,1,0,0,0,1590,1591,1,0,0,0,1591,1592,1,0,0,0,1592,
1593,5,155,0,0,1593,1594,5,183,0,0,1594,1596,3,164,82,0,1595,1590,1,0,
0,0,1595,1596,1,0,0,0,1596,167,1,0,0,0,1597,1598,5,118,0,0,1598,1600,
5,183,0,0,1599,1597,1,0,0,0,1599,1600,1,0,0,0,1600,1601,1,0,0,0,1601,
1603,5,106,0,0,1602,1604,5,183,0,0,1603,1602,1,0,0,0,1603,1604,1,0,0,
0,1604,1605,1,0,0,0,1605,1608,3,208,104,0,1606,1607,5,183,0,0,1607,1609,
3,206,103,0,1608,1606,1,0,0,0,1608,1609,1,0,0,0,1609,1612,1,0,0,0,1610,
1611,5,183,0,0,1611,1613,3,170,85,0,1612,1610,1,0,0,0,1612,1613,1,0,0,
0,1613,169,1,0,0,0,1614,1615,5,93,0,0,1615,1616,5,183,0,0,1616,1617,3,
172,86,0,1617,171,1,0,0,0,1618,1619,6,86,-1,0,1619,1621,5,2,0,0,1620,
1622,5,183,0,0,1621,1620,1,0,0,0,1621,1622,1,0,0,0,1622,1623,1,0,0,0,
1623,1625,3,172,86,0,1624,1626,5,183,0,0,1625,1624,1,0,0,0,1625,1626,
1,0,0,0,1626,1627,1,0,0,0,1627,1628,5,3,0,0,1628,1631,1,0,0,0,1629,1631,
3,350,175,0,1630,1618,1,0,0,0,1630,1629,1,0,0,0,1631,1648,1,0,0,0,1632,
1633,10,4,0,0,1633,1634,5,183,0,0,1634,1635,5,100,0,0,1635,1636,5,183,
0,0,1636,1647,3,172,86,5,1637,1642,10,3,0,0,1638,1639,5,183,0,0,1639,
1640,5,110,0,0,1640,1641,5,183,0,0,1641,1643,3,350,175,0,1642,1638,1,
0,0,0,1643,1644,1,0,0,0,1644,1642,1,0,0,0,1644,1645,1,0,0,0,1645,1647,
1,0,0,0,1646,1632,1,0,0,0,1646,1637,1,0,0,0,1647,1650,1,0,0,0,1648,1646,
1,0,0,0,1648,1649,1,0,0,0,1649,173,1,0,0,0,1650,1648,1,0,0,0,1651,1653,
5,144,0,0,1652,1654,5,183,0,0,1653,1652,1,0,0,0,1653,1654,1,0,0,0,1654,
1655,1,0,0,0,1655,1656,3,248,124,0,1656,1657,5,183,0,0,1657,1658,5,51,
0,0,1658,1659,5,183,0,0,1659,1660,3,336,168,0,1660,175,1,0,0,0,1661,1663,
5,68,0,0,1662,1664,5,183,0,0,1663,1662,1,0,0,0,1663,1664,1,0,0,0,1664,
1665,1,0,0,0,1665,1666,3,208,104,0,1666,177,1,0,0,0,1667,1669,5,108,0,
0,1668,1670,5,183,0,0,1669,1668,1,0,0,0,1669,1670,1,0,0,0,1670,1671,1,
0,0,0,1671,1676,3,208,104,0,1672,1673,5,183,0,0,1673,1675,3,180,90,0,
1674,1672,1,0,0,0,1675,1678,1,0,0,0,1676,1674,1,0,0,0,1676,1677,1,0,0,
0,1677,179,1,0,0,0,1678,1676,1,0,0,0,1679,1680,5,116,0,0,1680,1681,5,
183,0,0,1681,1682,5,106,0,0,1682,1683,5,183,0,0,1683,1690,3,182,91,0,
1684,1685,5,116,0,0,1685,1686,5,183,0,0,1686,1687,5,68,0,0,1687,1688,
5,183,0,0,1688,1690,3,182,91,0,1689,1679,1,0,0,0,1689,1684,1,0,0,0,1690,
181,1,0,0,0,1691,1693,5,131,0,0,1692,1694,5,183,0,0,1693,1692,1,0,0,0,
1693,1694,1,0,0,0,1694,1695,1,0,0,0,1695,1706,3,184,92,0,1696,1698,5,
183,0,0,1697,1696,1,0,0,0,1697,1698,1,0,0,0,1698,1699,1,0,0,0,1699,1701,
5,4,0,0,1700,1702,5,183,0,0,1701,1700,1,0,0,0,1701,1702,1,0,0,0,1702,
1703,1,0,0,0,1703,1705,3,184,92,0,1704,1697,1,0,0,0,1705,1708,1,0,0,0,
1706,1704,1,0,0,0,1706,1707,1,0,0,0,1707,1724,1,0,0,0,1708,1706,1,0,0,
0,1709,1711,5,131,0,0,1710,1712,5,183,0,0,1711,1710,1,0,0,0,1711,1712,
1,0,0,0,1712,1713,1,0,0,0,1713,1715,3,294,147,0,1714,1716,5,183,0,0,1715,
1714,1,0,0,0,1715,1716,1,0,0,0,1716,1717,1,0,0,0,1717,1719,5,6,0,0,1718,
1720,5,183,0,0,1719,1718,1,0,0,0,1719,1720,1,0,0,0,1720,1721,1,0,0,0,
1721,1722,3,224,112,0,1722,1724,1,0,0,0,1723,1691,1,0,0,0,1723,1709,1,
0,0,0,1724,183,1,0,0,0,1725,1727,3,342,171,0,1726,1728,5,183,0,0,1727,
1726,1,0,0,0,1727,1728,1,0,0,0,1728,1729,1,0,0,0,1729,1731,5,6,0,0,1730,
1732,5,183,0,0,1731,1730,1,0,0,0,1731,1732,1,0,0,0,1732,1733,1,0,0,0,
1733,1734,3,248,124,0,1734,185,1,0,0,0,1735,1736,5,76,0,0,1736,1738,5,
183,0,0,1737,1735,1,0,0,0,1737,1738,1,0,0,0,1738,1739,1,0,0,0,1739,1741,
5,73,0,0,1740,1742,5,183,0,0,1741,1740,1,0,0,0,1741,1742,1,0,0,0,1742,
1743,1,0,0,0,1743,1754,3,248,124,0,1744,1746,5,183,0,0,1745,1744,1,0,
0,0,1745,1746,1,0,0,0,1746,1747,1,0,0,0,1747,1749,5,4,0,0,1748,1750,5,
183,0,0,1749,1748,1,0,0,0,1749,1750,1,0,0,0,1750,1751,1,0,0,0,1751,1753,
3,248,124,0,1752,1745,1,0,0,0,1753,1756,1,0,0,0,1754,1752,1,0,0,0,1754,
1755,1,0,0,0,1755,187,1,0,0,0,1756,1754,1,0,0,0,1757,1758,5,150,0,0,1758,
1763,3,192,96,0,1759,1761,5,183,0,0,1760,1759,1,0,0,0,1760,1761,1,0,0,
0,1761,1762,1,0,0,0,1762,1764,3,206,103,0,1763,1760,1,0,0,0,1763,1764,
1,0,0,0,1764,189,1,0,0,0,1765,1766,5,127,0,0,1766,1767,3,192,96,0,1767,
191,1,0,0,0,1768,1770,5,183,0,0,1769,1768,1,0,0,0,1769,1770,1,0,0,0,1770,
1771,1,0,0,0,1771,1773,5,77,0,0,1772,1769,1,0,0,0,1772,1773,1,0,0,0,1773,
1774,1,0,0,0,1774,1775,5,183,0,0,1775,1778,3,194,97,0,1776,1777,5,183,
0,0,1777,1779,3,198,99,0,1778,1776,1,0,0,0,1778,1779,1,0,0,0,1779,1782,
1,0,0,0,1780,1781,5,183,0,0,1781,1783,3,200,100,0,1782,1780,1,0,0,0,1782,
1783,1,0,0,0,1783,1786,1,0,0,0,1784,1785,5,183,0,0,1785,1787,3,202,101,
0,1786,1784,1,0,0,0,1786,1787,1,0,0,0,1787,193,1,0,0,0,1788,1799,5,161,
0,0,1789,1791,5,183,0,0,1790,1789,1,0,0,0,1790,1791,1,0,0,0,1791,1792,
1,0,0,0,1792,1794,5,4,0,0,1793,1795,5,183,0,0,1794,1793,1,0,0,0,1794,
1795,1,0,0,0,1795,1796,1,0,0,0,1796,1798,3,196,98,0,1797,1790,1,0,0,0,
1798,1801,1,0,0,0,1799,1797,1,0,0,0,1799,1800,1,0,0,0,1800,1817,1,0,0,
0,1801,1799,1,0,0,0,1802,1813,3,196,98,0,1803,1805,5,183,0,0,1804,1803,
1,0,0,0,1804,1805,1,0,0,0,1805,1806,1,0,0,0,1806,1808,5,4,0,0,1807,1809,
5,183,0,0,1808,1807,1,0,0,0,1808,1809,1,0,0,0,1809,1810,1,0,0,0,1810,
1812,3,196,98,0,1811,1804,1,0,0,0,1812,1815,1,0,0,0,1813,1811,1,0,0,0,
1813,1814,1,0,0,0,1814,1817,1,0,0,0,1815,1813,1,0,0,0,1816,1788,1,0,0,
0,1816,1802,1,0,0,0,1817,195,1,0,0,0,1818,1819,3,248,124,0,1819,1820,
5,183,0,0,1820,1821,5,51,0,0,1821,1822,5,183,0,0,1822,1823,3,336,168,
0,1823,1826,1,0,0,0,1824,1826,3,248,124,0,1825,1818,1,0,0,0,1825,1824,
1,0,0,0,1826,197,1,0,0,0,1827,1828,5,120,0,0,1828,1829,5,183,0,0,1829,
1830,5,56,0,0,1830,1831,5,183,0,0,1831,1839,3,204,102,0,1832,1834,5,4,
0,0,1833,1835,5,183,0,0,1834,1833,1,0,0,0,1834,1835,1,0,0,0,1835,1836,
1,0,0,0,1836,1838,3,204,102,0,1837,1832,1,0,0,0,1838,1841,1,0,0,0,1839,
1837,1,0,0,0,1839,1840,1,0,0,0,1840,199,1,0,0,0,1841,1839,1,0,0,0,1842,
1843,5,162,0,0,1843,1844,5,183,0,0,1844,1845,3,248,124,0,1845,201,1,0,
0,0,1846,1847,5,102,0,0,1847,1848,5,183,0,0,1848,1849,3,248,124,0,1849,
203,1,0,0,0,1850,1855,3,248,124,0,1851,1853,5,183,0,0,1852,1851,1,0,0,
0,1852,1853,1,0,0,0,1853,1854,1,0,0,0,1854,1856,7,1,0,0,1855,1852,1,0,
0,0,1855,1856,1,0,0,0,1856,205,1,0,0,0,1857,1858,5,149,0,0,1858,1859,
5,183,0,0,1859,1860,3,248,124,0,1860,207,1,0,0,0,1861,1872,3,210,105,
0,1862,1864,5,183,0,0,1863,1862,1,0,0,0,1863,1864,1,0,0,0,1864,1865,1,
0,0,0,1865,1867,5,4,0,0,1866,1868,5,183,0,0,1867,1866,1,0,0,0,1867,1868,
1,0,0,0,1868,1869,1,0,0,0,1869,1871,3,210,105,0,1870,1863,1,0,0,0,1871,
1874,1,0,0,0,1872,1870,1,0,0,0,1872,1873,1,0,0,0,1873,209,1,0,0,0,1874,
1872,1,0,0,0,1875,1877,3,336,168,0,1876,1878,5,183,0,0,1877,1876,1,0,
0,0,1877,1878,1,0,0,0,1878,1879,1,0,0,0,1879,1881,5,6,0,0,1880,1882,5,
183,0,0,1881,1880,1,0,0,0,1881,1882,1,0,0,0,1882,1883,1,0,0,0,1883,1884,
3,212,106,0,1884,1887,1,0,0,0,1885,1887,3,212,106,0,1886,1875,1,0,0,0,
1886,1885,1,0,0,0,1887,211,1,0,0,0,1888,1889,3,214,107,0,1889,213,1,0,
0,0,1890,1897,3,216,108,0,1891,1893,5,183,0,0,1892,1891,1,0,0,0,1892,
1893,1,0,0,0,1893,1894,1,0,0,0,1894,1896,3,218,109,0,1895,1892,1,0,0,
0,1896,1899,1,0,0,0,1897,1895,1,0,0,0,1897,1898,1,0,0,0,1898,1905,1,0,
0,0,1899,1897,1,0,0,0,1900,1901,5,2,0,0,1901,1902,3,214,107,0,1902,1903,
5,3,0,0,1903,1905,1,0,0,0,1904,1890,1,0,0,0,1904,1900,1,0,0,0,1905,215,
1,0,0,0,1906,1908,5,2,0,0,1907,1909,5,183,0,0,1908,1907,1,0,0,0,1908,
1909,1,0,0,0,1909,1914,1,0,0,0,1910,1912,3,336,168,0,1911,1913,5,183,
0,0,1912,1911,1,0,0,0,1912,1913,1,0,0,0,1913,1915,1,0,0,0,1914,1910,1,
0,0,0,1914,1915,1,0,0,0,1915,1920,1,0,0,0,1916,1918,3,228,114,0,1917,
1919,5,183,0,0,1918,1917,1,0,0,0,1918,1919,1,0,0,0,1919,1921,1,0,0,0,
1920,1916,1,0,0,0,1920,1921,1,0,0,0,1921,1926,1,0,0,0,1922,1924,3,224,
112,0,1923,1925,5,183,0,0,1924,1923,1,0,0,0,1924,1925,1,0,0,0,1925,1927,
1,0,0,0,1926,1922,1,0,0,0,1926,1927,1,0,0,0,1927,1928,1,0,0,0,1928,1929,
5,3,0,0,1929,217,1,0,0,0,1930,1932,3,220,110,0,1931,1933,5,183,0,0,1932,
1931,1,0,0,0,1932,1933,1,0,0,0,1933,1934,1,0,0,0,1934,1935,3,216,108,
0,1935,219,1,0,0,0,1936,1938,3,356,178,0,1937,1939,5,183,0,0,1938,1937,
1,0,0,0,1938,1939,1,0,0,0,1939,1940,1,0,0,0,1940,1942,3,360,180,0,1941,
1943,5,183,0,0,1942,1941,1,0,0,0,1942,1943,1,0,0,0,1943,1945,1,0,0,0,
1944,1946,3,222,111,0,1945,1944,1,0,0,0,1945,1946,1,0,0,0,1946,1948,1,
0,0,0,1947,1949,5,183,0,0,1948,1947,1,0,0,0,1948,1949,1,0,0,0,1949,1950,
1,0,0,0,1950,1951,3,360,180,0,1951,1981,1,0,0,0,1952,1954,3,360,180,0,
1953,1955,5,183,0,0,1954,1953,1,0,0,0,1954,1955,1,0,0,0,1955,1957,1,0,
0,0,1956,1958,3,222,111,0,1957,1956,1,0,0,0,1957,1958,1,0,0,0,1958,1960,
1,0,0,0,1959,1961,5,183,0,0,1960,1959,1,0,0,0,1960,1961,1,0,0,0,1961,
1962,1,0,0,0,1962,1964,3,360,180,0,1963,1965,5,183,0,0,1964,1963,1,0,
0,0,1964,1965,1,0,0,0,1965,1966,1,0,0,0,1966,1967,3,358,179,0,1967,1981,
1,0,0,0,1968,1970,3,360,180,0,1969,1971,5,183,0,0,1970,1969,1,0,0,0,1970,
1971,1,0,0,0,1971,1973,1,0,0,0,1972,1974,3,222,111,0,1973,1972,1,0,0,
0,1973,1974,1,0,0,0,1974,1976,1,0,0,0,1975,1977,5,183,0,0,1976,1975,1,
0,0,0,1976,1977,1,0,0,0,1977,1978,1,0,0,0,1978,1979,3,360,180,0,1979,
1981,1,0,0,0,1980,1936,1,0,0,0,1980,1952,1,0,0,0,1980,1968,1,0,0,0,1981,
221,1,0,0,0,1982,1984,5,7,0,0,1983,1985,5,183,0,0,1984,1983,1,0,0,0,1984,
1985,1,0,0,0,1985,1990,1,0,0,0,1986,1988,3,336,168,0,1987,1989,5,183,
0,0,1988,1987,1,0,0,0,1988,1989,1,0,0,0,1989,1991,1,0,0,0,1990,1986,1,
0,0,0,1990,1991,1,0,0,0,1991,1996,1,0,0,0,1992,1994,3,226,113,0,1993,
1995,5,183,0,0,1994,1993,1,0,0,0,1994,1995,1,0,0,0,1995,1997,1,0,0,0,
1996,1992,1,0,0,0,1996,1997,1,0,0,0,1997,2002,1,0,0,0,1998,2000,3,230,
115,0,1999,2001,5,183,0,0,2000,1999,1,0,0,0,2000,2001,1,0,0,0,2001,2003,
1,0,0,0,2002,1998,1,0,0,0,2002,2003,1,0,0,0,2003,2008,1,0,0,0,2004,2006,
3,224,112,0,2005,2007,5,183,0,0,2006,2005,1,0,0,0,2006,2007,1,0,0,0,2007,
2009,1,0,0,0,2008,2004,1,0,0,0,2008,2009,1,0,0,0,2009,2010,1,0,0,0,2010,
2011,5,8,0,0,2011,223,1,0,0,0,2012,2014,5,9,0,0,2013,2015,5,183,0,0,2014,
2013,1,0,0,0,2014,2015,1,0,0,0,2015,2049,1,0,0,0,2016,2018,3,344,172,
0,2017,2019,5,183,0,0,2018,2017,1,0,0,0,2018,2019,1,0,0,0,2019,2020,1,
0,0,0,2020,2022,5,164,0,0,2021,2023,5,183,0,0,2022,2021,1,0,0,0,2022,
2023,1,0,0,0,2023,2024,1,0,0,0,2024,2026,3,248,124,0,2025,2027,5,183,
0,0,2026,2025,1,0,0,0,2026,2027,1,0,0,0,2027,2046,1,0,0,0,2028,2030,5,
4,0,0,2029,2031,5,183,0,0,2030,2029,1,0,0,0,2030,2031,1,0,0,0,2031,2032,
1,0,0,0,2032,2034,3,344,172,0,2033,2035,5,183,0,0,2034,2033,1,0,0,0,2034,
2035,1,0,0,0,2035,2036,1,0,0,0,2036,2038,5,164,0,0,2037,2039,5,183,0,
0,2038,2037,1,0,0,0,2038,2039,1,0,0,0,2039,2040,1,0,0,0,2040,2042,3,248,
124,0,2041,2043,5,183,0,0,2042,2041,1,0,0,0,2042,2043,1,0,0,0,2043,2045,
1,0,0,0,2044,2028,1,0,0,0,2045,2048,1,0,0,0,2046,2044,1,0,0,0,2046,2047,
1,0,0,0,2047,2050,1,0,0,0,2048,2046,1,0,0,0,2049,2016,1,0,0,0,2049,2050,
1,0,0,0,2050,2051,1,0,0,0,2051,2052,5,10,0,0,2052,225,1,0,0,0,2053,2055,
5,164,0,0,2054,2056,5,183,0,0,2055,2054,1,0,0,0,2055,2056,1,0,0,0,2056,
2057,1,0,0,0,2057,2071,3,246,123,0,2058,2060,5,183,0,0,2059,2058,1,0,
0,0,2059,2060,1,0,0,0,2060,2061,1,0,0,0,2061,2063,5,11,0,0,2062,2064,
5,164,0,0,2063,2062,1,0,0,0,2063,2064,1,0,0,0,2064,2066,1,0,0,0,2065,
2067,5,183,0,0,2066,2065,1,0,0,0,2066,2067,1,0,0,0,2067,2068,1,0,0,0,
2068,2070,3,246,123,0,2069,2059,1,0,0,0,2070,2073,1,0,0,0,2071,2069,1,
0,0,0,2071,2072,1,0,0,0,2072,227,1,0,0,0,2073,2071,1,0,0,0,2074,2076,
5,164,0,0,2075,2077,5,183,0,0,2076,2075,1,0,0,0,2076,2077,1,0,0,0,2077,
2078,1,0,0,0,2078,2095,3,244,122,0,2079,2081,5,183,0,0,2080,2079,1,0,
0,0,2080,2081,1,0,0,0,2081,2087,1,0,0,0,2082,2084,5,11,0,0,2083,2085,
5,164,0,0,2084,2083,1,0,0,0,2084,2085,1,0,0,0,2085,2088,1,0,0,0,2086,
2088,5,164,0,0,2087,2082,1,0,0,0,2087,2086,1,0,0,0,2088,2090,1,0,0,0,
2089,2091,5,183,0,0,2090,2089,1,0,0,0,2090,2091,1,0,0,0,2091,2092,1,0,
0,0,2092,2094,3,244,122,0,2093,2080,1,0,0,0,2094,2097,1,0,0,0,2095,2093,
1,0,0,0,2095,2096,1,0,0,0,2096,229,1,0,0,0,2097,2095,1,0,0,0,2098,2103,
5,161,0,0,2099,2101,5,183,0,0,2100,2099,1,0,0,0,2100,2101,1,0,0,0,2101,
2102,1,0,0,0,2102,2104,3,232,116,0,2103,2100,1,0,0,0,2103,2104,1,0,0,
0,2104,2109,1,0,0,0,2105,2107,5,183,0,0,2106,2105,1,0,0,0,2106,2107,1,
0,0,0,2107,2108,1,0,0,0,2108,2110,3,234,117,0,2109,2106,1,0,0,0,2109,
2110,1,0,0,0,2110,2115,1,0,0,0,2111,2113,5,183,0,0,2112,2111,1,0,0,0,
2112,2113,1,0,0,0,2113,2114,1,0,0,0,2114,2116,3,236,118,0,2115,2112,1,
0,0,0,2115,2116,1,0,0,0,2116,231,1,0,0,0,2117,2118,5,48,0,0,2118,2120,
5,183,0,0,2119,2117,1,0,0,0,2119,2120,1,0,0,0,2120,2121,1,0,0,0,2121,
2123,5,152,0,0,2122,2124,5,183,0,0,2123,2122,1,0,0,0,2123,2124,1,0,0,
0,2124,2125,1,0,0,0,2125,2127,5,2,0,0,2126,2128,5,183,0,0,2127,2126,1,
0,0,0,2127,2128,1,0,0,0,2128,2129,1,0,0,0,2129,2131,3,344,172,0,2130,
2132,5,183,0,0,2131,2130,1,0,0,0,2131,2132,1,0,0,0,2132,2133,1,0,0,0,
2133,2134,5,3,0,0,2134,2142,1,0,0,0,2135,2142,5,132,0,0,2136,2137,5,48,
0,0,2137,2138,5,183,0,0,2138,2142,5,132,0,0,2139,2142,5,139,0,0,2140,
2142,5,45,0,0,2141,2119,1,0,0,0,2141,2135,1,0,0,0,2141,2136,1,0,0,0,2141,
2139,1,0,0,0,2141,2140,1,0,0,0,2142,233,1,0,0,0,2143,2145,3,240,120,0,
2144,2143,1,0,0,0,2144,2145,1,0,0,0,2145,2147,1,0,0,0,2146,2148,5,183,
0,0,2147,2146,1,0,0,0,2147,2148,1,0,0,0,2148,2149,1,0,0,0,2149,2151,5,
165,0,0,2150,2152,5,183,0,0,2151,2150,1,0,0,0,2151,2152,1,0,0,0,2152,
2154,1,0,0,0,2153,2155,3,242,121,0,2154,2153,1,0,0,0,2154,2155,1,0,0,
0,2155,2158,1,0,0,0,2156,2158,3,346,173,0,2157,2144,1,0,0,0,2157,2156,
1,0,0,0,2158,235,1,0,0,0,2159,2161,5,2,0,0,2160,2162,5,183,0,0,2161,2160,
1,0,0,0,2161,2162,1,0,0,0,2162,2163,1,0,0,0,2163,2165,3,336,168,0,2164,
2166,5,183,0,0,2165,2164,1,0,0,0,2165,2166,1,0,0,0,2166,2167,1,0,0,0,
2167,2169,5,4,0,0,2168,2170,5,183,0,0,2169,2168,1,0,0,0,2169,2170,1,0,
0,0,2170,2171,1,0,0,0,2171,2183,3,336,168,0,2172,2174,5,183,0,0,2173,
2172,1,0,0,0,2173,2174,1,0,0,0,2174,2175,1,0,0,0,2175,2177,5,11,0,0,2176,
2178,5,183,0,0,2177,2176,1,0,0,0,2177,2178,1,0,0,0,2178,2179,1,0,0,0,
2179,2181,3,206,103,0,2180,2182,5,183,0,0,2181,2180,1,0,0,0,2181,2182,
1,0,0,0,2182,2184,1,0,0,0,2183,2173,1,0,0,0,2183,2184,1,0,0,0,2184,2204,
1,0,0,0,2185,2187,5,183,0,0,2186,2185,1,0,0,0,2186,2187,1,0,0,0,2187,
2188,1,0,0,0,2188,2190,5,11,0,0,2189,2191,5,183,0,0,2190,2189,1,0,0,0,
2190,2191,1,0,0,0,2191,2192,1,0,0,0,2192,2194,3,238,119,0,2193,2195,5,
183,0,0,2194,2193,1,0,0,0,2194,2195,1,0,0,0,2195,2196,1,0,0,0,2196,2198,
5,4,0,0,2197,2199,5,183,0,0,2198,2197,1,0,0,0,2198,2199,1,0,0,0,2199,
2200,1,0,0,0,2200,2202,3,238,119,0,2201,2203,5,183,0,0,2202,2201,1,0,
0,0,2202,2203,1,0,0,0,2203,2205,1,0,0,0,2204,2186,1,0,0,0,2204,2205,1,
0,0,0,2205,2206,1,0,0,0,2206,2207,5,3,0,0,2207,237,1,0,0,0,2208,2210,
5,9,0,0,2209,2211,5,183,0,0,2210,2209,1,0,0,0,2210,2211,1,0,0,0,2211,
2213,1,0,0,0,2212,2214,3,194,97,0,2213,2212,1,0,0,0,2213,2214,1,0,0,0,
2214,2216,1,0,0,0,2215,2217,5,183,0,0,2216,2215,1,0,0,0,2216,2217,1,0,
0,0,2217,2218,1,0,0,0,2218,2219,5,10,0,0,2219,239,1,0,0,0,2220,2221,5,
170,0,0,2221,241,1,0,0,0,2222,2223,5,170,0,0,2223,243,1,0,0,0,2224,2227,
3,350,175,0,2225,2226,5,5,0,0,2226,2228,3,350,175,0,2227,2225,1,0,0,0,
2227,2228,1,0,0,0,2228,245,1,0,0,0,2229,2230,3,350,175,0,2230,247,1,0,
0,0,2231,2232,3,250,125,0,2232,249,1,0,0,0,2233,2240,3,252,126,0,2234,
2235,5,183,0,0,2235,2236,5,119,0,0,2236,2237,5,183,0,0,2237,2239,3,252,
126,0,2238,2234,1,0,0,0,2239,2242,1,0,0,0,2240,2238,1,0,0,0,2240,2241,
1,0,0,0,2241,251,1,0,0,0,2242,2240,1,0,0,0,2243,2250,3,254,127,0,2244,
2245,5,183,0,0,2245,2246,5,153,0,0,2246,2247,5,183,0,0,2247,2249,3,254,
127,0,2248,2244,1,0,0,0,2249,2252,1,0,0,0,2250,2248,1,0,0,0,2250,2251,
1,0,0,0,2251,253,1,0,0,0,2252,2250,1,0,0,0,2253,2260,3,256,128,0,2254,
2255,5,183,0,0,2255,2256,5,50,0,0,2256,2257,5,183,0,0,2257,2259,3,256,
128,0,2258,2254,1,0,0,0,2259,2262,1,0,0,0,2260,2258,1,0,0,0,2260,2261,
1,0,0,0,2261,255,1,0,0,0,2262,2260,1,0,0,0,2263,2265,5,113,0,0,2264,2266,
5,183,0,0,2265,2264,1,0,0,0,2265,2266,1,0,0,0,2266,2268,1,0,0,0,2267,
2263,1,0,0,0,2268,2271,1,0,0,0,2269,2267,1,0,0,0,2269,2270,1,0,0,0,2270,
2272,1,0,0,0,2271,2269,1,0,0,0,2272,2273,3,258,129,0,2273,257,1,0,0,0,
2274,2284,3,262,131,0,2275,2277,5,183,0,0,2276,2275,1,0,0,0,2276,2277,
1,0,0,0,2277,2278,1,0,0,0,2278,2280,3,260,130,0,2279,2281,5,183,0,0,2280,
2279,1,0,0,0,2280,2281,1,0,0,0,2281,2282,1,0,0,0,2282,2283,3,262,131,
0,2283,2285,1,0,0,0,2284,2276,1,0,0,0,2284,2285,1,0,0,0,2285,2323,1,0,
0,0,2286,2288,3,262,131,0,2287,2289,5,183,0,0,2288,2287,1,0,0,0,2288,
2289,1,0,0,0,2289,2290,1,0,0,0,2290,2292,5,163,0,0,2291,2293,5,183,0,
0,2292,2291,1,0,0,0,2292,2293,1,0,0,0,2293,2294,1,0,0,0,2294,2295,3,262,
131,0,2295,2296,1,0,0,0,2296,2297,6,129,-1,0,2297,2323,1,0,0,0,2298,2300,
3,262,131,0,2299,2301,5,183,0,0,2300,2299,1,0,0,0,2300,2301,1,0,0,0,2301,
2302,1,0,0,0,2302,2304,3,260,130,0,2303,2305,5,183,0,0,2304,2303,1,0,
0,0,2304,2305,1,0,0,0,2305,2306,1,0,0,0,2306,2316,3,262,131,0,2307,2309,
5,183,0,0,2308,2307,1,0,0,0,2308,2309,1,0,0,0,2309,2310,1,0,0,0,2310,
2312,3,260,130,0,2311,2313,5,183,0,0,2312,2311,1,0,0,0,2312,2313,1,0,
0,0,2313,2314,1,0,0,0,2314,2315,3,262,131,0,2315,2317,1,0,0,0,2316,2308,
1,0,0,0,2317,2318,1,0,0,0,2318,2316,1,0,0,0,2318,2319,1,0,0,0,2319,2320,
1,0,0,0,2320,2321,6,129,-1,0,2321,2323,1,0,0,0,2322,2274,1,0,0,0,2322,
2286,1,0,0,0,2322,2298,1,0,0,0,2323,259,1,0,0,0,2324,2325,7,2,0,0,2325,
261,1,0,0,0,2326,2337,3,264,132,0,2327,2329,5,183,0,0,2328,2327,1,0,0,
0,2328,2329,1,0,0,0,2329,2330,1,0,0,0,2330,2332,5,11,0,0,2331,2333,5,
183,0,0,2332,2331,1,0,0,0,2332,2333,1,0,0,0,2333,2334,1,0,0,0,2334,2336,
3,264,132,0,2335,2328,1,0,0,0,2336,2339,1,0,0,0,2337,2335,1,0,0,0,2337,
2338,1,0,0,0,2338,263,1,0,0,0,2339,2337,1,0,0,0,2340,2351,3,266,133,0,
2341,2343,5,183,0,0,2342,2341,1,0,0,0,2342,2343,1,0,0,0,2343,2344,1,0,
0,0,2344,2346,5,17,0,0,2345,2347,5,183,0,0,2346,2345,1,0,0,0,2346,2347,
1,0,0,0,2347,2348,1,0,0,0,2348,2350,3,266,133,0,2349,2342,1,0,0,0,2350,
2353,1,0,0,0,2351,2349,1,0,0,0,2351,2352,1,0,0,0,2352,265,1,0,0,0,2353,
2351,1,0,0,0,2354,2366,3,270,135,0,2355,2357,5,183,0,0,2356,2355,1,0,
0,0,2356,2357,1,0,0,0,2357,2358,1,0,0,0,2358,2360,3,268,134,0,2359,2361,
5,183,0,0,2360,2359,1,0,0,0,2360,2361,1,0,0,0,2361,2362,1,0,0,0,2362,
2363,3,270,135,0,2363,2365,1,0,0,0,2364,2356,1,0,0,0,2365,2368,1,0,0,
0,2366,2364,1,0,0,0,2366,2367,1,0,0,0,2367,267,1,0,0,0,2368,2366,1,0,
0,0,2369,2370,7,3,0,0,2370,269,1,0,0,0,2371,2383,3,274,137,0,2372,2374,
5,183,0,0,2373,2372,1,0,0,0,2373,2374,1,0,0,0,2374,2375,1,0,0,0,2375,
2377,3,272,136,0,2376,2378,5,183,0,0,2377,2376,1,0,0,0,2377,2378,1,0,
0,0,2378,2379,1,0,0,0,2379,2380,3,274,137,0,2380,2382,1,0,0,0,2381,2373,
1,0,0,0,2382,2385,1,0,0,0,2383,2381,1,0,0,0,2383,2384,1,0,0,0,2384,271,
1,0,0,0,2385,2383,1,0,0,0,2386,2387,7,4,0,0,2387,273,1,0,0,0,2388,2400,
3,278,139,0,2389,2391,5,183,0,0,2390,2389,1,0,0,0,2390,2391,1,0,0,0,2391,
2392,1,0,0,0,2392,2394,3,276,138,0,2393,2395,5,183,0,0,2394,2393,1,0,
0,0,2394,2395,1,0,0,0,2395,2396,1,0,0,0,2396,2397,3,278,139,0,2397,2399,
1,0,0,0,2398,2390,1,0,0,0,2399,2402,1,0,0,0,2400,2398,1,0,0,0,2400,2401,
1,0,0,0,2401,275,1,0,0,0,2402,2400,1,0,0,0,2403,2404,7,5,0,0,2404,277,
1,0,0,0,2405,2416,3,280,140,0,2406,2408,5,183,0,0,2407,2406,1,0,0,0,2407,
2408,1,0,0,0,2408,2409,1,0,0,0,2409,2411,5,23,0,0,2410,2412,5,183,0,0,
2411,2410,1,0,0,0,2411,2412,1,0,0,0,2412,2413,1,0,0,0,2413,2415,3,280,
140,0,2414,2407,1,0,0,0,2415,2418,1,0,0,0,2416,2414,1,0,0,0,2416,2417,
1,0,0,0,2417,279,1,0,0,0,2418,2416,1,0,0,0,2419,2427,3,290,145,0,2420,
2428,3,284,142,0,2421,2423,3,282,141,0,2422,2421,1,0,0,0,2423,2424,1,
0,0,0,2424,2422,1,0,0,0,2424,2425,1,0,0,0,2425,2428,1,0,0,0,2426,2428,
3,288,144,0,2427,2420,1,0,0,0,2427,2422,1,0,0,0,2427,2426,1,0,0,0,2427,
2428,1,0,0,0,2428,281,1,0,0,0,2429,2430,5,183,0,0,2430,2432,5,96,0,0,
2431,2433,5,183,0,0,2432,2431,1,0,0,0,2432,2433,1,0,0,0,2433,2434,1,0,
0,0,2434,2449,3,292,146,0,2435,2436,5,7,0,0,2436,2437,3,248,124,0,2437,
2438,5,8,0,0,2438,2449,1,0,0,0,2439,2441,5,7,0,0,2440,2442,3,248,124,
0,2441,2440,1,0,0,0,2441,2442,1,0,0,0,2442,2443,1,0,0,0,2443,2445,7,6,
0,0,2444,2446,3,248,124,0,2445,2444,1,0,0,0,2445,2446,1,0,0,0,2446,2447,
1,0,0,0,2447,2449,5,8,0,0,2448,2429,1,0,0,0,2448,2435,1,0,0,0,2448,2439,
1,0,0,0,2449,283,1,0,0,0,2450,2462,3,286,143,0,2451,2452,5,183,0,0,2452,
2453,5,134,0,0,2453,2454,5,183,0,0,2454,2462,5,150,0,0,2455,2456,5,183,
0,0,2456,2457,5,81,0,0,2457,2458,5,183,0,0,2458,2462,5,150,0,0,2459,2460,
5,183,0,0,2460,2462,5,65,0,0,2461,2450,1,0,0,0,2461,2451,1,0,0,0,2461,
2455,1,0,0,0,2461,2459,1,0,0,0,2462,2464,1,0,0,0,2463,2465,5,183,0,0,
2464,2463,1,0,0,0,2464,2465,1,0,0,0,2465,2466,1,0,0,0,2466,2467,3,292,
146,0,2467,285,1,0,0,0,2468,2470,5,183,0,0,2469,2468,1,0,0,0,2469,2470,
1,0,0,0,2470,2471,1,0,0,0,2471,2472,5,24,0,0,2472,287,1,0,0,0,2473,2474,
5,183,0,0,2474,2475,5,99,0,0,2475,2476,5,183,0,0,2476,2484,5,115,0,0,
2477,2478,5,183,0,0,2478,2479,5,99,0,0,2479,2480,5,183,0,0,2480,2481,
5,113,0,0,2481,2482,5,183,0,0,2482,2484,5,115,0,0,2483,2473,1,0,0,0,2483,
2477,1,0,0,0,2484,289,1,0,0,0,2485,2487,5,166,0,0,2486,2488,5,183,0,0,
2487,2486,1,0,0,0,2487,2488,1,0,0,0,2488,2490,1,0,0,0,2489,2485,1,0,0,
0,2490,2493,1,0,0,0,2491,2489,1,0,0,0,2491,2492,1,0,0,0,2492,2494,1,0,
0,0,2493,2491,1,0,0,0,2494,2499,3,292,146,0,2495,2497,5,183,0,0,2496,
2495,1,0,0,0,2496,2497,1,0,0,0,2497,2498,1,0,0,0,2498,2500,5,167,0,0,
2499,2496,1,0,0,0,2499,2500,1,0,0,0,2500,291,1,0,0,0,2501,2508,3,294,
147,0,2502,2504,5,183,0,0,2503,2502,1,0,0,0,2503,2504,1,0,0,0,2504,2505,
1,0,0,0,2505,2507,3,330,165,0,2506,2503,1,0,0,0,2507,2510,1,0,0,0,2508,
2506,1,0,0,0,2508,2509,1,0,0,0,2509,293,1,0,0,0,2510,2508,1,0,0,0,2511,
2521,3,302,151,0,2512,2521,3,340,170,0,2513,2521,3,332,166,0,2514,2521,
3,314,157,0,2515,2521,3,316,158,0,2516,2521,3,326,163,0,2517,2521,3,328,
164,0,2518,2521,3,336,168,0,2519,2521,3,296,148,0,2520,2511,1,0,0,0,2520,
2512,1,0,0,0,2520,2513,1,0,0,0,2520,2514,1,0,0,0,2520,2515,1,0,0,0,2520,
2516,1,0,0,0,2520,2517,1,0,0,0,2520,2518,1,0,0,0,2520,2519,1,0,0,0,2521,
295,1,0,0,0,2522,2524,5,48,0,0,2523,2525,5,183,0,0,2524,2523,1,0,0,0,
2524,2525,1,0,0,0,2525,2526,1,0,0,0,2526,2528,5,2,0,0,2527,2529,5,183,
0,0,2528,2527,1,0,0,0,2528,2529,1,0,0,0,2529,2530,1,0,0,0,2530,2532,3,
298,149,0,2531,2533,5,183,0,0,2532,2531,1,0,0,0,2532,2533,1,0,0,0,2533,
2534,1,0,0,0,2534,2535,5,3,0,0,2535,2579,1,0,0,0,2536,2538,5,46,0,0,2537,
2539,5,183,0,0,2538,2537,1,0,0,0,2538,2539,1,0,0,0,2539,2540,1,0,0,0,
2540,2542,5,2,0,0,2541,2543,5,183,0,0,2542,2541,1,0,0,0,2542,2543,1,0,
0,0,2543,2544,1,0,0,0,2544,2546,3,298,149,0,2545,2547,5,183,0,0,2546,
2545,1,0,0,0,2546,2547,1,0,0,0,2547,2548,1,0,0,0,2548,2549,5,3,0,0,2549,
2579,1,0,0,0,2550,2552,5,114,0,0,2551,2553,5,183,0,0,2552,2551,1,0,0,
0,2552,2553,1,0,0,0,2553,2554,1,0,0,0,2554,2556,5,2,0,0,2555,2557,5,183,
0,0,2556,2555,1,0,0,0,2556,2557,1,0,0,0,2557,2558,1,0,0,0,2558,2560,3,
298,149,0,2559,2561,5,183,0,0,2560,2559,1,0,0,0,2560,2561,1,0,0,0,2561,
2562,1,0,0,0,2562,2563,5,3,0,0,2563,2579,1,0,0,0,2564,2566,5,154,0,0,
2565,2567,5,183,0,0,2566,2565,1,0,0,0,2566,2567,1,0,0,0,2567,2568,1,0,
0,0,2568,2570,5,2,0,0,2569,2571,5,183,0,0,2570,2569,1,0,0,0,2570,2571,
1,0,0,0,2571,2572,1,0,0,0,2572,2574,3,298,149,0,2573,2575,5,183,0,0,2574,
2573,1,0,0,0,2574,2575,1,0,0,0,2575,2576,1,0,0,0,2576,2577,5,3,0,0,2577,
2579,1,0,0,0,2578,2522,1,0,0,0,2578,2536,1,0,0,0,2578,2550,1,0,0,0,2578,
2564,1,0,0,0,2579,297,1,0,0,0,2580,2581,3,300,150,0,2581,2582,5,183,0,
0,2582,2583,3,206,103,0,2583,299,1,0,0,0,2584,2585,3,336,168,0,2585,2586,
5,183,0,0,2586,2587,5,96,0,0,2587,2588,5,183,0,0,2588,2589,3,248,124,
0,2589,301,1,0,0,0,2590,2597,3,338,169,0,2591,2597,5,168,0,0,2592,2597,
3,304,152,0,2593,2597,5,115,0,0,2594,2597,3,306,153,0,2595,2597,3,310,
155,0,2596,2590,1,0,0,0,2596,2591,1,0,0,0,2596,2592,1,0,0,0,2596,2593,
1,0,0,0,2596,2594,1,0,0,0,2596,2595,1,0,0,0,2597,303,1,0,0,0,2598,2599,
7,7,0,0,2599,305,1,0,0,0,2600,2602,5,7,0,0,2601,2603,5,183,0,0,2602,2601,
1,0,0,0,2602,2603,1,0,0,0,2603,2617,1,0,0,0,2604,2606,3,248,124,0,2605,
2607,5,183,0,0,2606,2605,1,0,0,0,2606,2607,1,0,0,0,2607,2614,1,0,0,0,
2608,2610,3,308,154,0,2609,2611,5,183,0,0,2610,2609,1,0,0,0,2610,2611,
1,0,0,0,2611,2613,1,0,0,0,2612,2608,1,0,0,0,2613,2616,1,0,0,0,2614,2612,
1,0,0,0,2614,2615,1,0,0,0,2615,2618,1,0,0,0,2616,2614,1,0,0,0,2617,2604,
1,0,0,0,2617,2618,1,0,0,0,2618,2619,1,0,0,0,2619,2620,5,8,0,0,2620,307,
1,0,0,0,2621,2623,5,4,0,0,2622,2624,5,183,0,0,2623,2622,1,0,0,0,2623,
2624,1,0,0,0,2624,2626,1,0,0,0,2625,2627,3,248,124,0,2626,2625,1,0,0,
0,2626,2627,1,0,0,0,2627,309,1,0,0,0,2628,2630,5,9,0,0,2629,2631,5,183,
0,0,2630,2629,1,0,0,0,2630,2631,1,0,0,0,2631,2632,1,0,0,0,2632,2634,3,
312,156,0,2633,2635,5,183,0,0,2634,2633,1,0,0,0,2634,2635,1,0,0,0,2635,
2646,1,0,0,0,2636,2638,5,4,0,0,2637,2639,5,183,0,0,2638,2637,1,0,0,0,
2638,2639,1,0,0,0,2639,2640,1,0,0,0,2640,2642,3,312,156,0,2641,2643,5,
183,0,0,2642,2641,1,0,0,0,2642,2643,1,0,0,0,2643,2645,1,0,0,0,2644,2636,
1,0,0,0,2645,2648,1,0,0,0,2646,2644,1,0,0,0,2646,2647,1,0,0,0,2647,2649,
1,0,0,0,2648,2646,1,0,0,0,2649,2650,5,10,0,0,2650,311,1,0,0,0,2651,2654,
3,352,176,0,2652,2654,5,168,0,0,2653,2651,1,0,0,0,2653,2652,1,0,0,0,2654,
2656,1,0,0,0,2655,2657,5,183,0,0,2656,2655,1,0,0,0,2656,2657,1,0,0,0,
2657,2658,1,0,0,0,2658,2660,5,164,0,0,2659,2661,5,183,0,0,2660,2659,1,
0,0,0,2660,2661,1,0,0,0,2661,2662,1,0,0,0,2662,2663,3,248,124,0,2663,
313,1,0,0,0,2664,2666,5,2,0,0,2665,2667,5,183,0,0,2666,2665,1,0,0,0,2666,
2667,1,0,0,0,2667,2668,1,0,0,0,2668,2670,3,248,124,0,2669,2671,5,183,
0,0,2670,2669,1,0,0,0,2670,2671,1,0,0,0,2671,2672,1,0,0,0,2672,2673,5,
3,0,0,2673,315,1,0,0,0,2674,2676,5,67,0,0,2675,2677,5,183,0,0,2676,2675,
1,0,0,0,2676,2677,1,0,0,0,2677,2678,1,0,0,0,2678,2680,5,2,0,0,2679,2681,
5,183,0,0,2680,2679,1,0,0,0,2680,2681,1,0,0,0,2681,2682,1,0,0,0,2682,
2684,5,161,0,0,2683,2685,5,183,0,0,2684,2683,1,0,0,0,2684,2685,1,0,0,
0,2685,2686,1,0,0,0,2686,2752,5,3,0,0,2687,2689,5,59,0,0,2688,2690,5,
183,0,0,2689,2688,1,0,0,0,2689,2690,1,0,0,0,2690,2691,1,0,0,0,2691,2693,
5,2,0,0,2692,2694,5,183,0,0,2693,2692,1,0,0,0,2693,2694,1,0,0,0,2694,
2695,1,0,0,0,2695,2697,3,320,160,0,2696,2698,5,183,0,0,2697,2696,1,0,
0,0,2697,2698,1,0,0,0,2698,2709,1,0,0,0,2699,2701,5,51,0,0,2700,2702,
5,183,0,0,2701,2700,1,0,0,0,2701,2702,1,0,0,0,2702,2703,1,0,0,0,2703,
2710,3,118,59,0,2704,2706,5,4,0,0,2705,2707,5,183,0,0,2706,2705,1,0,0,
0,2706,2707,1,0,0,0,2707,2708,1,0,0,0,2708,2710,3,320,160,0,2709,2699,
1,0,0,0,2709,2704,1,0,0,0,2710,2712,1,0,0,0,2711,2713,5,183,0,0,2712,
2711,1,0,0,0,2712,2713,1,0,0,0,2713,2714,1,0,0,0,2714,2715,5,3,0,0,2715,
2752,1,0,0,0,2716,2718,3,318,159,0,2717,2719,5,183,0,0,2718,2717,1,0,
0,0,2718,2719,1,0,0,0,2719,2720,1,0,0,0,2720,2722,5,2,0,0,2721,2723,5,
183,0,0,2722,2721,1,0,0,0,2722,2723,1,0,0,0,2723,2728,1,0,0,0,2724,2726,
5,77,0,0,2725,2727,5,183,0,0,2726,2725,1,0,0,0,2726,2727,1,0,0,0,2727,
2729,1,0,0,0,2728,2724,1,0,0,0,2728,2729,1,0,0,0,2729,2747,1,0,0,0,2730,
2732,3,320,160,0,2731,2733,5,183,0,0,2732,2731,1,0,0,0,2732,2733,1,0,
0,0,2733,2744,1,0,0,0,2734,2736,5,4,0,0,2735,2737,5,183,0,0,2736,2735,
1,0,0,0,2736,2737,1,0,0,0,2737,2738,1,0,0,0,2738,2740,3,320,160,0,2739,
2741,5,183,0,0,2740,2739,1,0,0,0,2740,2741,1,0,0,0,2741,2743,1,0,0,0,
2742,2734,1,0,0,0,2743,2746,1,0,0,0,2744,2742,1,0,0,0,2744,2745,1,0,0,
0,2745,2748,1,0,0,0,2746,2744,1,0,0,0,2747,2730,1,0,0,0,2747,2748,1,0,
0,0,2748,2749,1,0,0,0,2749,2750,5,3,0,0,2750,2752,1,0,0,0,2751,2674,1,
0,0,0,2751,2687,1,0,0,0,2751,2716,1,0,0,0,2752,317,1,0,0,0,2753,2754,
3,352,176,0,2754,319,1,0,0,0,2755,2757,3,352,176,0,2756,2758,5,183,0,
0,2757,2756,1,0,0,0,2757,2758,1,0,0,0,2758,2759,1,0,0,0,2759,2760,5,164,
0,0,2760,2762,5,6,0,0,2761,2763,5,183,0,0,2762,2761,1,0,0,0,2762,2763,
1,0,0,0,2763,2765,1,0,0,0,2764,2755,1,0,0,0,2764,2765,1,0,0,0,2765,2766,
1,0,0,0,2766,2769,3,248,124,0,2767,2769,3,322,161,0,2768,2764,1,0,0,0,
2768,2767,1,0,0,0,2769,321,1,0,0,0,2770,2772,3,324,162,0,2771,2773,5,
183,0,0,2772,2771,1,0,0,0,2772,2773,1,0,0,0,2773,2774,1,0,0,0,2774,2775,
5,166,0,0,2775,2777,5,15,0,0,2776,2778,5,183,0,0,2777,2776,1,0,0,0,2777,
2778,1,0,0,0,2778,2779,1,0,0,0,2779,2781,3,248,124,0,2780,2782,5,183,
0,0,2781,2780,1,0,0,0,2781,2782,1,0,0,0,2782,323,1,0,0,0,2783,2808,3,
352,176,0,2784,2786,5,2,0,0,2785,2787,5,183,0,0,2786,2785,1,0,0,0,2786,
2787,1,0,0,0,2787,2788,1,0,0,0,2788,2790,3,352,176,0,2789,2791,5,183,
0,0,2790,2789,1,0,0,0,2790,2791,1,0,0,0,2791,2802,1,0,0,0,2792,2794,5,
4,0,0,2793,2795,5,183,0,0,2794,2793,1,0,0,0,2794,2795,1,0,0,0,2795,2796,
1,0,0,0,2796,2798,3,352,176,0,2797,2799,5,183,0,0,2798,2797,1,0,0,0,2798,
2799,1,0,0,0,2799,2801,1,0,0,0,2800,2792,1,0,0,0,2801,2804,1,0,0,0,2802,
2800,1,0,0,0,2802,2803,1,0,0,0,2803,2805,1,0,0,0,2804,2802,1,0,0,0,2805,
2806,5,3,0,0,2806,2808,1,0,0,0,2807,2783,1,0,0,0,2807,2784,1,0,0,0,2808,
325,1,0,0,0,2809,2814,3,216,108,0,2810,2812,5,183,0,0,2811,2810,1,0,0,
0,2811,2812,1,0,0,0,2812,2813,1,0,0,0,2813,2815,3,218,109,0,2814,2811,
1,0,0,0,2815,2816,1,0,0,0,2816,2814,1,0,0,0,2816,2817,1,0,0,0,2817,327,
1,0,0,0,2818,2820,7,8,0,0,2819,2821,5,183,0,0,2820,2819,1,0,0,0,2820,
2821,1,0,0,0,2821,2822,1,0,0,0,2822,2824,5,9,0,0,2823,2825,5,183,0,0,
2824,2823,1,0,0,0,2824,2825,1,0,0,0,2825,2826,1,0,0,0,2826,2828,5,106,
0,0,2827,2829,5,183,0,0,2828,2827,1,0,0,0,2828,2829,1,0,0,0,2829,2830,
1,0,0,0,2830,2835,3,208,104,0,2831,2833,5,183,0,0,2832,2831,1,0,0,0,2832,
2833,1,0,0,0,2833,2834,1,0,0,0,2834,2836,3,206,103,0,2835,2832,1,0,0,
0,2835,2836,1,0,0,0,2836,2841,1,0,0,0,2837,2839,5,183,0,0,2838,2837,1,
0,0,0,2838,2839,1,0,0,0,2839,2840,1,0,0,0,2840,2842,3,170,85,0,2841,2838,
1,0,0,0,2841,2842,1,0,0,0,2842,2844,1,0,0,0,2843,2845,5,183,0,0,2844,
2843,1,0,0,0,2844,2845,1,0,0,0,2845,2846,1,0,0,0,2846,2847,5,10,0,0,2847,
329,1,0,0,0,2848,2850,5,5,0,0,2849,2851,5,183,0,0,2850,2849,1,0,0,0,2850,
2851,1,0,0,0,2851,2854,1,0,0,0,2852,2855,3,344,172,0,2853,2855,5,161,
0,0,2854,2852,1,0,0,0,2854,2853,1,0,0,0,2855,331,1,0,0,0,2856,2861,5,
58,0,0,2857,2859,5,183,0,0,2858,2857,1,0,0,0,2858,2859,1,0,0,0,2859,2860,
1,0,0,0,2860,2862,3,334,167,0,2861,2858,1,0,0,0,2862,2863,1,0,0,0,2863,
2861,1,0,0,0,2863,2864,1,0,0,0,2864,2879,1,0,0,0,2865,2867,5,58,0,0,2866,
2868,5,183,0,0,2867,2866,1,0,0,0,2867,2868,1,0,0,0,2868,2869,1,0,0,0,
2869,2874,3,248,124,0,2870,2872,5,183,0,0,2871,2870,1,0,0,0,2871,2872,
1,0,0,0,2872,2873,1,0,0,0,2873,2875,3,334,167,0,2874,2871,1,0,0,0,2875,
2876,1,0,0,0,2876,2874,1,0,0,0,2876,2877,1,0,0,0,2877,2879,1,0,0,0,2878,
2856,1,0,0,0,2878,2865,1,0,0,0,2879,2888,1,0,0,0,2880,2882,5,183,0,0,
2881,2880,1,0,0,0,2881,2882,1,0,0,0,2882,2883,1,0,0,0,2883,2885,5,79,
0,0,2884,2886,5,183,0,0,2885,2884,1,0,0,0,2885,2886,1,0,0,0,2886,2887,
1,0,0,0,2887,2889,3,248,124,0,2888,2881,1,0,0,0,2888,2889,1,0,0,0,2889,
2891,1,0,0,0,2890,2892,5,183,0,0,2891,2890,1,0,0,0,2891,2892,1,0,0,0,
2892,2893,1,0,0,0,2893,2894,5,80,0,0,2894,333,1,0,0,0,2895,2897,5,148,
0,0,2896,2898,5,183,0,0,2897,2896,1,0,0,0,2897,2898,1,0,0,0,2898,2899,
1,0,0,0,2899,2901,3,248,124,0,2900,2902,5,183,0,0,2901,2900,1,0,0,0,2901,
2902,1,0,0,0,2902,2903,1,0,0,0,2903,2905,5,137,0,0,2904,2906,5,183,0,
0,2905,2904,1,0,0,0,2905,2906,1,0,0,0,2906,2907,1,0,0,0,2907,2908,3,248,
124,0,2908,335,1,0,0,0,2909,2910,3,352,176,0,2910,337,1,0,0,0,2911,2914,
3,348,174,0,2912,2914,3,346,173,0,2913,2911,1,0,0,0,2913,2912,1,0,0,0,
2914,339,1,0,0,0,2915,2918,5,25,0,0,2916,2919,3,352,176,0,2917,2919,5,
170,0,0,2918,2916,1,0,0,0,2918,2917,1,0,0,0,2919,341,1,0,0,0,2920,2922,
3,294,147,0,2921,2923,5,183,0,0,2922,2921,1,0,0,0,2922,2923,1,0,0,0,2923,
2924,1,0,0,0,2924,2925,3,330,165,0,2925,343,1,0,0,0,2926,2927,3,352,176,
0,2927,345,1,0,0,0,2928,2929,5,170,0,0,2929,347,1,0,0,0,2930,2931,7,9,
0,0,2931,349,1,0,0,0,2932,2935,3,352,176,0,2933,2934,5,5,0,0,2934,2936,
3,352,176,0,2935,2933,1,0,0,0,2935,2936,1,0,0,0,2936,351,1,0,0,0,2937,
2943,5,179,0,0,2938,2939,5,182,0,0,2939,2943,6,176,-1,0,2940,2943,5,171,
0,0,2941,2943,3,354,177,0,2942,2937,1,0,0,0,2942,2938,1,0,0,0,2942,2940,
1,0,0,0,2942,2941,1,0,0,0,2943,353,1,0,0,0,2944,2945,7,10,0,0,2945,355,
1,0,0,0,2946,2947,7,11,0,0,2947,357,1,0,0,0,2948,2949,7,12,0,0,2949,359,
1,0,0,0,2950,2951,7,13,0,0,2951,361,1,0,0,0,502,364,368,373,377,382,385,
389,392,418,424,431,435,439,443,446,450,454,458,463,467,469,476,480,489,
494,504,508,512,517,530,534,542,546,550,554,562,566,570,574,589,594,600,
604,607,610,616,620,625,628,633,637,641,646,664,676,680,687,707,711,714,
717,720,723,727,732,736,746,750,755,760,765,771,775,779,784,791,795,799,
802,819,823,827,831,835,838,841,849,854,858,862,866,875,879,884,888,892,
896,900,902,906,910,912,920,925,929,933,937,941,945,950,968,975,988,995,
1011,1015,1024,1032,1035,1045,1048,1056,1059,1065,1068,1074,1089,1107,
1114,1121,1132,1155,1164,1170,1174,1179,1188,1192,1197,1203,1209,1215,
1219,1223,1229,1233,1237,1243,1247,1251,1257,1261,1265,1269,1273,1279,
1283,1287,1291,1295,1305,1311,1318,1323,1329,1334,1351,1357,1363,1367,
1371,1380,1394,1399,1404,1408,1413,1419,1424,1427,1431,1435,1439,1445,
1449,1454,1459,1463,1466,1468,1472,1476,1482,1486,1491,1495,1504,1510,
1518,1522,1526,1530,1537,1541,1545,1549,1552,1555,1562,1568,1572,1577,
1584,1587,1590,1595,1599,1603,1608,1612,1621,1625,1630,1644,1646,1648,
1653,1663,1669,1676,1689,1693,1697,1701,1706,1711,1715,1719,1723,1727,
1731,1737,1741,1745,1749,1754,1760,1763,1769,1772,1778,1782,1786,1790,
1794,1799,1804,1808,1813,1816,1825,1834,1839,1852,1855,1863,1867,1872,
1877,1881,1886,1892,1897,1904,1908,1912,1914,1918,1920,1924,1926,1932,
1938,1942,1945,1948,1954,1957,1960,1964,1970,1973,1976,1980,1984,1988,
1990,1994,1996,2000,2002,2006,2008,2014,2018,2022,2026,2030,2034,2038,
2042,2046,2049,2055,2059,2063,2066,2071,2076,2080,2084,2087,2090,2095,
2100,2103,2106,2109,2112,2115,2119,2123,2127,2131,2141,2144,2147,2151,
2154,2157,2161,2165,2169,2173,2177,2181,2183,2186,2190,2194,2198,2202,
2204,2210,2213,2216,2227,2240,2250,2260,2265,2269,2276,2280,2284,2288,
2292,2300,2304,2308,2312,2318,2322,2328,2332,2337,2342,2346,2351,2356,
2360,2366,2373,2377,2383,2390,2394,2400,2407,2411,2416,2424,2427,2432,
2441,2445,2448,2461,2464,2469,2483,2487,2491,2496,2499,2503,2508,2520,
2524,2528,2532,2538,2542,2546,2552,2556,2560,2566,2570,2574,2578,2596,
2602,2606,2610,2614,2617,2623,2626,2630,2634,2638,2642,2646,2653,2656,
2660,2666,2670,2676,2680,2684,2689,2693,2697,2701,2706,2709,2712,2718,
2722,2726,2728,2732,2736,2740,2744,2747,2751,2757,2762,2764,2768,2772,
2777,2781,2786,2790,2794,2798,2802,2807,2811,2816,2820,2824,2828,2832,
2835,2838,2841,2844,2850,2854,2858,2863,2867,2871,2876,2878,2881,2885,
2888,2891,2897,2901,2905,2913,2918,2922,2935,2942
};
staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
antlr4::atn::ATNDeserializer deserializer;
staticData->atn = deserializer.deserialize(staticData->serializedATN);
const size_t count = staticData->atn->getNumberOfDecisions();
staticData->decisionToDFA.reserve(count);
for (size_t i = 0; i < count; i++) {
staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
}
cypherParserStaticData = staticData.release();
}
}
CypherParser::CypherParser(TokenStream *input) : CypherParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
CypherParser::CypherParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
CypherParser::initialize();
_interpreter = new atn::ParserATNSimulator(this, *cypherParserStaticData->atn, cypherParserStaticData->decisionToDFA, cypherParserStaticData->sharedContextCache, options);
}
CypherParser::~CypherParser() {
delete _interpreter;
}
const atn::ATN& CypherParser::getATN() const {
return *cypherParserStaticData->atn;
}
std::string CypherParser::getGrammarFileName() const {
return "Cypher.g4";
}
const std::vector<std::string>& CypherParser::getRuleNames() const {
return cypherParserStaticData->ruleNames;
}
const dfa::Vocabulary& CypherParser::getVocabulary() const {
return cypherParserStaticData->vocabulary;
}
antlr4::atn::SerializedATNView CypherParser::getSerializedATN() const {
return cypherParserStaticData->serializedATN;
}
CypherParser::IC_StatementsContext::IC_StatementsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_CypherContext *> CypherParser::IC_StatementsContext::oC_Cypher() {
return getRuleContexts<CypherParser::OC_CypherContext>();
}
CypherParser::OC_CypherContext* CypherParser::IC_StatementsContext::oC_Cypher(size_t i) {
return getRuleContext<CypherParser::OC_CypherContext>(i);
}
tree::TerminalNode* CypherParser::IC_StatementsContext::EOF() {
return getToken(CypherParser::EOF, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_StatementsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_StatementsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_StatementsContext::getRuleIndex() const {
return CypherParser::RuleIC_Statements;
}
CypherParser::IC_StatementsContext* CypherParser::iC_Statements() {
IC_StatementsContext *_localctx = _tracker.createInstance<IC_StatementsContext>(_ctx, getState());
enterRule(_localctx, 0, CypherParser::RuleIC_Statements);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(362);
oC_Cypher();
setState(373);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(364);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(363);
match(CypherParser::SP);
}
setState(366);
match(CypherParser::T__0);
setState(368);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
case 1: {
setState(367);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(370);
oC_Cypher();
}
setState(375);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
}
setState(377);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(376);
match(CypherParser::SP);
}
setState(379);
match(CypherParser::EOF);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_CypherContext::OC_CypherContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_StatementContext* CypherParser::OC_CypherContext::oC_Statement() {
return getRuleContext<CypherParser::OC_StatementContext>(0);
}
CypherParser::OC_AnyCypherOptionContext* CypherParser::OC_CypherContext::oC_AnyCypherOption() {
return getRuleContext<CypherParser::OC_AnyCypherOptionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_CypherContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_CypherContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_CypherContext::getRuleIndex() const {
return CypherParser::RuleOC_Cypher;
}
CypherParser::OC_CypherContext* CypherParser::oC_Cypher() {
OC_CypherContext *_localctx = _tracker.createInstance<OC_CypherContext>(_ctx, getState());
enterRule(_localctx, 2, CypherParser::RuleOC_Cypher);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(382);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::EXPLAIN
|| _la == CypherParser::PROFILE) {
setState(381);
oC_AnyCypherOption();
}
setState(385);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(384);
match(CypherParser::SP);
}
setState(387);
oC_Statement();
setState(392);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
case 1: {
setState(389);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(388);
match(CypherParser::SP);
}
setState(391);
match(CypherParser::T__0);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_StatementContext::OC_StatementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_QueryContext* CypherParser::OC_StatementContext::oC_Query() {
return getRuleContext<CypherParser::OC_QueryContext>(0);
}
CypherParser::IC_CreateUserContext* CypherParser::OC_StatementContext::iC_CreateUser() {
return getRuleContext<CypherParser::IC_CreateUserContext>(0);
}
CypherParser::IC_CreateRoleContext* CypherParser::OC_StatementContext::iC_CreateRole() {
return getRuleContext<CypherParser::IC_CreateRoleContext>(0);
}
CypherParser::IC_CreateNodeTableContext* CypherParser::OC_StatementContext::iC_CreateNodeTable() {
return getRuleContext<CypherParser::IC_CreateNodeTableContext>(0);
}
CypherParser::IC_CreateRelTableContext* CypherParser::OC_StatementContext::iC_CreateRelTable() {
return getRuleContext<CypherParser::IC_CreateRelTableContext>(0);
}
CypherParser::IC_CreateSequenceContext* CypherParser::OC_StatementContext::iC_CreateSequence() {
return getRuleContext<CypherParser::IC_CreateSequenceContext>(0);
}
CypherParser::IC_CreateTypeContext* CypherParser::OC_StatementContext::iC_CreateType() {
return getRuleContext<CypherParser::IC_CreateTypeContext>(0);
}
CypherParser::IC_DropContext* CypherParser::OC_StatementContext::iC_Drop() {
return getRuleContext<CypherParser::IC_DropContext>(0);
}
CypherParser::IC_AlterTableContext* CypherParser::OC_StatementContext::iC_AlterTable() {
return getRuleContext<CypherParser::IC_AlterTableContext>(0);
}
CypherParser::IC_CopyFromContext* CypherParser::OC_StatementContext::iC_CopyFrom() {
return getRuleContext<CypherParser::IC_CopyFromContext>(0);
}
CypherParser::IC_CopyFromByColumnContext* CypherParser::OC_StatementContext::iC_CopyFromByColumn() {
return getRuleContext<CypherParser::IC_CopyFromByColumnContext>(0);
}
CypherParser::IC_CopyTOContext* CypherParser::OC_StatementContext::iC_CopyTO() {
return getRuleContext<CypherParser::IC_CopyTOContext>(0);
}
CypherParser::IC_StandaloneCallContext* CypherParser::OC_StatementContext::iC_StandaloneCall() {
return getRuleContext<CypherParser::IC_StandaloneCallContext>(0);
}
CypherParser::IC_CreateMacroContext* CypherParser::OC_StatementContext::iC_CreateMacro() {
return getRuleContext<CypherParser::IC_CreateMacroContext>(0);
}
CypherParser::IC_CommentOnContext* CypherParser::OC_StatementContext::iC_CommentOn() {
return getRuleContext<CypherParser::IC_CommentOnContext>(0);
}
CypherParser::IC_TransactionContext* CypherParser::OC_StatementContext::iC_Transaction() {
return getRuleContext<CypherParser::IC_TransactionContext>(0);
}
CypherParser::IC_ExtensionContext* CypherParser::OC_StatementContext::iC_Extension() {
return getRuleContext<CypherParser::IC_ExtensionContext>(0);
}
CypherParser::IC_ExportDatabaseContext* CypherParser::OC_StatementContext::iC_ExportDatabase() {
return getRuleContext<CypherParser::IC_ExportDatabaseContext>(0);
}
CypherParser::IC_ImportDatabaseContext* CypherParser::OC_StatementContext::iC_ImportDatabase() {
return getRuleContext<CypherParser::IC_ImportDatabaseContext>(0);
}
CypherParser::IC_AttachDatabaseContext* CypherParser::OC_StatementContext::iC_AttachDatabase() {
return getRuleContext<CypherParser::IC_AttachDatabaseContext>(0);
}
CypherParser::IC_DetachDatabaseContext* CypherParser::OC_StatementContext::iC_DetachDatabase() {
return getRuleContext<CypherParser::IC_DetachDatabaseContext>(0);
}
CypherParser::IC_UseDatabaseContext* CypherParser::OC_StatementContext::iC_UseDatabase() {
return getRuleContext<CypherParser::IC_UseDatabaseContext>(0);
}
CypherParser::IC_CreateGraphContext* CypherParser::OC_StatementContext::iC_CreateGraph() {
return getRuleContext<CypherParser::IC_CreateGraphContext>(0);
}
CypherParser::IC_UseGraphContext* CypherParser::OC_StatementContext::iC_UseGraph() {
return getRuleContext<CypherParser::IC_UseGraphContext>(0);
}
size_t CypherParser::OC_StatementContext::getRuleIndex() const {
return CypherParser::RuleOC_Statement;
}
CypherParser::OC_StatementContext* CypherParser::oC_Statement() {
OC_StatementContext *_localctx = _tracker.createInstance<OC_StatementContext>(_ctx, getState());
enterRule(_localctx, 4, CypherParser::RuleOC_Statement);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(418);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(394);
oC_Query();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(395);
iC_CreateUser();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(396);
iC_CreateRole();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(397);
iC_CreateNodeTable();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(398);
iC_CreateRelTable();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(399);
iC_CreateSequence();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(400);
iC_CreateType();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(401);
iC_Drop();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(402);
iC_AlterTable();
break;
}
case 10: {
enterOuterAlt(_localctx, 10);
setState(403);
iC_CopyFrom();
break;
}
case 11: {
enterOuterAlt(_localctx, 11);
setState(404);
iC_CopyFromByColumn();
break;
}
case 12: {
enterOuterAlt(_localctx, 12);
setState(405);
iC_CopyTO();
break;
}
case 13: {
enterOuterAlt(_localctx, 13);
setState(406);
iC_StandaloneCall();
break;
}
case 14: {
enterOuterAlt(_localctx, 14);
setState(407);
iC_CreateMacro();
break;
}
case 15: {
enterOuterAlt(_localctx, 15);
setState(408);
iC_CommentOn();
break;
}
case 16: {
enterOuterAlt(_localctx, 16);
setState(409);
iC_Transaction();
break;
}
case 17: {
enterOuterAlt(_localctx, 17);
setState(410);
iC_Extension();
break;
}
case 18: {
enterOuterAlt(_localctx, 18);
setState(411);
iC_ExportDatabase();
break;
}
case 19: {
enterOuterAlt(_localctx, 19);
setState(412);
iC_ImportDatabase();
break;
}
case 20: {
enterOuterAlt(_localctx, 20);
setState(413);
iC_AttachDatabase();
break;
}
case 21: {
enterOuterAlt(_localctx, 21);
setState(414);
iC_DetachDatabase();
break;
}
case 22: {
enterOuterAlt(_localctx, 22);
setState(415);
iC_UseDatabase();
break;
}
case 23: {
enterOuterAlt(_localctx, 23);
setState(416);
iC_CreateGraph();
break;
}
case 24: {
enterOuterAlt(_localctx, 24);
setState(417);
iC_UseGraph();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CopyFromContext::IC_CopyFromContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CopyFromContext::COPY() {
return getToken(CypherParser::COPY, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CopyFromContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CopyFromContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CopyFromContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_CopyFromContext::FROM() {
return getToken(CypherParser::FROM, 0);
}
CypherParser::IC_ScanSourceContext* CypherParser::IC_CopyFromContext::iC_ScanSource() {
return getRuleContext<CypherParser::IC_ScanSourceContext>(0);
}
CypherParser::IC_ColumnNamesContext* CypherParser::IC_CopyFromContext::iC_ColumnNames() {
return getRuleContext<CypherParser::IC_ColumnNamesContext>(0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_CopyFromContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
size_t CypherParser::IC_CopyFromContext::getRuleIndex() const {
return CypherParser::RuleIC_CopyFrom;
}
CypherParser::IC_CopyFromContext* CypherParser::iC_CopyFrom() {
IC_CopyFromContext *_localctx = _tracker.createInstance<IC_CopyFromContext>(_ctx, getState());
enterRule(_localctx, 6, CypherParser::RuleIC_CopyFrom);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(420);
match(CypherParser::COPY);
setState(421);
match(CypherParser::SP);
setState(422);
oC_SchemaName();
setState(424);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
case 1: {
setState(423);
iC_ColumnNames();
break;
}
default:
break;
}
setState(426);
match(CypherParser::SP);
setState(427);
match(CypherParser::FROM);
setState(428);
match(CypherParser::SP);
setState(429);
iC_ScanSource();
setState(443);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx)) {
case 1: {
setState(431);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(430);
match(CypherParser::SP);
}
setState(433);
match(CypherParser::T__1);
setState(435);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(434);
match(CypherParser::SP);
}
setState(437);
iC_Options();
setState(439);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(438);
match(CypherParser::SP);
}
setState(441);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ColumnNamesContext::IC_ColumnNamesContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::IC_ColumnNamesContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_ColumnNamesContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_SchemaNameContext *> CypherParser::IC_ColumnNamesContext::oC_SchemaName() {
return getRuleContexts<CypherParser::OC_SchemaNameContext>();
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_ColumnNamesContext::oC_SchemaName(size_t i) {
return getRuleContext<CypherParser::OC_SchemaNameContext>(i);
}
size_t CypherParser::IC_ColumnNamesContext::getRuleIndex() const {
return CypherParser::RuleIC_ColumnNames;
}
CypherParser::IC_ColumnNamesContext* CypherParser::iC_ColumnNames() {
IC_ColumnNamesContext *_localctx = _tracker.createInstance<IC_ColumnNamesContext>(_ctx, getState());
enterRule(_localctx, 8, CypherParser::RuleIC_ColumnNames);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(446);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(445);
match(CypherParser::SP);
}
setState(448);
match(CypherParser::T__1);
setState(450);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(449);
match(CypherParser::SP);
}
setState(469);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -287985230644762313) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5068755015275819) != 0)) {
setState(452);
oC_SchemaName();
setState(463);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(454);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(453);
match(CypherParser::SP);
}
setState(456);
match(CypherParser::T__3);
setState(458);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(457);
match(CypherParser::SP);
}
setState(460);
oC_SchemaName();
}
setState(465);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
}
setState(467);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(466);
match(CypherParser::SP);
}
}
setState(471);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ScanSourceContext::IC_ScanSourceContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::IC_FilePathsContext* CypherParser::IC_ScanSourceContext::iC_FilePaths() {
return getRuleContext<CypherParser::IC_FilePathsContext>(0);
}
CypherParser::OC_QueryContext* CypherParser::IC_ScanSourceContext::oC_Query() {
return getRuleContext<CypherParser::OC_QueryContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_ScanSourceContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_ScanSourceContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_ParameterContext* CypherParser::IC_ScanSourceContext::oC_Parameter() {
return getRuleContext<CypherParser::OC_ParameterContext>(0);
}
CypherParser::OC_VariableContext* CypherParser::IC_ScanSourceContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_ScanSourceContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
CypherParser::OC_FunctionInvocationContext* CypherParser::IC_ScanSourceContext::oC_FunctionInvocation() {
return getRuleContext<CypherParser::OC_FunctionInvocationContext>(0);
}
size_t CypherParser::IC_ScanSourceContext::getRuleIndex() const {
return CypherParser::RuleIC_ScanSource;
}
CypherParser::IC_ScanSourceContext* CypherParser::iC_ScanSource() {
IC_ScanSourceContext *_localctx = _tracker.createInstance<IC_ScanSourceContext>(_ctx, getState());
enterRule(_localctx, 10, CypherParser::RuleIC_ScanSource);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(494);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(473);
iC_FilePaths();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(474);
match(CypherParser::T__1);
setState(476);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(475);
match(CypherParser::SP);
}
setState(478);
oC_Query();
setState(480);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(479);
match(CypherParser::SP);
}
setState(482);
match(CypherParser::T__2);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(484);
oC_Parameter();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(485);
oC_Variable();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(486);
oC_Variable();
setState(487);
match(CypherParser::T__4);
setState(489);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(488);
match(CypherParser::SP);
}
setState(491);
oC_SchemaName();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(493);
oC_FunctionInvocation();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CopyFromByColumnContext::IC_CopyFromByColumnContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CopyFromByColumnContext::COPY() {
return getToken(CypherParser::COPY, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CopyFromByColumnContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CopyFromByColumnContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CopyFromByColumnContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_CopyFromByColumnContext::FROM() {
return getToken(CypherParser::FROM, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CopyFromByColumnContext::StringLiteral() {
return getTokens(CypherParser::StringLiteral);
}
tree::TerminalNode* CypherParser::IC_CopyFromByColumnContext::StringLiteral(size_t i) {
return getToken(CypherParser::StringLiteral, i);
}
tree::TerminalNode* CypherParser::IC_CopyFromByColumnContext::BY() {
return getToken(CypherParser::BY, 0);
}
tree::TerminalNode* CypherParser::IC_CopyFromByColumnContext::COLUMN() {
return getToken(CypherParser::COLUMN, 0);
}
size_t CypherParser::IC_CopyFromByColumnContext::getRuleIndex() const {
return CypherParser::RuleIC_CopyFromByColumn;
}
CypherParser::IC_CopyFromByColumnContext* CypherParser::iC_CopyFromByColumn() {
IC_CopyFromByColumnContext *_localctx = _tracker.createInstance<IC_CopyFromByColumnContext>(_ctx, getState());
enterRule(_localctx, 12, CypherParser::RuleIC_CopyFromByColumn);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(496);
match(CypherParser::COPY);
setState(497);
match(CypherParser::SP);
setState(498);
oC_SchemaName();
setState(499);
match(CypherParser::SP);
setState(500);
match(CypherParser::FROM);
setState(501);
match(CypherParser::SP);
setState(502);
match(CypherParser::T__1);
setState(504);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(503);
match(CypherParser::SP);
}
setState(506);
match(CypherParser::StringLiteral);
setState(517);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3 || _la == CypherParser::SP) {
setState(508);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(507);
match(CypherParser::SP);
}
setState(510);
match(CypherParser::T__3);
setState(512);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(511);
match(CypherParser::SP);
}
setState(514);
match(CypherParser::StringLiteral);
setState(519);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(520);
match(CypherParser::T__2);
setState(521);
match(CypherParser::SP);
setState(522);
match(CypherParser::BY);
setState(523);
match(CypherParser::SP);
setState(524);
match(CypherParser::COLUMN);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CopyTOContext::IC_CopyTOContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CopyTOContext::COPY() {
return getToken(CypherParser::COPY, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CopyTOContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CopyTOContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_QueryContext* CypherParser::IC_CopyTOContext::oC_Query() {
return getRuleContext<CypherParser::OC_QueryContext>(0);
}
tree::TerminalNode* CypherParser::IC_CopyTOContext::TO() {
return getToken(CypherParser::TO, 0);
}
tree::TerminalNode* CypherParser::IC_CopyTOContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_CopyTOContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
size_t CypherParser::IC_CopyTOContext::getRuleIndex() const {
return CypherParser::RuleIC_CopyTO;
}
CypherParser::IC_CopyTOContext* CypherParser::iC_CopyTO() {
IC_CopyTOContext *_localctx = _tracker.createInstance<IC_CopyTOContext>(_ctx, getState());
enterRule(_localctx, 14, CypherParser::RuleIC_CopyTO);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(526);
match(CypherParser::COPY);
setState(527);
match(CypherParser::SP);
setState(528);
match(CypherParser::T__1);
setState(530);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(529);
match(CypherParser::SP);
}
setState(532);
oC_Query();
setState(534);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(533);
match(CypherParser::SP);
}
setState(536);
match(CypherParser::T__2);
setState(537);
match(CypherParser::SP);
setState(538);
match(CypherParser::TO);
setState(539);
match(CypherParser::SP);
setState(540);
match(CypherParser::StringLiteral);
setState(554);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx)) {
case 1: {
setState(542);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(541);
match(CypherParser::SP);
}
setState(544);
match(CypherParser::T__1);
setState(546);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(545);
match(CypherParser::SP);
}
setState(548);
iC_Options();
setState(550);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(549);
match(CypherParser::SP);
}
setState(552);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ExportDatabaseContext::IC_ExportDatabaseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_ExportDatabaseContext::EXPORT() {
return getToken(CypherParser::EXPORT, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_ExportDatabaseContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_ExportDatabaseContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_ExportDatabaseContext::DATABASE() {
return getToken(CypherParser::DATABASE, 0);
}
tree::TerminalNode* CypherParser::IC_ExportDatabaseContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_ExportDatabaseContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
size_t CypherParser::IC_ExportDatabaseContext::getRuleIndex() const {
return CypherParser::RuleIC_ExportDatabase;
}
CypherParser::IC_ExportDatabaseContext* CypherParser::iC_ExportDatabase() {
IC_ExportDatabaseContext *_localctx = _tracker.createInstance<IC_ExportDatabaseContext>(_ctx, getState());
enterRule(_localctx, 16, CypherParser::RuleIC_ExportDatabase);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(556);
match(CypherParser::EXPORT);
setState(557);
match(CypherParser::SP);
setState(558);
match(CypherParser::DATABASE);
setState(559);
match(CypherParser::SP);
setState(560);
match(CypherParser::StringLiteral);
setState(574);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx)) {
case 1: {
setState(562);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(561);
match(CypherParser::SP);
}
setState(564);
match(CypherParser::T__1);
setState(566);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(565);
match(CypherParser::SP);
}
setState(568);
iC_Options();
setState(570);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(569);
match(CypherParser::SP);
}
setState(572);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ImportDatabaseContext::IC_ImportDatabaseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_ImportDatabaseContext::IMPORT() {
return getToken(CypherParser::IMPORT, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_ImportDatabaseContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_ImportDatabaseContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_ImportDatabaseContext::DATABASE() {
return getToken(CypherParser::DATABASE, 0);
}
tree::TerminalNode* CypherParser::IC_ImportDatabaseContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
size_t CypherParser::IC_ImportDatabaseContext::getRuleIndex() const {
return CypherParser::RuleIC_ImportDatabase;
}
CypherParser::IC_ImportDatabaseContext* CypherParser::iC_ImportDatabase() {
IC_ImportDatabaseContext *_localctx = _tracker.createInstance<IC_ImportDatabaseContext>(_ctx, getState());
enterRule(_localctx, 18, CypherParser::RuleIC_ImportDatabase);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(576);
match(CypherParser::IMPORT);
setState(577);
match(CypherParser::SP);
setState(578);
match(CypherParser::DATABASE);
setState(579);
match(CypherParser::SP);
setState(580);
match(CypherParser::StringLiteral);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_AttachDatabaseContext::IC_AttachDatabaseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_AttachDatabaseContext::ATTACH() {
return getToken(CypherParser::ATTACH, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_AttachDatabaseContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_AttachDatabaseContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_AttachDatabaseContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
tree::TerminalNode* CypherParser::IC_AttachDatabaseContext::DBTYPE() {
return getToken(CypherParser::DBTYPE, 0);
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_AttachDatabaseContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_AttachDatabaseContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_AttachDatabaseContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_AttachDatabaseContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
size_t CypherParser::IC_AttachDatabaseContext::getRuleIndex() const {
return CypherParser::RuleIC_AttachDatabase;
}
CypherParser::IC_AttachDatabaseContext* CypherParser::iC_AttachDatabase() {
IC_AttachDatabaseContext *_localctx = _tracker.createInstance<IC_AttachDatabaseContext>(_ctx, getState());
enterRule(_localctx, 20, CypherParser::RuleIC_AttachDatabase);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(582);
match(CypherParser::ATTACH);
setState(583);
match(CypherParser::SP);
setState(584);
match(CypherParser::StringLiteral);
setState(589);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
case 1: {
setState(585);
match(CypherParser::SP);
setState(586);
match(CypherParser::AS);
setState(587);
match(CypherParser::SP);
setState(588);
oC_SchemaName();
break;
}
default:
break;
}
setState(591);
match(CypherParser::SP);
setState(592);
match(CypherParser::T__1);
setState(594);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(593);
match(CypherParser::SP);
}
setState(596);
match(CypherParser::DBTYPE);
setState(597);
match(CypherParser::SP);
setState(598);
oC_SymbolicName();
setState(607);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
case 1: {
setState(600);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(599);
match(CypherParser::SP);
}
setState(602);
match(CypherParser::T__3);
setState(604);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(603);
match(CypherParser::SP);
}
setState(606);
iC_Options();
break;
}
default:
break;
}
setState(610);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(609);
match(CypherParser::SP);
}
setState(612);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_OptionContext::IC_OptionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_OptionContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
CypherParser::OC_LiteralContext* CypherParser::IC_OptionContext::oC_Literal() {
return getRuleContext<CypherParser::OC_LiteralContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_OptionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_OptionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_OptionContext::getRuleIndex() const {
return CypherParser::RuleIC_Option;
}
CypherParser::IC_OptionContext* CypherParser::iC_Option() {
IC_OptionContext *_localctx = _tracker.createInstance<IC_OptionContext>(_ctx, getState());
enterRule(_localctx, 22, CypherParser::RuleIC_Option);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(633);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(614);
oC_SymbolicName();
setState(628);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
case 1: {
setState(616);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(615);
match(CypherParser::SP);
}
setState(618);
match(CypherParser::T__5);
setState(620);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(619);
match(CypherParser::SP);
}
break;
}
case 2: {
setState(625);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::SP) {
setState(622);
match(CypherParser::SP);
setState(627);
_errHandler->sync(this);
_la = _input->LA(1);
}
break;
}
default:
break;
}
setState(630);
oC_Literal();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(632);
oC_SymbolicName();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_OptionsContext::IC_OptionsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_OptionContext *> CypherParser::IC_OptionsContext::iC_Option() {
return getRuleContexts<CypherParser::IC_OptionContext>();
}
CypherParser::IC_OptionContext* CypherParser::IC_OptionsContext::iC_Option(size_t i) {
return getRuleContext<CypherParser::IC_OptionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_OptionsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_OptionsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_OptionsContext::getRuleIndex() const {
return CypherParser::RuleIC_Options;
}
CypherParser::IC_OptionsContext* CypherParser::iC_Options() {
IC_OptionsContext *_localctx = _tracker.createInstance<IC_OptionsContext>(_ctx, getState());
enterRule(_localctx, 24, CypherParser::RuleIC_Options);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(635);
iC_Option();
setState(646);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(637);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(636);
match(CypherParser::SP);
}
setState(639);
match(CypherParser::T__3);
setState(641);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(640);
match(CypherParser::SP);
}
setState(643);
iC_Option();
}
setState(648);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DetachDatabaseContext::IC_DetachDatabaseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_DetachDatabaseContext::DETACH() {
return getToken(CypherParser::DETACH, 0);
}
tree::TerminalNode* CypherParser::IC_DetachDatabaseContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_DetachDatabaseContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
size_t CypherParser::IC_DetachDatabaseContext::getRuleIndex() const {
return CypherParser::RuleIC_DetachDatabase;
}
CypherParser::IC_DetachDatabaseContext* CypherParser::iC_DetachDatabase() {
IC_DetachDatabaseContext *_localctx = _tracker.createInstance<IC_DetachDatabaseContext>(_ctx, getState());
enterRule(_localctx, 26, CypherParser::RuleIC_DetachDatabase);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(649);
match(CypherParser::DETACH);
setState(650);
match(CypherParser::SP);
setState(651);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_UseDatabaseContext::IC_UseDatabaseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_UseDatabaseContext::USE() {
return getToken(CypherParser::USE, 0);
}
tree::TerminalNode* CypherParser::IC_UseDatabaseContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_UseDatabaseContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
size_t CypherParser::IC_UseDatabaseContext::getRuleIndex() const {
return CypherParser::RuleIC_UseDatabase;
}
CypherParser::IC_UseDatabaseContext* CypherParser::iC_UseDatabase() {
IC_UseDatabaseContext *_localctx = _tracker.createInstance<IC_UseDatabaseContext>(_ctx, getState());
enterRule(_localctx, 28, CypherParser::RuleIC_UseDatabase);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(653);
match(CypherParser::USE);
setState(654);
match(CypherParser::SP);
setState(655);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateGraphContext::IC_CreateGraphContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateGraphContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateGraphContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateGraphContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateGraphContext::GRAPH() {
return getToken(CypherParser::GRAPH, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CreateGraphContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateGraphContext::ANY() {
return getToken(CypherParser::ANY, 0);
}
size_t CypherParser::IC_CreateGraphContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateGraph;
}
CypherParser::IC_CreateGraphContext* CypherParser::iC_CreateGraph() {
IC_CreateGraphContext *_localctx = _tracker.createInstance<IC_CreateGraphContext>(_ctx, getState());
enterRule(_localctx, 30, CypherParser::RuleIC_CreateGraph);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(657);
match(CypherParser::CREATE);
setState(658);
match(CypherParser::SP);
setState(659);
match(CypherParser::GRAPH);
setState(660);
match(CypherParser::SP);
setState(661);
oC_SchemaName();
setState(664);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
case 1: {
setState(662);
match(CypherParser::SP);
setState(663);
match(CypherParser::ANY);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_UseGraphContext::IC_UseGraphContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_UseGraphContext::USE() {
return getToken(CypherParser::USE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_UseGraphContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_UseGraphContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_UseGraphContext::GRAPH() {
return getToken(CypherParser::GRAPH, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_UseGraphContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
size_t CypherParser::IC_UseGraphContext::getRuleIndex() const {
return CypherParser::RuleIC_UseGraph;
}
CypherParser::IC_UseGraphContext* CypherParser::iC_UseGraph() {
IC_UseGraphContext *_localctx = _tracker.createInstance<IC_UseGraphContext>(_ctx, getState());
enterRule(_localctx, 32, CypherParser::RuleIC_UseGraph);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(666);
match(CypherParser::USE);
setState(667);
match(CypherParser::SP);
setState(668);
match(CypherParser::GRAPH);
setState(669);
match(CypherParser::SP);
setState(670);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_StandaloneCallContext::IC_StandaloneCallContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_StandaloneCallContext::CALL() {
return getToken(CypherParser::CALL, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_StandaloneCallContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_StandaloneCallContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_StandaloneCallContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
CypherParser::OC_ExpressionContext* CypherParser::IC_StandaloneCallContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
CypherParser::OC_FunctionInvocationContext* CypherParser::IC_StandaloneCallContext::oC_FunctionInvocation() {
return getRuleContext<CypherParser::OC_FunctionInvocationContext>(0);
}
size_t CypherParser::IC_StandaloneCallContext::getRuleIndex() const {
return CypherParser::RuleIC_StandaloneCall;
}
CypherParser::IC_StandaloneCallContext* CypherParser::iC_StandaloneCall() {
IC_StandaloneCallContext *_localctx = _tracker.createInstance<IC_StandaloneCallContext>(_ctx, getState());
enterRule(_localctx, 34, CypherParser::RuleIC_StandaloneCall);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(687);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(672);
match(CypherParser::CALL);
setState(673);
match(CypherParser::SP);
setState(674);
oC_SymbolicName();
setState(676);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(675);
match(CypherParser::SP);
}
setState(678);
match(CypherParser::T__5);
setState(680);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(679);
match(CypherParser::SP);
}
setState(682);
oC_Expression();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(684);
match(CypherParser::CALL);
setState(685);
match(CypherParser::SP);
setState(686);
oC_FunctionInvocation();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CommentOnContext::IC_CommentOnContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CommentOnContext::COMMENT() {
return getToken(CypherParser::COMMENT, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CommentOnContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CommentOnContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CommentOnContext::ON() {
return getToken(CypherParser::ON, 0);
}
tree::TerminalNode* CypherParser::IC_CommentOnContext::TABLE() {
return getToken(CypherParser::TABLE, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CommentOnContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_CommentOnContext::IS() {
return getToken(CypherParser::IS, 0);
}
tree::TerminalNode* CypherParser::IC_CommentOnContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
size_t CypherParser::IC_CommentOnContext::getRuleIndex() const {
return CypherParser::RuleIC_CommentOn;
}
CypherParser::IC_CommentOnContext* CypherParser::iC_CommentOn() {
IC_CommentOnContext *_localctx = _tracker.createInstance<IC_CommentOnContext>(_ctx, getState());
enterRule(_localctx, 36, CypherParser::RuleIC_CommentOn);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(689);
match(CypherParser::COMMENT);
setState(690);
match(CypherParser::SP);
setState(691);
match(CypherParser::ON);
setState(692);
match(CypherParser::SP);
setState(693);
match(CypherParser::TABLE);
setState(694);
match(CypherParser::SP);
setState(695);
oC_SchemaName();
setState(696);
match(CypherParser::SP);
setState(697);
match(CypherParser::IS);
setState(698);
match(CypherParser::SP);
setState(699);
match(CypherParser::StringLiteral);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateMacroContext::IC_CreateMacroContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateMacroContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateMacroContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateMacroContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateMacroContext::MACRO() {
return getToken(CypherParser::MACRO, 0);
}
CypherParser::OC_FunctionNameContext* CypherParser::IC_CreateMacroContext::oC_FunctionName() {
return getRuleContext<CypherParser::OC_FunctionNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateMacroContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::IC_CreateMacroContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
CypherParser::IC_PositionalArgsContext* CypherParser::IC_CreateMacroContext::iC_PositionalArgs() {
return getRuleContext<CypherParser::IC_PositionalArgsContext>(0);
}
std::vector<CypherParser::IC_DefaultArgContext *> CypherParser::IC_CreateMacroContext::iC_DefaultArg() {
return getRuleContexts<CypherParser::IC_DefaultArgContext>();
}
CypherParser::IC_DefaultArgContext* CypherParser::IC_CreateMacroContext::iC_DefaultArg(size_t i) {
return getRuleContext<CypherParser::IC_DefaultArgContext>(i);
}
size_t CypherParser::IC_CreateMacroContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateMacro;
}
CypherParser::IC_CreateMacroContext* CypherParser::iC_CreateMacro() {
IC_CreateMacroContext *_localctx = _tracker.createInstance<IC_CreateMacroContext>(_ctx, getState());
enterRule(_localctx, 38, CypherParser::RuleIC_CreateMacro);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(701);
match(CypherParser::CREATE);
setState(702);
match(CypherParser::SP);
setState(703);
match(CypherParser::MACRO);
setState(704);
match(CypherParser::SP);
setState(705);
oC_FunctionName();
setState(707);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(706);
match(CypherParser::SP);
}
setState(709);
match(CypherParser::T__1);
setState(711);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
case 1: {
setState(710);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(714);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx)) {
case 1: {
setState(713);
iC_PositionalArgs();
break;
}
default:
break;
}
setState(717);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
case 1: {
setState(716);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(720);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -287985230644762313) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5068755015275819) != 0)) {
setState(719);
iC_DefaultArg();
}
setState(732);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(723);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(722);
match(CypherParser::SP);
}
setState(725);
match(CypherParser::T__3);
setState(727);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(726);
match(CypherParser::SP);
}
setState(729);
iC_DefaultArg();
}
setState(734);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx);
}
setState(736);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(735);
match(CypherParser::SP);
}
setState(738);
match(CypherParser::T__2);
setState(739);
match(CypherParser::SP);
setState(740);
match(CypherParser::AS);
setState(741);
match(CypherParser::SP);
setState(742);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_PositionalArgsContext::IC_PositionalArgsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_SymbolicNameContext *> CypherParser::IC_PositionalArgsContext::oC_SymbolicName() {
return getRuleContexts<CypherParser::OC_SymbolicNameContext>();
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_PositionalArgsContext::oC_SymbolicName(size_t i) {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_PositionalArgsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_PositionalArgsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_PositionalArgsContext::getRuleIndex() const {
return CypherParser::RuleIC_PositionalArgs;
}
CypherParser::IC_PositionalArgsContext* CypherParser::iC_PositionalArgs() {
IC_PositionalArgsContext *_localctx = _tracker.createInstance<IC_PositionalArgsContext>(_ctx, getState());
enterRule(_localctx, 40, CypherParser::RuleIC_PositionalArgs);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(744);
oC_SymbolicName();
setState(755);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(746);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(745);
match(CypherParser::SP);
}
setState(748);
match(CypherParser::T__3);
setState(750);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(749);
match(CypherParser::SP);
}
setState(752);
oC_SymbolicName();
}
setState(757);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DefaultArgContext::IC_DefaultArgContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_DefaultArgContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_DefaultArgContext::COLON() {
return getToken(CypherParser::COLON, 0);
}
CypherParser::OC_LiteralContext* CypherParser::IC_DefaultArgContext::oC_Literal() {
return getRuleContext<CypherParser::OC_LiteralContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_DefaultArgContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_DefaultArgContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_DefaultArgContext::getRuleIndex() const {
return CypherParser::RuleIC_DefaultArg;
}
CypherParser::IC_DefaultArgContext* CypherParser::iC_DefaultArg() {
IC_DefaultArgContext *_localctx = _tracker.createInstance<IC_DefaultArgContext>(_ctx, getState());
enterRule(_localctx, 42, CypherParser::RuleIC_DefaultArg);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(758);
oC_SymbolicName();
setState(760);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(759);
match(CypherParser::SP);
}
setState(762);
match(CypherParser::COLON);
setState(763);
match(CypherParser::T__5);
setState(765);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(764);
match(CypherParser::SP);
}
setState(767);
oC_Literal();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_FilePathsContext::IC_FilePathsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::IC_FilePathsContext::StringLiteral() {
return getTokens(CypherParser::StringLiteral);
}
tree::TerminalNode* CypherParser::IC_FilePathsContext::StringLiteral(size_t i) {
return getToken(CypherParser::StringLiteral, i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_FilePathsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_FilePathsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_FilePathsContext::GLOB() {
return getToken(CypherParser::GLOB, 0);
}
size_t CypherParser::IC_FilePathsContext::getRuleIndex() const {
return CypherParser::RuleIC_FilePaths;
}
CypherParser::IC_FilePathsContext* CypherParser::iC_FilePaths() {
IC_FilePathsContext *_localctx = _tracker.createInstance<IC_FilePathsContext>(_ctx, getState());
enterRule(_localctx, 44, CypherParser::RuleIC_FilePaths);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(802);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::T__6: {
enterOuterAlt(_localctx, 1);
setState(769);
match(CypherParser::T__6);
setState(771);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(770);
match(CypherParser::SP);
}
setState(773);
match(CypherParser::StringLiteral);
setState(784);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3 || _la == CypherParser::SP) {
setState(775);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(774);
match(CypherParser::SP);
}
setState(777);
match(CypherParser::T__3);
setState(779);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(778);
match(CypherParser::SP);
}
setState(781);
match(CypherParser::StringLiteral);
setState(786);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(787);
match(CypherParser::T__7);
break;
}
case CypherParser::StringLiteral: {
enterOuterAlt(_localctx, 2);
setState(788);
match(CypherParser::StringLiteral);
break;
}
case CypherParser::GLOB: {
enterOuterAlt(_localctx, 3);
setState(789);
match(CypherParser::GLOB);
setState(791);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(790);
match(CypherParser::SP);
}
setState(793);
match(CypherParser::T__1);
setState(795);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(794);
match(CypherParser::SP);
}
setState(797);
match(CypherParser::StringLiteral);
setState(799);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(798);
match(CypherParser::SP);
}
setState(801);
match(CypherParser::T__2);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_IfNotExistsContext::IC_IfNotExistsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_IfNotExistsContext::IF() {
return getToken(CypherParser::IF, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_IfNotExistsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_IfNotExistsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_IfNotExistsContext::NOT() {
return getToken(CypherParser::NOT, 0);
}
tree::TerminalNode* CypherParser::IC_IfNotExistsContext::EXISTS() {
return getToken(CypherParser::EXISTS, 0);
}
size_t CypherParser::IC_IfNotExistsContext::getRuleIndex() const {
return CypherParser::RuleIC_IfNotExists;
}
CypherParser::IC_IfNotExistsContext* CypherParser::iC_IfNotExists() {
IC_IfNotExistsContext *_localctx = _tracker.createInstance<IC_IfNotExistsContext>(_ctx, getState());
enterRule(_localctx, 46, CypherParser::RuleIC_IfNotExists);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(804);
match(CypherParser::IF);
setState(805);
match(CypherParser::SP);
setState(806);
match(CypherParser::NOT);
setState(807);
match(CypherParser::SP);
setState(808);
match(CypherParser::EXISTS);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateNodeTableContext::IC_CreateNodeTableContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateNodeTableContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateNodeTableContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateNodeTableContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateNodeTableContext::NODE() {
return getToken(CypherParser::NODE, 0);
}
tree::TerminalNode* CypherParser::IC_CreateNodeTableContext::TABLE() {
return getToken(CypherParser::TABLE, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CreateNodeTableContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
CypherParser::IC_PropertyDefinitionsContext* CypherParser::IC_CreateNodeTableContext::iC_PropertyDefinitions() {
return getRuleContext<CypherParser::IC_PropertyDefinitionsContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateNodeTableContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::OC_QueryContext* CypherParser::IC_CreateNodeTableContext::oC_Query() {
return getRuleContext<CypherParser::OC_QueryContext>(0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateNodeTableContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateNodeTableContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_CreateNodeTableContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
CypherParser::IC_CreateNodeConstraintContext* CypherParser::IC_CreateNodeTableContext::iC_CreateNodeConstraint() {
return getRuleContext<CypherParser::IC_CreateNodeConstraintContext>(0);
}
size_t CypherParser::IC_CreateNodeTableContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateNodeTable;
}
CypherParser::IC_CreateNodeTableContext* CypherParser::iC_CreateNodeTable() {
IC_CreateNodeTableContext *_localctx = _tracker.createInstance<IC_CreateNodeTableContext>(_ctx, getState());
enterRule(_localctx, 48, CypherParser::RuleIC_CreateNodeTable);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(810);
match(CypherParser::CREATE);
setState(811);
match(CypherParser::SP);
setState(812);
match(CypherParser::NODE);
setState(813);
match(CypherParser::SP);
setState(814);
match(CypherParser::TABLE);
setState(815);
match(CypherParser::SP);
setState(819);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
case 1: {
setState(816);
iC_IfNotExists();
setState(817);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(821);
oC_SchemaName();
setState(849);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
case 1: {
setState(823);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(822);
match(CypherParser::SP);
}
setState(825);
match(CypherParser::T__1);
setState(827);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(826);
match(CypherParser::SP);
}
setState(829);
iC_PropertyDefinitions();
setState(831);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
case 1: {
setState(830);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(838);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__3) {
setState(833);
match(CypherParser::T__3);
setState(835);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(834);
match(CypherParser::SP);
}
setState(837);
iC_CreateNodeConstraint();
}
setState(841);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(840);
match(CypherParser::SP);
}
setState(843);
match(CypherParser::T__2);
break;
}
case 2: {
setState(845);
match(CypherParser::SP);
setState(846);
match(CypherParser::AS);
setState(847);
match(CypherParser::SP);
setState(848);
oC_Query();
break;
}
default:
break;
}
setState(866);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
case 1: {
setState(851);
match(CypherParser::SP);
setState(852);
match(CypherParser::WITH);
setState(854);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(853);
match(CypherParser::SP);
}
setState(856);
match(CypherParser::T__1);
setState(858);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(857);
match(CypherParser::SP);
}
setState(860);
iC_Options();
setState(862);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(861);
match(CypherParser::SP);
}
setState(864);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateRelTableContext::IC_CreateRelTableContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateRelTableContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::REL() {
return getToken(CypherParser::REL, 0);
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::TABLE() {
return getToken(CypherParser::TABLE, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CreateRelTableContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
CypherParser::IC_FromToConnectionsContext* CypherParser::IC_CreateRelTableContext::iC_FromToConnections() {
return getRuleContext<CypherParser::IC_FromToConnectionsContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::OC_QueryContext* CypherParser::IC_CreateRelTableContext::oC_Query() {
return getRuleContext<CypherParser::OC_QueryContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::GROUP() {
return getToken(CypherParser::GROUP, 0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateRelTableContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateRelTableContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_CreateRelTableContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
CypherParser::IC_PropertyDefinitionsContext* CypherParser::IC_CreateRelTableContext::iC_PropertyDefinitions() {
return getRuleContext<CypherParser::IC_PropertyDefinitionsContext>(0);
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_CreateRelTableContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
size_t CypherParser::IC_CreateRelTableContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateRelTable;
}
CypherParser::IC_CreateRelTableContext* CypherParser::iC_CreateRelTable() {
IC_CreateRelTableContext *_localctx = _tracker.createInstance<IC_CreateRelTableContext>(_ctx, getState());
enterRule(_localctx, 50, CypherParser::RuleIC_CreateRelTable);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(868);
match(CypherParser::CREATE);
setState(869);
match(CypherParser::SP);
setState(870);
match(CypherParser::REL);
setState(871);
match(CypherParser::SP);
setState(872);
match(CypherParser::TABLE);
setState(875);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
case 1: {
setState(873);
match(CypherParser::SP);
setState(874);
match(CypherParser::GROUP);
break;
}
default:
break;
}
setState(879);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
case 1: {
setState(877);
match(CypherParser::SP);
setState(878);
iC_IfNotExists();
break;
}
default:
break;
}
setState(881);
match(CypherParser::SP);
setState(882);
oC_SchemaName();
setState(884);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(883);
match(CypherParser::SP);
}
setState(886);
match(CypherParser::T__1);
setState(888);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(887);
match(CypherParser::SP);
}
setState(890);
iC_FromToConnections();
setState(892);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(891);
match(CypherParser::SP);
}
setState(920);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx)) {
case 1: {
setState(902);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 98, _ctx)) {
case 1: {
setState(894);
match(CypherParser::T__3);
setState(896);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(895);
match(CypherParser::SP);
}
setState(898);
iC_PropertyDefinitions();
setState(900);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(899);
match(CypherParser::SP);
}
break;
}
default:
break;
}
setState(912);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__3) {
setState(904);
match(CypherParser::T__3);
setState(906);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(905);
match(CypherParser::SP);
}
setState(908);
oC_SymbolicName();
setState(910);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(909);
match(CypherParser::SP);
}
}
setState(914);
match(CypherParser::T__2);
break;
}
case 2: {
setState(915);
match(CypherParser::T__2);
setState(916);
match(CypherParser::SP);
setState(917);
match(CypherParser::AS);
setState(918);
match(CypherParser::SP);
setState(919);
oC_Query();
break;
}
default:
break;
}
setState(937);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx)) {
case 1: {
setState(922);
match(CypherParser::SP);
setState(923);
match(CypherParser::WITH);
setState(925);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(924);
match(CypherParser::SP);
}
setState(927);
match(CypherParser::T__1);
setState(929);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(928);
match(CypherParser::SP);
}
setState(931);
iC_Options();
setState(933);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(932);
match(CypherParser::SP);
}
setState(935);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_FromToConnectionsContext::IC_FromToConnectionsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_FromToConnectionContext *> CypherParser::IC_FromToConnectionsContext::iC_FromToConnection() {
return getRuleContexts<CypherParser::IC_FromToConnectionContext>();
}
CypherParser::IC_FromToConnectionContext* CypherParser::IC_FromToConnectionsContext::iC_FromToConnection(size_t i) {
return getRuleContext<CypherParser::IC_FromToConnectionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_FromToConnectionsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_FromToConnectionsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_FromToConnectionsContext::getRuleIndex() const {
return CypherParser::RuleIC_FromToConnections;
}
CypherParser::IC_FromToConnectionsContext* CypherParser::iC_FromToConnections() {
IC_FromToConnectionsContext *_localctx = _tracker.createInstance<IC_FromToConnectionsContext>(_ctx, getState());
enterRule(_localctx, 52, CypherParser::RuleIC_FromToConnections);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(939);
iC_FromToConnection();
setState(950);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(941);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(940);
match(CypherParser::SP);
}
setState(943);
match(CypherParser::T__3);
setState(945);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(944);
match(CypherParser::SP);
}
setState(947);
iC_FromToConnection();
}
setState(952);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_FromToConnectionContext::IC_FromToConnectionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_FromToConnectionContext::FROM() {
return getToken(CypherParser::FROM, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_FromToConnectionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_FromToConnectionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_SchemaNameContext *> CypherParser::IC_FromToConnectionContext::oC_SchemaName() {
return getRuleContexts<CypherParser::OC_SchemaNameContext>();
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_FromToConnectionContext::oC_SchemaName(size_t i) {
return getRuleContext<CypherParser::OC_SchemaNameContext>(i);
}
tree::TerminalNode* CypherParser::IC_FromToConnectionContext::TO() {
return getToken(CypherParser::TO, 0);
}
size_t CypherParser::IC_FromToConnectionContext::getRuleIndex() const {
return CypherParser::RuleIC_FromToConnection;
}
CypherParser::IC_FromToConnectionContext* CypherParser::iC_FromToConnection() {
IC_FromToConnectionContext *_localctx = _tracker.createInstance<IC_FromToConnectionContext>(_ctx, getState());
enterRule(_localctx, 54, CypherParser::RuleIC_FromToConnection);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(953);
match(CypherParser::FROM);
setState(954);
match(CypherParser::SP);
setState(955);
oC_SchemaName();
setState(956);
match(CypherParser::SP);
setState(957);
match(CypherParser::TO);
setState(958);
match(CypherParser::SP);
setState(959);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateSequenceContext::IC_CreateSequenceContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateSequenceContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateSequenceContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateSequenceContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateSequenceContext::SEQUENCE() {
return getToken(CypherParser::SEQUENCE, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CreateSequenceContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateSequenceContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
std::vector<CypherParser::IC_SequenceOptionsContext *> CypherParser::IC_CreateSequenceContext::iC_SequenceOptions() {
return getRuleContexts<CypherParser::IC_SequenceOptionsContext>();
}
CypherParser::IC_SequenceOptionsContext* CypherParser::IC_CreateSequenceContext::iC_SequenceOptions(size_t i) {
return getRuleContext<CypherParser::IC_SequenceOptionsContext>(i);
}
size_t CypherParser::IC_CreateSequenceContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateSequence;
}
CypherParser::IC_CreateSequenceContext* CypherParser::iC_CreateSequence() {
IC_CreateSequenceContext *_localctx = _tracker.createInstance<IC_CreateSequenceContext>(_ctx, getState());
enterRule(_localctx, 56, CypherParser::RuleIC_CreateSequence);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(961);
match(CypherParser::CREATE);
setState(962);
match(CypherParser::SP);
setState(963);
match(CypherParser::SEQUENCE);
setState(964);
match(CypherParser::SP);
setState(968);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
case 1: {
setState(965);
iC_IfNotExists();
setState(966);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(970);
oC_SchemaName();
setState(975);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(971);
match(CypherParser::SP);
setState(972);
iC_SequenceOptions();
}
setState(977);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateTypeContext::IC_CreateTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateTypeContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateTypeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateTypeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateTypeContext::TYPE() {
return getToken(CypherParser::TYPE, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_CreateTypeContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_CreateTypeContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::IC_DataTypeContext* CypherParser::IC_CreateTypeContext::iC_DataType() {
return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}
size_t CypherParser::IC_CreateTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateType;
}
CypherParser::IC_CreateTypeContext* CypherParser::iC_CreateType() {
IC_CreateTypeContext *_localctx = _tracker.createInstance<IC_CreateTypeContext>(_ctx, getState());
enterRule(_localctx, 58, CypherParser::RuleIC_CreateType);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(978);
match(CypherParser::CREATE);
setState(979);
match(CypherParser::SP);
setState(980);
match(CypherParser::TYPE);
setState(981);
match(CypherParser::SP);
setState(982);
oC_SchemaName();
setState(983);
match(CypherParser::SP);
setState(984);
match(CypherParser::AS);
setState(985);
match(CypherParser::SP);
setState(986);
iC_DataType(0);
setState(988);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx)) {
case 1: {
setState(987);
match(CypherParser::SP);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_SequenceOptionsContext::IC_SequenceOptionsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::IC_IncrementByContext* CypherParser::IC_SequenceOptionsContext::iC_IncrementBy() {
return getRuleContext<CypherParser::IC_IncrementByContext>(0);
}
CypherParser::IC_MinValueContext* CypherParser::IC_SequenceOptionsContext::iC_MinValue() {
return getRuleContext<CypherParser::IC_MinValueContext>(0);
}
CypherParser::IC_MaxValueContext* CypherParser::IC_SequenceOptionsContext::iC_MaxValue() {
return getRuleContext<CypherParser::IC_MaxValueContext>(0);
}
CypherParser::IC_StartWithContext* CypherParser::IC_SequenceOptionsContext::iC_StartWith() {
return getRuleContext<CypherParser::IC_StartWithContext>(0);
}
CypherParser::IC_CycleContext* CypherParser::IC_SequenceOptionsContext::iC_Cycle() {
return getRuleContext<CypherParser::IC_CycleContext>(0);
}
size_t CypherParser::IC_SequenceOptionsContext::getRuleIndex() const {
return CypherParser::RuleIC_SequenceOptions;
}
CypherParser::IC_SequenceOptionsContext* CypherParser::iC_SequenceOptions() {
IC_SequenceOptionsContext *_localctx = _tracker.createInstance<IC_SequenceOptionsContext>(_ctx, getState());
enterRule(_localctx, 60, CypherParser::RuleIC_SequenceOptions);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(995);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(990);
iC_IncrementBy();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(991);
iC_MinValue();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(992);
iC_MaxValue();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(993);
iC_StartWith();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(994);
iC_Cycle();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_WithPasswdContext::IC_WithPasswdContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::IC_WithPasswdContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_WithPasswdContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_WithPasswdContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
tree::TerminalNode* CypherParser::IC_WithPasswdContext::PASSWORD() {
return getToken(CypherParser::PASSWORD, 0);
}
tree::TerminalNode* CypherParser::IC_WithPasswdContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
size_t CypherParser::IC_WithPasswdContext::getRuleIndex() const {
return CypherParser::RuleIC_WithPasswd;
}
CypherParser::IC_WithPasswdContext* CypherParser::iC_WithPasswd() {
IC_WithPasswdContext *_localctx = _tracker.createInstance<IC_WithPasswdContext>(_ctx, getState());
enterRule(_localctx, 62, CypherParser::RuleIC_WithPasswd);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(997);
match(CypherParser::SP);
setState(998);
match(CypherParser::WITH);
setState(999);
match(CypherParser::SP);
setState(1000);
match(CypherParser::PASSWORD);
setState(1001);
match(CypherParser::SP);
setState(1002);
match(CypherParser::StringLiteral);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateUserContext::IC_CreateUserContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateUserContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateUserContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateUserContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateUserContext::USER() {
return getToken(CypherParser::USER, 0);
}
CypherParser::OC_VariableContext* CypherParser::IC_CreateUserContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateUserContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
CypherParser::IC_WithPasswdContext* CypherParser::IC_CreateUserContext::iC_WithPasswd() {
return getRuleContext<CypherParser::IC_WithPasswdContext>(0);
}
size_t CypherParser::IC_CreateUserContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateUser;
}
CypherParser::IC_CreateUserContext* CypherParser::iC_CreateUser() {
IC_CreateUserContext *_localctx = _tracker.createInstance<IC_CreateUserContext>(_ctx, getState());
enterRule(_localctx, 64, CypherParser::RuleIC_CreateUser);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1004);
match(CypherParser::CREATE);
setState(1005);
match(CypherParser::SP);
setState(1006);
match(CypherParser::USER);
setState(1007);
match(CypherParser::SP);
setState(1011);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
case 1: {
setState(1008);
iC_IfNotExists();
setState(1009);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1013);
oC_Variable();
setState(1015);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx)) {
case 1: {
setState(1014);
iC_WithPasswd();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateRoleContext::IC_CreateRoleContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateRoleContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateRoleContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateRoleContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateRoleContext::ROLE() {
return getToken(CypherParser::ROLE, 0);
}
CypherParser::OC_VariableContext* CypherParser::IC_CreateRoleContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateRoleContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
size_t CypherParser::IC_CreateRoleContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateRole;
}
CypherParser::IC_CreateRoleContext* CypherParser::iC_CreateRole() {
IC_CreateRoleContext *_localctx = _tracker.createInstance<IC_CreateRoleContext>(_ctx, getState());
enterRule(_localctx, 66, CypherParser::RuleIC_CreateRole);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1017);
match(CypherParser::CREATE);
setState(1018);
match(CypherParser::SP);
setState(1019);
match(CypherParser::ROLE);
setState(1020);
match(CypherParser::SP);
setState(1024);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx)) {
case 1: {
setState(1021);
iC_IfNotExists();
setState(1022);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1026);
oC_Variable();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_IncrementByContext::IC_IncrementByContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_IncrementByContext::INCREMENT() {
return getToken(CypherParser::INCREMENT, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_IncrementByContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_IncrementByContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_IntegerLiteralContext* CypherParser::IC_IncrementByContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
tree::TerminalNode* CypherParser::IC_IncrementByContext::BY() {
return getToken(CypherParser::BY, 0);
}
tree::TerminalNode* CypherParser::IC_IncrementByContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
size_t CypherParser::IC_IncrementByContext::getRuleIndex() const {
return CypherParser::RuleIC_IncrementBy;
}
CypherParser::IC_IncrementByContext* CypherParser::iC_IncrementBy() {
IC_IncrementByContext *_localctx = _tracker.createInstance<IC_IncrementByContext>(_ctx, getState());
enterRule(_localctx, 68, CypherParser::RuleIC_IncrementBy);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1028);
match(CypherParser::INCREMENT);
setState(1029);
match(CypherParser::SP);
setState(1032);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::BY) {
setState(1030);
match(CypherParser::BY);
setState(1031);
match(CypherParser::SP);
}
setState(1035);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::MINUS) {
setState(1034);
match(CypherParser::MINUS);
}
setState(1037);
oC_IntegerLiteral();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_MinValueContext::IC_MinValueContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_MinValueContext::NO() {
return getToken(CypherParser::NO, 0);
}
tree::TerminalNode* CypherParser::IC_MinValueContext::SP() {
return getToken(CypherParser::SP, 0);
}
tree::TerminalNode* CypherParser::IC_MinValueContext::MINVALUE() {
return getToken(CypherParser::MINVALUE, 0);
}
CypherParser::OC_IntegerLiteralContext* CypherParser::IC_MinValueContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
tree::TerminalNode* CypherParser::IC_MinValueContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
size_t CypherParser::IC_MinValueContext::getRuleIndex() const {
return CypherParser::RuleIC_MinValue;
}
CypherParser::IC_MinValueContext* CypherParser::iC_MinValue() {
IC_MinValueContext *_localctx = _tracker.createInstance<IC_MinValueContext>(_ctx, getState());
enterRule(_localctx, 70, CypherParser::RuleIC_MinValue);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1048);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::NO: {
enterOuterAlt(_localctx, 1);
setState(1039);
match(CypherParser::NO);
setState(1040);
match(CypherParser::SP);
setState(1041);
match(CypherParser::MINVALUE);
break;
}
case CypherParser::MINVALUE: {
enterOuterAlt(_localctx, 2);
setState(1042);
match(CypherParser::MINVALUE);
setState(1043);
match(CypherParser::SP);
setState(1045);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::MINUS) {
setState(1044);
match(CypherParser::MINUS);
}
setState(1047);
oC_IntegerLiteral();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_MaxValueContext::IC_MaxValueContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_MaxValueContext::NO() {
return getToken(CypherParser::NO, 0);
}
tree::TerminalNode* CypherParser::IC_MaxValueContext::SP() {
return getToken(CypherParser::SP, 0);
}
tree::TerminalNode* CypherParser::IC_MaxValueContext::MAXVALUE() {
return getToken(CypherParser::MAXVALUE, 0);
}
CypherParser::OC_IntegerLiteralContext* CypherParser::IC_MaxValueContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
tree::TerminalNode* CypherParser::IC_MaxValueContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
size_t CypherParser::IC_MaxValueContext::getRuleIndex() const {
return CypherParser::RuleIC_MaxValue;
}
CypherParser::IC_MaxValueContext* CypherParser::iC_MaxValue() {
IC_MaxValueContext *_localctx = _tracker.createInstance<IC_MaxValueContext>(_ctx, getState());
enterRule(_localctx, 72, CypherParser::RuleIC_MaxValue);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1059);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::NO: {
enterOuterAlt(_localctx, 1);
setState(1050);
match(CypherParser::NO);
setState(1051);
match(CypherParser::SP);
setState(1052);
match(CypherParser::MAXVALUE);
break;
}
case CypherParser::MAXVALUE: {
enterOuterAlt(_localctx, 2);
setState(1053);
match(CypherParser::MAXVALUE);
setState(1054);
match(CypherParser::SP);
setState(1056);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::MINUS) {
setState(1055);
match(CypherParser::MINUS);
}
setState(1058);
oC_IntegerLiteral();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_StartWithContext::IC_StartWithContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_StartWithContext::START() {
return getToken(CypherParser::START, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_StartWithContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_StartWithContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_IntegerLiteralContext* CypherParser::IC_StartWithContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
tree::TerminalNode* CypherParser::IC_StartWithContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
tree::TerminalNode* CypherParser::IC_StartWithContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
size_t CypherParser::IC_StartWithContext::getRuleIndex() const {
return CypherParser::RuleIC_StartWith;
}
CypherParser::IC_StartWithContext* CypherParser::iC_StartWith() {
IC_StartWithContext *_localctx = _tracker.createInstance<IC_StartWithContext>(_ctx, getState());
enterRule(_localctx, 74, CypherParser::RuleIC_StartWith);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1061);
match(CypherParser::START);
setState(1062);
match(CypherParser::SP);
setState(1065);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::WITH) {
setState(1063);
match(CypherParser::WITH);
setState(1064);
match(CypherParser::SP);
}
setState(1068);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::MINUS) {
setState(1067);
match(CypherParser::MINUS);
}
setState(1070);
oC_IntegerLiteral();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CycleContext::IC_CycleContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CycleContext::CYCLE() {
return getToken(CypherParser::CYCLE, 0);
}
tree::TerminalNode* CypherParser::IC_CycleContext::NO() {
return getToken(CypherParser::NO, 0);
}
tree::TerminalNode* CypherParser::IC_CycleContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::IC_CycleContext::getRuleIndex() const {
return CypherParser::RuleIC_Cycle;
}
CypherParser::IC_CycleContext* CypherParser::iC_Cycle() {
IC_CycleContext *_localctx = _tracker.createInstance<IC_CycleContext>(_ctx, getState());
enterRule(_localctx, 76, CypherParser::RuleIC_Cycle);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1074);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::NO) {
setState(1072);
match(CypherParser::NO);
setState(1073);
match(CypherParser::SP);
}
setState(1076);
match(CypherParser::CYCLE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_IfExistsContext::IC_IfExistsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_IfExistsContext::IF() {
return getToken(CypherParser::IF, 0);
}
tree::TerminalNode* CypherParser::IC_IfExistsContext::SP() {
return getToken(CypherParser::SP, 0);
}
tree::TerminalNode* CypherParser::IC_IfExistsContext::EXISTS() {
return getToken(CypherParser::EXISTS, 0);
}
size_t CypherParser::IC_IfExistsContext::getRuleIndex() const {
return CypherParser::RuleIC_IfExists;
}
CypherParser::IC_IfExistsContext* CypherParser::iC_IfExists() {
IC_IfExistsContext *_localctx = _tracker.createInstance<IC_IfExistsContext>(_ctx, getState());
enterRule(_localctx, 78, CypherParser::RuleIC_IfExists);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1078);
match(CypherParser::IF);
setState(1079);
match(CypherParser::SP);
setState(1080);
match(CypherParser::EXISTS);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DropContext::IC_DropContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_DropContext::DROP() {
return getToken(CypherParser::DROP, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_DropContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_DropContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_DropContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_DropContext::TABLE() {
return getToken(CypherParser::TABLE, 0);
}
tree::TerminalNode* CypherParser::IC_DropContext::SEQUENCE() {
return getToken(CypherParser::SEQUENCE, 0);
}
tree::TerminalNode* CypherParser::IC_DropContext::MACRO() {
return getToken(CypherParser::MACRO, 0);
}
tree::TerminalNode* CypherParser::IC_DropContext::GRAPH() {
return getToken(CypherParser::GRAPH, 0);
}
CypherParser::IC_IfExistsContext* CypherParser::IC_DropContext::iC_IfExists() {
return getRuleContext<CypherParser::IC_IfExistsContext>(0);
}
size_t CypherParser::IC_DropContext::getRuleIndex() const {
return CypherParser::RuleIC_Drop;
}
CypherParser::IC_DropContext* CypherParser::iC_Drop() {
IC_DropContext *_localctx = _tracker.createInstance<IC_DropContext>(_ctx, getState());
enterRule(_localctx, 80, CypherParser::RuleIC_Drop);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1082);
match(CypherParser::DROP);
setState(1083);
match(CypherParser::SP);
setState(1084);
_la = _input->LA(1);
if (!(((((_la - 90) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 90)) & 71468255838209) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(1085);
match(CypherParser::SP);
setState(1089);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 126, _ctx)) {
case 1: {
setState(1086);
iC_IfExists();
setState(1087);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1091);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_AlterTableContext::IC_AlterTableContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_AlterTableContext::ALTER() {
return getToken(CypherParser::ALTER, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_AlterTableContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_AlterTableContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_AlterTableContext::TABLE() {
return getToken(CypherParser::TABLE, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_AlterTableContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
CypherParser::IC_AlterOptionsContext* CypherParser::IC_AlterTableContext::iC_AlterOptions() {
return getRuleContext<CypherParser::IC_AlterOptionsContext>(0);
}
size_t CypherParser::IC_AlterTableContext::getRuleIndex() const {
return CypherParser::RuleIC_AlterTable;
}
CypherParser::IC_AlterTableContext* CypherParser::iC_AlterTable() {
IC_AlterTableContext *_localctx = _tracker.createInstance<IC_AlterTableContext>(_ctx, getState());
enterRule(_localctx, 82, CypherParser::RuleIC_AlterTable);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1093);
match(CypherParser::ALTER);
setState(1094);
match(CypherParser::SP);
setState(1095);
match(CypherParser::TABLE);
setState(1096);
match(CypherParser::SP);
setState(1097);
oC_SchemaName();
setState(1098);
match(CypherParser::SP);
setState(1099);
iC_AlterOptions();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_AlterOptionsContext::IC_AlterOptionsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::IC_AddPropertyContext* CypherParser::IC_AlterOptionsContext::iC_AddProperty() {
return getRuleContext<CypherParser::IC_AddPropertyContext>(0);
}
CypherParser::IC_DropPropertyContext* CypherParser::IC_AlterOptionsContext::iC_DropProperty() {
return getRuleContext<CypherParser::IC_DropPropertyContext>(0);
}
CypherParser::IC_RenameTableContext* CypherParser::IC_AlterOptionsContext::iC_RenameTable() {
return getRuleContext<CypherParser::IC_RenameTableContext>(0);
}
CypherParser::IC_RenamePropertyContext* CypherParser::IC_AlterOptionsContext::iC_RenameProperty() {
return getRuleContext<CypherParser::IC_RenamePropertyContext>(0);
}
CypherParser::IC_AddFromToConnectionContext* CypherParser::IC_AlterOptionsContext::iC_AddFromToConnection() {
return getRuleContext<CypherParser::IC_AddFromToConnectionContext>(0);
}
CypherParser::IC_DropFromToConnectionContext* CypherParser::IC_AlterOptionsContext::iC_DropFromToConnection() {
return getRuleContext<CypherParser::IC_DropFromToConnectionContext>(0);
}
size_t CypherParser::IC_AlterOptionsContext::getRuleIndex() const {
return CypherParser::RuleIC_AlterOptions;
}
CypherParser::IC_AlterOptionsContext* CypherParser::iC_AlterOptions() {
IC_AlterOptionsContext *_localctx = _tracker.createInstance<IC_AlterOptionsContext>(_ctx, getState());
enterRule(_localctx, 84, CypherParser::RuleIC_AlterOptions);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1107);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1101);
iC_AddProperty();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1102);
iC_DropProperty();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(1103);
iC_RenameTable();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(1104);
iC_RenameProperty();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(1105);
iC_AddFromToConnection();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(1106);
iC_DropFromToConnection();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_AddPropertyContext::IC_AddPropertyContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_AddPropertyContext::ADD() {
return getToken(CypherParser::ADD, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_AddPropertyContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_AddPropertyContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_AddPropertyContext::oC_PropertyKeyName() {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}
CypherParser::IC_DataTypeContext* CypherParser::IC_AddPropertyContext::iC_DataType() {
return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_AddPropertyContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
CypherParser::IC_DefaultContext* CypherParser::IC_AddPropertyContext::iC_Default() {
return getRuleContext<CypherParser::IC_DefaultContext>(0);
}
size_t CypherParser::IC_AddPropertyContext::getRuleIndex() const {
return CypherParser::RuleIC_AddProperty;
}
CypherParser::IC_AddPropertyContext* CypherParser::iC_AddProperty() {
IC_AddPropertyContext *_localctx = _tracker.createInstance<IC_AddPropertyContext>(_ctx, getState());
enterRule(_localctx, 86, CypherParser::RuleIC_AddProperty);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1109);
match(CypherParser::ADD);
setState(1110);
match(CypherParser::SP);
setState(1114);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx)) {
case 1: {
setState(1111);
iC_IfNotExists();
setState(1112);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1116);
oC_PropertyKeyName();
setState(1117);
match(CypherParser::SP);
setState(1118);
iC_DataType(0);
setState(1121);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
case 1: {
setState(1119);
match(CypherParser::SP);
setState(1120);
iC_Default();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DefaultContext::IC_DefaultContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_DefaultContext::DEFAULT() {
return getToken(CypherParser::DEFAULT, 0);
}
tree::TerminalNode* CypherParser::IC_DefaultContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::IC_DefaultContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
size_t CypherParser::IC_DefaultContext::getRuleIndex() const {
return CypherParser::RuleIC_Default;
}
CypherParser::IC_DefaultContext* CypherParser::iC_Default() {
IC_DefaultContext *_localctx = _tracker.createInstance<IC_DefaultContext>(_ctx, getState());
enterRule(_localctx, 88, CypherParser::RuleIC_Default);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1123);
match(CypherParser::DEFAULT);
setState(1124);
match(CypherParser::SP);
setState(1125);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DropPropertyContext::IC_DropPropertyContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_DropPropertyContext::DROP() {
return getToken(CypherParser::DROP, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_DropPropertyContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_DropPropertyContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_DropPropertyContext::oC_PropertyKeyName() {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}
CypherParser::IC_IfExistsContext* CypherParser::IC_DropPropertyContext::iC_IfExists() {
return getRuleContext<CypherParser::IC_IfExistsContext>(0);
}
size_t CypherParser::IC_DropPropertyContext::getRuleIndex() const {
return CypherParser::RuleIC_DropProperty;
}
CypherParser::IC_DropPropertyContext* CypherParser::iC_DropProperty() {
IC_DropPropertyContext *_localctx = _tracker.createInstance<IC_DropPropertyContext>(_ctx, getState());
enterRule(_localctx, 90, CypherParser::RuleIC_DropProperty);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1127);
match(CypherParser::DROP);
setState(1128);
match(CypherParser::SP);
setState(1132);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 130, _ctx)) {
case 1: {
setState(1129);
iC_IfExists();
setState(1130);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1134);
oC_PropertyKeyName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_RenameTableContext::IC_RenameTableContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_RenameTableContext::RENAME() {
return getToken(CypherParser::RENAME, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_RenameTableContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_RenameTableContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_RenameTableContext::TO() {
return getToken(CypherParser::TO, 0);
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_RenameTableContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
size_t CypherParser::IC_RenameTableContext::getRuleIndex() const {
return CypherParser::RuleIC_RenameTable;
}
CypherParser::IC_RenameTableContext* CypherParser::iC_RenameTable() {
IC_RenameTableContext *_localctx = _tracker.createInstance<IC_RenameTableContext>(_ctx, getState());
enterRule(_localctx, 92, CypherParser::RuleIC_RenameTable);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1136);
match(CypherParser::RENAME);
setState(1137);
match(CypherParser::SP);
setState(1138);
match(CypherParser::TO);
setState(1139);
match(CypherParser::SP);
setState(1140);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_RenamePropertyContext::IC_RenamePropertyContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_RenamePropertyContext::RENAME() {
return getToken(CypherParser::RENAME, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_RenamePropertyContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_RenamePropertyContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_PropertyKeyNameContext *> CypherParser::IC_RenamePropertyContext::oC_PropertyKeyName() {
return getRuleContexts<CypherParser::OC_PropertyKeyNameContext>();
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_RenamePropertyContext::oC_PropertyKeyName(size_t i) {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(i);
}
tree::TerminalNode* CypherParser::IC_RenamePropertyContext::TO() {
return getToken(CypherParser::TO, 0);
}
size_t CypherParser::IC_RenamePropertyContext::getRuleIndex() const {
return CypherParser::RuleIC_RenameProperty;
}
CypherParser::IC_RenamePropertyContext* CypherParser::iC_RenameProperty() {
IC_RenamePropertyContext *_localctx = _tracker.createInstance<IC_RenamePropertyContext>(_ctx, getState());
enterRule(_localctx, 94, CypherParser::RuleIC_RenameProperty);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1142);
match(CypherParser::RENAME);
setState(1143);
match(CypherParser::SP);
setState(1144);
oC_PropertyKeyName();
setState(1145);
match(CypherParser::SP);
setState(1146);
match(CypherParser::TO);
setState(1147);
match(CypherParser::SP);
setState(1148);
oC_PropertyKeyName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_AddFromToConnectionContext::IC_AddFromToConnectionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_AddFromToConnectionContext::ADD() {
return getToken(CypherParser::ADD, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_AddFromToConnectionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_AddFromToConnectionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::IC_FromToConnectionContext* CypherParser::IC_AddFromToConnectionContext::iC_FromToConnection() {
return getRuleContext<CypherParser::IC_FromToConnectionContext>(0);
}
CypherParser::IC_IfNotExistsContext* CypherParser::IC_AddFromToConnectionContext::iC_IfNotExists() {
return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}
size_t CypherParser::IC_AddFromToConnectionContext::getRuleIndex() const {
return CypherParser::RuleIC_AddFromToConnection;
}
CypherParser::IC_AddFromToConnectionContext* CypherParser::iC_AddFromToConnection() {
IC_AddFromToConnectionContext *_localctx = _tracker.createInstance<IC_AddFromToConnectionContext>(_ctx, getState());
enterRule(_localctx, 96, CypherParser::RuleIC_AddFromToConnection);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1150);
match(CypherParser::ADD);
setState(1151);
match(CypherParser::SP);
setState(1155);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::IF) {
setState(1152);
iC_IfNotExists();
setState(1153);
match(CypherParser::SP);
}
setState(1157);
iC_FromToConnection();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DropFromToConnectionContext::IC_DropFromToConnectionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_DropFromToConnectionContext::DROP() {
return getToken(CypherParser::DROP, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_DropFromToConnectionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_DropFromToConnectionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::IC_FromToConnectionContext* CypherParser::IC_DropFromToConnectionContext::iC_FromToConnection() {
return getRuleContext<CypherParser::IC_FromToConnectionContext>(0);
}
CypherParser::IC_IfExistsContext* CypherParser::IC_DropFromToConnectionContext::iC_IfExists() {
return getRuleContext<CypherParser::IC_IfExistsContext>(0);
}
size_t CypherParser::IC_DropFromToConnectionContext::getRuleIndex() const {
return CypherParser::RuleIC_DropFromToConnection;
}
CypherParser::IC_DropFromToConnectionContext* CypherParser::iC_DropFromToConnection() {
IC_DropFromToConnectionContext *_localctx = _tracker.createInstance<IC_DropFromToConnectionContext>(_ctx, getState());
enterRule(_localctx, 98, CypherParser::RuleIC_DropFromToConnection);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1159);
match(CypherParser::DROP);
setState(1160);
match(CypherParser::SP);
setState(1164);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::IF) {
setState(1161);
iC_IfExists();
setState(1162);
match(CypherParser::SP);
}
setState(1166);
iC_FromToConnection();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ColumnDefinitionsContext::IC_ColumnDefinitionsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_ColumnDefinitionContext *> CypherParser::IC_ColumnDefinitionsContext::iC_ColumnDefinition() {
return getRuleContexts<CypherParser::IC_ColumnDefinitionContext>();
}
CypherParser::IC_ColumnDefinitionContext* CypherParser::IC_ColumnDefinitionsContext::iC_ColumnDefinition(size_t i) {
return getRuleContext<CypherParser::IC_ColumnDefinitionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_ColumnDefinitionsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_ColumnDefinitionsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_ColumnDefinitionsContext::getRuleIndex() const {
return CypherParser::RuleIC_ColumnDefinitions;
}
CypherParser::IC_ColumnDefinitionsContext* CypherParser::iC_ColumnDefinitions() {
IC_ColumnDefinitionsContext *_localctx = _tracker.createInstance<IC_ColumnDefinitionsContext>(_ctx, getState());
enterRule(_localctx, 100, CypherParser::RuleIC_ColumnDefinitions);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1168);
iC_ColumnDefinition();
setState(1179);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 135, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1170);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1169);
match(CypherParser::SP);
}
setState(1172);
match(CypherParser::T__3);
setState(1174);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1173);
match(CypherParser::SP);
}
setState(1176);
iC_ColumnDefinition();
}
setState(1181);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 135, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ColumnDefinitionContext::IC_ColumnDefinitionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_ColumnDefinitionContext::oC_PropertyKeyName() {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_ColumnDefinitionContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::IC_DataTypeContext* CypherParser::IC_ColumnDefinitionContext::iC_DataType() {
return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}
size_t CypherParser::IC_ColumnDefinitionContext::getRuleIndex() const {
return CypherParser::RuleIC_ColumnDefinition;
}
CypherParser::IC_ColumnDefinitionContext* CypherParser::iC_ColumnDefinition() {
IC_ColumnDefinitionContext *_localctx = _tracker.createInstance<IC_ColumnDefinitionContext>(_ctx, getState());
enterRule(_localctx, 102, CypherParser::RuleIC_ColumnDefinition);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1182);
oC_PropertyKeyName();
setState(1183);
match(CypherParser::SP);
setState(1184);
iC_DataType(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_PropertyDefinitionsContext::IC_PropertyDefinitionsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_PropertyDefinitionContext *> CypherParser::IC_PropertyDefinitionsContext::iC_PropertyDefinition() {
return getRuleContexts<CypherParser::IC_PropertyDefinitionContext>();
}
CypherParser::IC_PropertyDefinitionContext* CypherParser::IC_PropertyDefinitionsContext::iC_PropertyDefinition(size_t i) {
return getRuleContext<CypherParser::IC_PropertyDefinitionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_PropertyDefinitionsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_PropertyDefinitionsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_PropertyDefinitionsContext::getRuleIndex() const {
return CypherParser::RuleIC_PropertyDefinitions;
}
CypherParser::IC_PropertyDefinitionsContext* CypherParser::iC_PropertyDefinitions() {
IC_PropertyDefinitionsContext *_localctx = _tracker.createInstance<IC_PropertyDefinitionsContext>(_ctx, getState());
enterRule(_localctx, 104, CypherParser::RuleIC_PropertyDefinitions);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1186);
iC_PropertyDefinition();
setState(1197);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1188);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1187);
match(CypherParser::SP);
}
setState(1190);
match(CypherParser::T__3);
setState(1192);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1191);
match(CypherParser::SP);
}
setState(1194);
iC_PropertyDefinition();
}
setState(1199);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_PropertyDefinitionContext::IC_PropertyDefinitionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::IC_ColumnDefinitionContext* CypherParser::IC_PropertyDefinitionContext::iC_ColumnDefinition() {
return getRuleContext<CypherParser::IC_ColumnDefinitionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_PropertyDefinitionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_PropertyDefinitionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::IC_DefaultContext* CypherParser::IC_PropertyDefinitionContext::iC_Default() {
return getRuleContext<CypherParser::IC_DefaultContext>(0);
}
tree::TerminalNode* CypherParser::IC_PropertyDefinitionContext::PRIMARY() {
return getToken(CypherParser::PRIMARY, 0);
}
tree::TerminalNode* CypherParser::IC_PropertyDefinitionContext::KEY() {
return getToken(CypherParser::KEY, 0);
}
size_t CypherParser::IC_PropertyDefinitionContext::getRuleIndex() const {
return CypherParser::RuleIC_PropertyDefinition;
}
CypherParser::IC_PropertyDefinitionContext* CypherParser::iC_PropertyDefinition() {
IC_PropertyDefinitionContext *_localctx = _tracker.createInstance<IC_PropertyDefinitionContext>(_ctx, getState());
enterRule(_localctx, 106, CypherParser::RuleIC_PropertyDefinition);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1200);
iC_ColumnDefinition();
setState(1203);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx)) {
case 1: {
setState(1201);
match(CypherParser::SP);
setState(1202);
iC_Default();
break;
}
default:
break;
}
setState(1209);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx)) {
case 1: {
setState(1205);
match(CypherParser::SP);
setState(1206);
match(CypherParser::PRIMARY);
setState(1207);
match(CypherParser::SP);
setState(1208);
match(CypherParser::KEY);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_CreateNodeConstraintContext::IC_CreateNodeConstraintContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_CreateNodeConstraintContext::PRIMARY() {
return getToken(CypherParser::PRIMARY, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_CreateNodeConstraintContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_CreateNodeConstraintContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_CreateNodeConstraintContext::KEY() {
return getToken(CypherParser::KEY, 0);
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_CreateNodeConstraintContext::oC_PropertyKeyName() {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}
size_t CypherParser::IC_CreateNodeConstraintContext::getRuleIndex() const {
return CypherParser::RuleIC_CreateNodeConstraint;
}
CypherParser::IC_CreateNodeConstraintContext* CypherParser::iC_CreateNodeConstraint() {
IC_CreateNodeConstraintContext *_localctx = _tracker.createInstance<IC_CreateNodeConstraintContext>(_ctx, getState());
enterRule(_localctx, 108, CypherParser::RuleIC_CreateNodeConstraint);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1211);
match(CypherParser::PRIMARY);
setState(1212);
match(CypherParser::SP);
setState(1213);
match(CypherParser::KEY);
setState(1215);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1214);
match(CypherParser::SP);
}
setState(1217);
match(CypherParser::T__1);
setState(1219);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1218);
match(CypherParser::SP);
}
setState(1221);
oC_PropertyKeyName();
setState(1223);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1222);
match(CypherParser::SP);
}
setState(1225);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_UnionTypeContext::IC_UnionTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_UnionTypeContext::UNION() {
return getToken(CypherParser::UNION, 0);
}
CypherParser::IC_ColumnDefinitionsContext* CypherParser::IC_UnionTypeContext::iC_ColumnDefinitions() {
return getRuleContext<CypherParser::IC_ColumnDefinitionsContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_UnionTypeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_UnionTypeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_UnionTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_UnionType;
}
CypherParser::IC_UnionTypeContext* CypherParser::iC_UnionType() {
IC_UnionTypeContext *_localctx = _tracker.createInstance<IC_UnionTypeContext>(_ctx, getState());
enterRule(_localctx, 110, CypherParser::RuleIC_UnionType);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1227);
match(CypherParser::UNION);
setState(1229);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1228);
match(CypherParser::SP);
}
setState(1231);
match(CypherParser::T__1);
setState(1233);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1232);
match(CypherParser::SP);
}
setState(1235);
iC_ColumnDefinitions();
setState(1237);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1236);
match(CypherParser::SP);
}
setState(1239);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_StructTypeContext::IC_StructTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_StructTypeContext::STRUCT() {
return getToken(CypherParser::STRUCT, 0);
}
CypherParser::IC_ColumnDefinitionsContext* CypherParser::IC_StructTypeContext::iC_ColumnDefinitions() {
return getRuleContext<CypherParser::IC_ColumnDefinitionsContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_StructTypeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_StructTypeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_StructTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_StructType;
}
CypherParser::IC_StructTypeContext* CypherParser::iC_StructType() {
IC_StructTypeContext *_localctx = _tracker.createInstance<IC_StructTypeContext>(_ctx, getState());
enterRule(_localctx, 112, CypherParser::RuleIC_StructType);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1241);
match(CypherParser::STRUCT);
setState(1243);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1242);
match(CypherParser::SP);
}
setState(1245);
match(CypherParser::T__1);
setState(1247);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1246);
match(CypherParser::SP);
}
setState(1249);
iC_ColumnDefinitions();
setState(1251);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1250);
match(CypherParser::SP);
}
setState(1253);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_MapTypeContext::IC_MapTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_MapTypeContext::MAP() {
return getToken(CypherParser::MAP, 0);
}
std::vector<CypherParser::IC_DataTypeContext *> CypherParser::IC_MapTypeContext::iC_DataType() {
return getRuleContexts<CypherParser::IC_DataTypeContext>();
}
CypherParser::IC_DataTypeContext* CypherParser::IC_MapTypeContext::iC_DataType(size_t i) {
return getRuleContext<CypherParser::IC_DataTypeContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_MapTypeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_MapTypeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_MapTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_MapType;
}
CypherParser::IC_MapTypeContext* CypherParser::iC_MapType() {
IC_MapTypeContext *_localctx = _tracker.createInstance<IC_MapTypeContext>(_ctx, getState());
enterRule(_localctx, 114, CypherParser::RuleIC_MapType);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1255);
match(CypherParser::MAP);
setState(1257);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1256);
match(CypherParser::SP);
}
setState(1259);
match(CypherParser::T__1);
setState(1261);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1260);
match(CypherParser::SP);
}
setState(1263);
iC_DataType(0);
setState(1265);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1264);
match(CypherParser::SP);
}
setState(1267);
match(CypherParser::T__3);
setState(1269);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1268);
match(CypherParser::SP);
}
setState(1271);
iC_DataType(0);
setState(1273);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1272);
match(CypherParser::SP);
}
setState(1275);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DecimalTypeContext::IC_DecimalTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_DecimalTypeContext::DECIMAL() {
return getToken(CypherParser::DECIMAL, 0);
}
std::vector<CypherParser::OC_IntegerLiteralContext *> CypherParser::IC_DecimalTypeContext::oC_IntegerLiteral() {
return getRuleContexts<CypherParser::OC_IntegerLiteralContext>();
}
CypherParser::OC_IntegerLiteralContext* CypherParser::IC_DecimalTypeContext::oC_IntegerLiteral(size_t i) {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_DecimalTypeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_DecimalTypeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_DecimalTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_DecimalType;
}
CypherParser::IC_DecimalTypeContext* CypherParser::iC_DecimalType() {
IC_DecimalTypeContext *_localctx = _tracker.createInstance<IC_DecimalTypeContext>(_ctx, getState());
enterRule(_localctx, 116, CypherParser::RuleIC_DecimalType);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1277);
match(CypherParser::DECIMAL);
setState(1279);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1278);
match(CypherParser::SP);
}
setState(1281);
match(CypherParser::T__1);
setState(1283);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1282);
match(CypherParser::SP);
}
setState(1285);
oC_IntegerLiteral();
setState(1287);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1286);
match(CypherParser::SP);
}
setState(1289);
match(CypherParser::T__3);
setState(1291);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1290);
match(CypherParser::SP);
}
setState(1293);
oC_IntegerLiteral();
setState(1295);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1294);
match(CypherParser::SP);
}
setState(1297);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_DataTypeContext::IC_DataTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_DataTypeContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
CypherParser::IC_UnionTypeContext* CypherParser::IC_DataTypeContext::iC_UnionType() {
return getRuleContext<CypherParser::IC_UnionTypeContext>(0);
}
CypherParser::IC_StructTypeContext* CypherParser::IC_DataTypeContext::iC_StructType() {
return getRuleContext<CypherParser::IC_StructTypeContext>(0);
}
CypherParser::IC_MapTypeContext* CypherParser::IC_DataTypeContext::iC_MapType() {
return getRuleContext<CypherParser::IC_MapTypeContext>(0);
}
CypherParser::IC_DecimalTypeContext* CypherParser::IC_DataTypeContext::iC_DecimalType() {
return getRuleContext<CypherParser::IC_DecimalTypeContext>(0);
}
CypherParser::IC_DataTypeContext* CypherParser::IC_DataTypeContext::iC_DataType() {
return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}
CypherParser::IC_ListIdentifiersContext* CypherParser::IC_DataTypeContext::iC_ListIdentifiers() {
return getRuleContext<CypherParser::IC_ListIdentifiersContext>(0);
}
size_t CypherParser::IC_DataTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_DataType;
}
CypherParser::IC_DataTypeContext* CypherParser::iC_DataType() {
return iC_DataType(0);
}
CypherParser::IC_DataTypeContext* CypherParser::iC_DataType(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
CypherParser::IC_DataTypeContext *_localctx = _tracker.createInstance<IC_DataTypeContext>(_ctx, parentState);
CypherParser::IC_DataTypeContext *previousContext = _localctx;
(void)previousContext; size_t startState = 118;
enterRecursionRule(_localctx, 118, CypherParser::RuleIC_DataType, precedence);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1305);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx)) {
case 1: {
setState(1300);
oC_SymbolicName();
break;
}
case 2: {
setState(1301);
iC_UnionType();
break;
}
case 3: {
setState(1302);
iC_StructType();
break;
}
case 4: {
setState(1303);
iC_MapType();
break;
}
case 5: {
setState(1304);
iC_DecimalType();
break;
}
default:
break;
}
_ctx->stop = _input->LT(-1);
setState(1311);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 161, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
_localctx = _tracker.createInstance<IC_DataTypeContext>(parentContext, parentState);
pushNewRecursionContext(_localctx, startState, RuleIC_DataType);
setState(1307);
if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1308);
iC_ListIdentifiers();
}
setState(1313);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 161, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ListIdentifiersContext::IC_ListIdentifiersContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_ListIdentifierContext *> CypherParser::IC_ListIdentifiersContext::iC_ListIdentifier() {
return getRuleContexts<CypherParser::IC_ListIdentifierContext>();
}
CypherParser::IC_ListIdentifierContext* CypherParser::IC_ListIdentifiersContext::iC_ListIdentifier(size_t i) {
return getRuleContext<CypherParser::IC_ListIdentifierContext>(i);
}
size_t CypherParser::IC_ListIdentifiersContext::getRuleIndex() const {
return CypherParser::RuleIC_ListIdentifiers;
}
CypherParser::IC_ListIdentifiersContext* CypherParser::iC_ListIdentifiers() {
IC_ListIdentifiersContext *_localctx = _tracker.createInstance<IC_ListIdentifiersContext>(_ctx, getState());
enterRule(_localctx, 120, CypherParser::RuleIC_ListIdentifiers);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1314);
iC_ListIdentifier();
setState(1318);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 162, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1315);
iC_ListIdentifier();
}
setState(1320);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 162, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ListIdentifierContext::IC_ListIdentifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_IntegerLiteralContext* CypherParser::IC_ListIdentifierContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
size_t CypherParser::IC_ListIdentifierContext::getRuleIndex() const {
return CypherParser::RuleIC_ListIdentifier;
}
CypherParser::IC_ListIdentifierContext* CypherParser::iC_ListIdentifier() {
IC_ListIdentifierContext *_localctx = _tracker.createInstance<IC_ListIdentifierContext>(_ctx, getState());
enterRule(_localctx, 122, CypherParser::RuleIC_ListIdentifier);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1321);
match(CypherParser::T__6);
setState(1323);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::DecimalInteger) {
setState(1322);
oC_IntegerLiteral();
}
setState(1325);
match(CypherParser::T__7);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_AnyCypherOptionContext::OC_AnyCypherOptionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ExplainContext* CypherParser::OC_AnyCypherOptionContext::oC_Explain() {
return getRuleContext<CypherParser::OC_ExplainContext>(0);
}
CypherParser::OC_ProfileContext* CypherParser::OC_AnyCypherOptionContext::oC_Profile() {
return getRuleContext<CypherParser::OC_ProfileContext>(0);
}
size_t CypherParser::OC_AnyCypherOptionContext::getRuleIndex() const {
return CypherParser::RuleOC_AnyCypherOption;
}
CypherParser::OC_AnyCypherOptionContext* CypherParser::oC_AnyCypherOption() {
OC_AnyCypherOptionContext *_localctx = _tracker.createInstance<OC_AnyCypherOptionContext>(_ctx, getState());
enterRule(_localctx, 124, CypherParser::RuleOC_AnyCypherOption);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1329);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::EXPLAIN: {
enterOuterAlt(_localctx, 1);
setState(1327);
oC_Explain();
break;
}
case CypherParser::PROFILE: {
enterOuterAlt(_localctx, 2);
setState(1328);
oC_Profile();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ExplainContext::OC_ExplainContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_ExplainContext::EXPLAIN() {
return getToken(CypherParser::EXPLAIN, 0);
}
tree::TerminalNode* CypherParser::OC_ExplainContext::SP() {
return getToken(CypherParser::SP, 0);
}
tree::TerminalNode* CypherParser::OC_ExplainContext::LOGICAL() {
return getToken(CypherParser::LOGICAL, 0);
}
size_t CypherParser::OC_ExplainContext::getRuleIndex() const {
return CypherParser::RuleOC_Explain;
}
CypherParser::OC_ExplainContext* CypherParser::oC_Explain() {
OC_ExplainContext *_localctx = _tracker.createInstance<OC_ExplainContext>(_ctx, getState());
enterRule(_localctx, 126, CypherParser::RuleOC_Explain);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1331);
match(CypherParser::EXPLAIN);
setState(1334);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 165, _ctx)) {
case 1: {
setState(1332);
match(CypherParser::SP);
setState(1333);
match(CypherParser::LOGICAL);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ProfileContext::OC_ProfileContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_ProfileContext::PROFILE() {
return getToken(CypherParser::PROFILE, 0);
}
size_t CypherParser::OC_ProfileContext::getRuleIndex() const {
return CypherParser::RuleOC_Profile;
}
CypherParser::OC_ProfileContext* CypherParser::oC_Profile() {
OC_ProfileContext *_localctx = _tracker.createInstance<OC_ProfileContext>(_ctx, getState());
enterRule(_localctx, 128, CypherParser::RuleOC_Profile);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1336);
match(CypherParser::PROFILE);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_TransactionContext::IC_TransactionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_TransactionContext::BEGIN() {
return getToken(CypherParser::BEGIN, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_TransactionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::TRANSACTION() {
return getToken(CypherParser::TRANSACTION, 0);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::READ() {
return getToken(CypherParser::READ, 0);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::ONLY() {
return getToken(CypherParser::ONLY, 0);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::COMMIT() {
return getToken(CypherParser::COMMIT, 0);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::ROLLBACK() {
return getToken(CypherParser::ROLLBACK, 0);
}
tree::TerminalNode* CypherParser::IC_TransactionContext::CHECKPOINT() {
return getToken(CypherParser::CHECKPOINT, 0);
}
size_t CypherParser::IC_TransactionContext::getRuleIndex() const {
return CypherParser::RuleIC_Transaction;
}
CypherParser::IC_TransactionContext* CypherParser::iC_Transaction() {
IC_TransactionContext *_localctx = _tracker.createInstance<IC_TransactionContext>(_ctx, getState());
enterRule(_localctx, 130, CypherParser::RuleIC_Transaction);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1351);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 166, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1338);
match(CypherParser::BEGIN);
setState(1339);
match(CypherParser::SP);
setState(1340);
match(CypherParser::TRANSACTION);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1341);
match(CypherParser::BEGIN);
setState(1342);
match(CypherParser::SP);
setState(1343);
match(CypherParser::TRANSACTION);
setState(1344);
match(CypherParser::SP);
setState(1345);
match(CypherParser::READ);
setState(1346);
match(CypherParser::SP);
setState(1347);
match(CypherParser::ONLY);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(1348);
match(CypherParser::COMMIT);
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(1349);
match(CypherParser::ROLLBACK);
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(1350);
match(CypherParser::CHECKPOINT);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ExtensionContext::IC_ExtensionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::IC_LoadExtensionContext* CypherParser::IC_ExtensionContext::iC_LoadExtension() {
return getRuleContext<CypherParser::IC_LoadExtensionContext>(0);
}
CypherParser::IC_InstallExtensionContext* CypherParser::IC_ExtensionContext::iC_InstallExtension() {
return getRuleContext<CypherParser::IC_InstallExtensionContext>(0);
}
CypherParser::IC_UninstallExtensionContext* CypherParser::IC_ExtensionContext::iC_UninstallExtension() {
return getRuleContext<CypherParser::IC_UninstallExtensionContext>(0);
}
CypherParser::IC_UpdateExtensionContext* CypherParser::IC_ExtensionContext::iC_UpdateExtension() {
return getRuleContext<CypherParser::IC_UpdateExtensionContext>(0);
}
size_t CypherParser::IC_ExtensionContext::getRuleIndex() const {
return CypherParser::RuleIC_Extension;
}
CypherParser::IC_ExtensionContext* CypherParser::iC_Extension() {
IC_ExtensionContext *_localctx = _tracker.createInstance<IC_ExtensionContext>(_ctx, getState());
enterRule(_localctx, 132, CypherParser::RuleIC_Extension);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1357);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::LOAD: {
enterOuterAlt(_localctx, 1);
setState(1353);
iC_LoadExtension();
break;
}
case CypherParser::FORCE:
case CypherParser::INSTALL: {
enterOuterAlt(_localctx, 2);
setState(1354);
iC_InstallExtension();
break;
}
case CypherParser::UNINSTALL: {
enterOuterAlt(_localctx, 3);
setState(1355);
iC_UninstallExtension();
break;
}
case CypherParser::UPDATE: {
enterOuterAlt(_localctx, 4);
setState(1356);
iC_UpdateExtension();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_LoadExtensionContext::IC_LoadExtensionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_LoadExtensionContext::LOAD() {
return getToken(CypherParser::LOAD, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_LoadExtensionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_LoadExtensionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_LoadExtensionContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
CypherParser::OC_VariableContext* CypherParser::IC_LoadExtensionContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
tree::TerminalNode* CypherParser::IC_LoadExtensionContext::EXTENSION() {
return getToken(CypherParser::EXTENSION, 0);
}
size_t CypherParser::IC_LoadExtensionContext::getRuleIndex() const {
return CypherParser::RuleIC_LoadExtension;
}
CypherParser::IC_LoadExtensionContext* CypherParser::iC_LoadExtension() {
IC_LoadExtensionContext *_localctx = _tracker.createInstance<IC_LoadExtensionContext>(_ctx, getState());
enterRule(_localctx, 134, CypherParser::RuleIC_LoadExtension);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1359);
match(CypherParser::LOAD);
setState(1360);
match(CypherParser::SP);
setState(1363);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 168, _ctx)) {
case 1: {
setState(1361);
match(CypherParser::EXTENSION);
setState(1362);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1367);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::StringLiteral: {
setState(1365);
match(CypherParser::StringLiteral);
break;
}
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
setState(1366);
oC_Variable();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_InstallExtensionContext::IC_InstallExtensionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_InstallExtensionContext::INSTALL() {
return getToken(CypherParser::INSTALL, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_InstallExtensionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_InstallExtensionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_VariableContext* CypherParser::IC_InstallExtensionContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
tree::TerminalNode* CypherParser::IC_InstallExtensionContext::FORCE() {
return getToken(CypherParser::FORCE, 0);
}
tree::TerminalNode* CypherParser::IC_InstallExtensionContext::FROM() {
return getToken(CypherParser::FROM, 0);
}
tree::TerminalNode* CypherParser::IC_InstallExtensionContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
size_t CypherParser::IC_InstallExtensionContext::getRuleIndex() const {
return CypherParser::RuleIC_InstallExtension;
}
CypherParser::IC_InstallExtensionContext* CypherParser::iC_InstallExtension() {
IC_InstallExtensionContext *_localctx = _tracker.createInstance<IC_InstallExtensionContext>(_ctx, getState());
enterRule(_localctx, 136, CypherParser::RuleIC_InstallExtension);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1371);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::FORCE) {
setState(1369);
match(CypherParser::FORCE);
setState(1370);
match(CypherParser::SP);
}
setState(1373);
match(CypherParser::INSTALL);
setState(1374);
match(CypherParser::SP);
setState(1375);
oC_Variable();
setState(1380);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx)) {
case 1: {
setState(1376);
match(CypherParser::SP);
setState(1377);
match(CypherParser::FROM);
setState(1378);
match(CypherParser::SP);
setState(1379);
match(CypherParser::StringLiteral);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_UninstallExtensionContext::IC_UninstallExtensionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_UninstallExtensionContext::UNINSTALL() {
return getToken(CypherParser::UNINSTALL, 0);
}
tree::TerminalNode* CypherParser::IC_UninstallExtensionContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_VariableContext* CypherParser::IC_UninstallExtensionContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
size_t CypherParser::IC_UninstallExtensionContext::getRuleIndex() const {
return CypherParser::RuleIC_UninstallExtension;
}
CypherParser::IC_UninstallExtensionContext* CypherParser::iC_UninstallExtension() {
IC_UninstallExtensionContext *_localctx = _tracker.createInstance<IC_UninstallExtensionContext>(_ctx, getState());
enterRule(_localctx, 138, CypherParser::RuleIC_UninstallExtension);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1382);
match(CypherParser::UNINSTALL);
setState(1383);
match(CypherParser::SP);
setState(1384);
oC_Variable();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_UpdateExtensionContext::IC_UpdateExtensionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_UpdateExtensionContext::UPDATE() {
return getToken(CypherParser::UPDATE, 0);
}
tree::TerminalNode* CypherParser::IC_UpdateExtensionContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_VariableContext* CypherParser::IC_UpdateExtensionContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
size_t CypherParser::IC_UpdateExtensionContext::getRuleIndex() const {
return CypherParser::RuleIC_UpdateExtension;
}
CypherParser::IC_UpdateExtensionContext* CypherParser::iC_UpdateExtension() {
IC_UpdateExtensionContext *_localctx = _tracker.createInstance<IC_UpdateExtensionContext>(_ctx, getState());
enterRule(_localctx, 140, CypherParser::RuleIC_UpdateExtension);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1386);
match(CypherParser::UPDATE);
setState(1387);
match(CypherParser::SP);
setState(1388);
oC_Variable();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_QueryContext::OC_QueryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_RegularQueryContext* CypherParser::OC_QueryContext::oC_RegularQuery() {
return getRuleContext<CypherParser::OC_RegularQueryContext>(0);
}
size_t CypherParser::OC_QueryContext::getRuleIndex() const {
return CypherParser::RuleOC_Query;
}
CypherParser::OC_QueryContext* CypherParser::oC_Query() {
OC_QueryContext *_localctx = _tracker.createInstance<OC_QueryContext>(_ctx, getState());
enterRule(_localctx, 142, CypherParser::RuleOC_Query);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1390);
oC_RegularQuery();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RegularQueryContext::OC_RegularQueryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SingleQueryContext* CypherParser::OC_RegularQueryContext::oC_SingleQuery() {
return getRuleContext<CypherParser::OC_SingleQueryContext>(0);
}
std::vector<CypherParser::OC_UnionContext *> CypherParser::OC_RegularQueryContext::oC_Union() {
return getRuleContexts<CypherParser::OC_UnionContext>();
}
CypherParser::OC_UnionContext* CypherParser::OC_RegularQueryContext::oC_Union(size_t i) {
return getRuleContext<CypherParser::OC_UnionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_RegularQueryContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_RegularQueryContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_ReturnContext *> CypherParser::OC_RegularQueryContext::oC_Return() {
return getRuleContexts<CypherParser::OC_ReturnContext>();
}
CypherParser::OC_ReturnContext* CypherParser::OC_RegularQueryContext::oC_Return(size_t i) {
return getRuleContext<CypherParser::OC_ReturnContext>(i);
}
size_t CypherParser::OC_RegularQueryContext::getRuleIndex() const {
return CypherParser::RuleOC_RegularQuery;
}
CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() {
OC_RegularQueryContext *_localctx = _tracker.createInstance<OC_RegularQueryContext>(_ctx, getState());
enterRule(_localctx, 144, CypherParser::RuleOC_RegularQuery);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1413);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 176, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1392);
oC_SingleQuery();
setState(1399);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 173, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1394);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1393);
match(CypherParser::SP);
}
setState(1396);
oC_Union();
}
setState(1401);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 173, _ctx);
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1406);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(1402);
oC_Return();
setState(1404);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1403);
match(CypherParser::SP);
}
break;
}
default:
throw NoViableAltException(this);
}
setState(1408);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 175, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
setState(1410);
oC_SingleQuery();
notifyReturnNotAtEnd(_localctx->start);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_UnionContext::OC_UnionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_UnionContext::UNION() {
return getToken(CypherParser::UNION, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_UnionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_UnionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_UnionContext::ALL() {
return getToken(CypherParser::ALL, 0);
}
CypherParser::OC_SingleQueryContext* CypherParser::OC_UnionContext::oC_SingleQuery() {
return getRuleContext<CypherParser::OC_SingleQueryContext>(0);
}
size_t CypherParser::OC_UnionContext::getRuleIndex() const {
return CypherParser::RuleOC_Union;
}
CypherParser::OC_UnionContext* CypherParser::oC_Union() {
OC_UnionContext *_localctx = _tracker.createInstance<OC_UnionContext>(_ctx, getState());
enterRule(_localctx, 146, CypherParser::RuleOC_Union);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1427);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 179, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1415);
match(CypherParser::UNION);
setState(1416);
match(CypherParser::SP);
setState(1417);
match(CypherParser::ALL);
setState(1419);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1418);
match(CypherParser::SP);
}
setState(1421);
oC_SingleQuery();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1422);
match(CypherParser::UNION);
setState(1424);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1423);
match(CypherParser::SP);
}
setState(1426);
oC_SingleQuery();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_SingleQueryContext::OC_SingleQueryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SinglePartQueryContext* CypherParser::OC_SingleQueryContext::oC_SinglePartQuery() {
return getRuleContext<CypherParser::OC_SinglePartQueryContext>(0);
}
CypherParser::OC_MultiPartQueryContext* CypherParser::OC_SingleQueryContext::oC_MultiPartQuery() {
return getRuleContext<CypherParser::OC_MultiPartQueryContext>(0);
}
size_t CypherParser::OC_SingleQueryContext::getRuleIndex() const {
return CypherParser::RuleOC_SingleQuery;
}
CypherParser::OC_SingleQueryContext* CypherParser::oC_SingleQuery() {
OC_SingleQueryContext *_localctx = _tracker.createInstance<OC_SingleQueryContext>(_ctx, getState());
enterRule(_localctx, 148, CypherParser::RuleOC_SingleQuery);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1431);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1429);
oC_SinglePartQuery();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1430);
oC_MultiPartQuery();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_SinglePartQueryContext::OC_SinglePartQueryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ReturnContext* CypherParser::OC_SinglePartQueryContext::oC_Return() {
return getRuleContext<CypherParser::OC_ReturnContext>(0);
}
std::vector<CypherParser::OC_ReadingClauseContext *> CypherParser::OC_SinglePartQueryContext::oC_ReadingClause() {
return getRuleContexts<CypherParser::OC_ReadingClauseContext>();
}
CypherParser::OC_ReadingClauseContext* CypherParser::OC_SinglePartQueryContext::oC_ReadingClause(size_t i) {
return getRuleContext<CypherParser::OC_ReadingClauseContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_SinglePartQueryContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_SinglePartQueryContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_UpdatingClauseContext *> CypherParser::OC_SinglePartQueryContext::oC_UpdatingClause() {
return getRuleContexts<CypherParser::OC_UpdatingClauseContext>();
}
CypherParser::OC_UpdatingClauseContext* CypherParser::OC_SinglePartQueryContext::oC_UpdatingClause(size_t i) {
return getRuleContext<CypherParser::OC_UpdatingClauseContext>(i);
}
size_t CypherParser::OC_SinglePartQueryContext::getRuleIndex() const {
return CypherParser::RuleOC_SinglePartQuery;
}
CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() {
OC_SinglePartQueryContext *_localctx = _tracker.createInstance<OC_SinglePartQueryContext>(_ctx, getState());
enterRule(_localctx, 150, CypherParser::RuleOC_SinglePartQuery);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1468);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 189, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1439);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 103)) & 2199023288329) != 0)) {
setState(1433);
oC_ReadingClause();
setState(1435);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1434);
match(CypherParser::SP);
}
setState(1441);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1442);
oC_Return();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1449);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 103)) & 2199023288329) != 0)) {
setState(1443);
oC_ReadingClause();
setState(1445);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1444);
match(CypherParser::SP);
}
setState(1451);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1452);
oC_UpdatingClause();
setState(1459);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 186, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1454);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1453);
match(CypherParser::SP);
}
setState(1456);
oC_UpdatingClause();
}
setState(1461);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 186, _ctx);
}
setState(1466);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 188, _ctx)) {
case 1: {
setState(1463);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1462);
match(CypherParser::SP);
}
setState(1465);
oC_Return();
break;
}
default:
break;
}
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_MultiPartQueryContext::OC_MultiPartQueryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SinglePartQueryContext* CypherParser::OC_MultiPartQueryContext::oC_SinglePartQuery() {
return getRuleContext<CypherParser::OC_SinglePartQueryContext>(0);
}
std::vector<CypherParser::IC_QueryPartContext *> CypherParser::OC_MultiPartQueryContext::iC_QueryPart() {
return getRuleContexts<CypherParser::IC_QueryPartContext>();
}
CypherParser::IC_QueryPartContext* CypherParser::OC_MultiPartQueryContext::iC_QueryPart(size_t i) {
return getRuleContext<CypherParser::IC_QueryPartContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_MultiPartQueryContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_MultiPartQueryContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_MultiPartQueryContext::getRuleIndex() const {
return CypherParser::RuleOC_MultiPartQuery;
}
CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() {
OC_MultiPartQueryContext *_localctx = _tracker.createInstance<OC_MultiPartQueryContext>(_ctx, getState());
enterRule(_localctx, 152, CypherParser::RuleOC_MultiPartQuery);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1474);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(1470);
iC_QueryPart();
setState(1472);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1471);
match(CypherParser::SP);
}
break;
}
default:
throw NoViableAltException(this);
}
setState(1476);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 191, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
setState(1478);
oC_SinglePartQuery();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_QueryPartContext::IC_QueryPartContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_WithContext* CypherParser::IC_QueryPartContext::oC_With() {
return getRuleContext<CypherParser::OC_WithContext>(0);
}
std::vector<CypherParser::OC_ReadingClauseContext *> CypherParser::IC_QueryPartContext::oC_ReadingClause() {
return getRuleContexts<CypherParser::OC_ReadingClauseContext>();
}
CypherParser::OC_ReadingClauseContext* CypherParser::IC_QueryPartContext::oC_ReadingClause(size_t i) {
return getRuleContext<CypherParser::OC_ReadingClauseContext>(i);
}
std::vector<CypherParser::OC_UpdatingClauseContext *> CypherParser::IC_QueryPartContext::oC_UpdatingClause() {
return getRuleContexts<CypherParser::OC_UpdatingClauseContext>();
}
CypherParser::OC_UpdatingClauseContext* CypherParser::IC_QueryPartContext::oC_UpdatingClause(size_t i) {
return getRuleContext<CypherParser::OC_UpdatingClauseContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_QueryPartContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_QueryPartContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_QueryPartContext::getRuleIndex() const {
return CypherParser::RuleIC_QueryPart;
}
CypherParser::IC_QueryPartContext* CypherParser::iC_QueryPart() {
IC_QueryPartContext *_localctx = _tracker.createInstance<IC_QueryPartContext>(_ctx, getState());
enterRule(_localctx, 154, CypherParser::RuleIC_QueryPart);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1486);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 103)) & 2199023288329) != 0)) {
setState(1480);
oC_ReadingClause();
setState(1482);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1481);
match(CypherParser::SP);
}
setState(1488);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1495);
_errHandler->sync(this);
_la = _input->LA(1);
while (((((_la - 68) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 68)) & -9223370937343147743) != 0)) {
setState(1489);
oC_UpdatingClause();
setState(1491);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1490);
match(CypherParser::SP);
}
setState(1497);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(1498);
oC_With();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_UpdatingClauseContext::OC_UpdatingClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_CreateContext* CypherParser::OC_UpdatingClauseContext::oC_Create() {
return getRuleContext<CypherParser::OC_CreateContext>(0);
}
CypherParser::OC_MergeContext* CypherParser::OC_UpdatingClauseContext::oC_Merge() {
return getRuleContext<CypherParser::OC_MergeContext>(0);
}
CypherParser::OC_SetContext* CypherParser::OC_UpdatingClauseContext::oC_Set() {
return getRuleContext<CypherParser::OC_SetContext>(0);
}
CypherParser::OC_DeleteContext* CypherParser::OC_UpdatingClauseContext::oC_Delete() {
return getRuleContext<CypherParser::OC_DeleteContext>(0);
}
size_t CypherParser::OC_UpdatingClauseContext::getRuleIndex() const {
return CypherParser::RuleOC_UpdatingClause;
}
CypherParser::OC_UpdatingClauseContext* CypherParser::oC_UpdatingClause() {
OC_UpdatingClauseContext *_localctx = _tracker.createInstance<OC_UpdatingClauseContext>(_ctx, getState());
enterRule(_localctx, 156, CypherParser::RuleOC_UpdatingClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1504);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::CREATE: {
enterOuterAlt(_localctx, 1);
setState(1500);
oC_Create();
break;
}
case CypherParser::MERGE: {
enterOuterAlt(_localctx, 2);
setState(1501);
oC_Merge();
break;
}
case CypherParser::SET: {
enterOuterAlt(_localctx, 3);
setState(1502);
oC_Set();
break;
}
case CypherParser::DELETE:
case CypherParser::DETACH: {
enterOuterAlt(_localctx, 4);
setState(1503);
oC_Delete();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ReadingClauseContext::OC_ReadingClauseContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_MatchContext* CypherParser::OC_ReadingClauseContext::oC_Match() {
return getRuleContext<CypherParser::OC_MatchContext>(0);
}
CypherParser::OC_UnwindContext* CypherParser::OC_ReadingClauseContext::oC_Unwind() {
return getRuleContext<CypherParser::OC_UnwindContext>(0);
}
CypherParser::IC_InQueryCallContext* CypherParser::OC_ReadingClauseContext::iC_InQueryCall() {
return getRuleContext<CypherParser::IC_InQueryCallContext>(0);
}
CypherParser::IC_LoadFromContext* CypherParser::OC_ReadingClauseContext::iC_LoadFrom() {
return getRuleContext<CypherParser::IC_LoadFromContext>(0);
}
size_t CypherParser::OC_ReadingClauseContext::getRuleIndex() const {
return CypherParser::RuleOC_ReadingClause;
}
CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() {
OC_ReadingClauseContext *_localctx = _tracker.createInstance<OC_ReadingClauseContext>(_ctx, getState());
enterRule(_localctx, 158, CypherParser::RuleOC_ReadingClause);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1510);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::MATCH:
case CypherParser::OPTIONAL: {
enterOuterAlt(_localctx, 1);
setState(1506);
oC_Match();
break;
}
case CypherParser::UNWIND: {
enterOuterAlt(_localctx, 2);
setState(1507);
oC_Unwind();
break;
}
case CypherParser::CALL: {
enterOuterAlt(_localctx, 3);
setState(1508);
iC_InQueryCall();
break;
}
case CypherParser::LOAD: {
enterOuterAlt(_localctx, 4);
setState(1509);
iC_LoadFrom();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_LoadFromContext::IC_LoadFromContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_LoadFromContext::LOAD() {
return getToken(CypherParser::LOAD, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_LoadFromContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_LoadFromContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_LoadFromContext::FROM() {
return getToken(CypherParser::FROM, 0);
}
CypherParser::IC_ScanSourceContext* CypherParser::IC_LoadFromContext::iC_ScanSource() {
return getRuleContext<CypherParser::IC_ScanSourceContext>(0);
}
tree::TerminalNode* CypherParser::IC_LoadFromContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
tree::TerminalNode* CypherParser::IC_LoadFromContext::HEADERS() {
return getToken(CypherParser::HEADERS, 0);
}
CypherParser::IC_ColumnDefinitionsContext* CypherParser::IC_LoadFromContext::iC_ColumnDefinitions() {
return getRuleContext<CypherParser::IC_ColumnDefinitionsContext>(0);
}
CypherParser::IC_OptionsContext* CypherParser::IC_LoadFromContext::iC_Options() {
return getRuleContext<CypherParser::IC_OptionsContext>(0);
}
CypherParser::OC_WhereContext* CypherParser::IC_LoadFromContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
size_t CypherParser::IC_LoadFromContext::getRuleIndex() const {
return CypherParser::RuleIC_LoadFrom;
}
CypherParser::IC_LoadFromContext* CypherParser::iC_LoadFrom() {
IC_LoadFromContext *_localctx = _tracker.createInstance<IC_LoadFromContext>(_ctx, getState());
enterRule(_localctx, 160, CypherParser::RuleIC_LoadFrom);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1512);
match(CypherParser::LOAD);
setState(1530);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx)) {
case 1: {
setState(1513);
match(CypherParser::SP);
setState(1514);
match(CypherParser::WITH);
setState(1515);
match(CypherParser::SP);
setState(1516);
match(CypherParser::HEADERS);
setState(1518);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1517);
match(CypherParser::SP);
}
setState(1520);
match(CypherParser::T__1);
setState(1522);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1521);
match(CypherParser::SP);
}
setState(1524);
iC_ColumnDefinitions();
setState(1526);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1525);
match(CypherParser::SP);
}
setState(1528);
match(CypherParser::T__2);
break;
}
default:
break;
}
setState(1532);
match(CypherParser::SP);
setState(1533);
match(CypherParser::FROM);
setState(1534);
match(CypherParser::SP);
setState(1535);
iC_ScanSource();
setState(1549);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
case 1: {
setState(1537);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1536);
match(CypherParser::SP);
}
setState(1539);
match(CypherParser::T__1);
setState(1541);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1540);
match(CypherParser::SP);
}
setState(1543);
iC_Options();
setState(1545);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1544);
match(CypherParser::SP);
}
setState(1547);
match(CypherParser::T__2);
break;
}
default:
break;
}
setState(1555);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx)) {
case 1: {
setState(1552);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1551);
match(CypherParser::SP);
}
setState(1554);
oC_Where();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_YieldItemContext::OC_YieldItemContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_VariableContext *> CypherParser::OC_YieldItemContext::oC_Variable() {
return getRuleContexts<CypherParser::OC_VariableContext>();
}
CypherParser::OC_VariableContext* CypherParser::OC_YieldItemContext::oC_Variable(size_t i) {
return getRuleContext<CypherParser::OC_VariableContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_YieldItemContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_YieldItemContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_YieldItemContext::AS() {
return getToken(CypherParser::AS, 0);
}
size_t CypherParser::OC_YieldItemContext::getRuleIndex() const {
return CypherParser::RuleOC_YieldItem;
}
CypherParser::OC_YieldItemContext* CypherParser::oC_YieldItem() {
OC_YieldItemContext *_localctx = _tracker.createInstance<OC_YieldItemContext>(_ctx, getState());
enterRule(_localctx, 162, CypherParser::RuleOC_YieldItem);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1562);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 208, _ctx)) {
case 1: {
setState(1557);
oC_Variable();
setState(1558);
match(CypherParser::SP);
setState(1559);
match(CypherParser::AS);
setState(1560);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1564);
oC_Variable();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_YieldItemsContext::OC_YieldItemsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_YieldItemContext *> CypherParser::OC_YieldItemsContext::oC_YieldItem() {
return getRuleContexts<CypherParser::OC_YieldItemContext>();
}
CypherParser::OC_YieldItemContext* CypherParser::OC_YieldItemsContext::oC_YieldItem(size_t i) {
return getRuleContext<CypherParser::OC_YieldItemContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_YieldItemsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_YieldItemsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_YieldItemsContext::getRuleIndex() const {
return CypherParser::RuleOC_YieldItems;
}
CypherParser::OC_YieldItemsContext* CypherParser::oC_YieldItems() {
OC_YieldItemsContext *_localctx = _tracker.createInstance<OC_YieldItemsContext>(_ctx, getState());
enterRule(_localctx, 164, CypherParser::RuleOC_YieldItems);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1566);
oC_YieldItem();
setState(1577);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 211, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1568);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1567);
match(CypherParser::SP);
}
setState(1570);
match(CypherParser::T__3);
setState(1572);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1571);
match(CypherParser::SP);
}
setState(1574);
oC_YieldItem();
}
setState(1579);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 211, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_InQueryCallContext::IC_InQueryCallContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_InQueryCallContext::CALL() {
return getToken(CypherParser::CALL, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_InQueryCallContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_InQueryCallContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_FunctionInvocationContext* CypherParser::IC_InQueryCallContext::oC_FunctionInvocation() {
return getRuleContext<CypherParser::OC_FunctionInvocationContext>(0);
}
CypherParser::OC_WhereContext* CypherParser::IC_InQueryCallContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
tree::TerminalNode* CypherParser::IC_InQueryCallContext::YIELD() {
return getToken(CypherParser::YIELD, 0);
}
CypherParser::OC_YieldItemsContext* CypherParser::IC_InQueryCallContext::oC_YieldItems() {
return getRuleContext<CypherParser::OC_YieldItemsContext>(0);
}
size_t CypherParser::IC_InQueryCallContext::getRuleIndex() const {
return CypherParser::RuleIC_InQueryCall;
}
CypherParser::IC_InQueryCallContext* CypherParser::iC_InQueryCall() {
IC_InQueryCallContext *_localctx = _tracker.createInstance<IC_InQueryCallContext>(_ctx, getState());
enterRule(_localctx, 166, CypherParser::RuleIC_InQueryCall);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1580);
match(CypherParser::CALL);
setState(1581);
match(CypherParser::SP);
setState(1582);
oC_FunctionInvocation();
setState(1587);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 213, _ctx)) {
case 1: {
setState(1584);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1583);
match(CypherParser::SP);
}
setState(1586);
oC_Where();
break;
}
default:
break;
}
setState(1595);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 215, _ctx)) {
case 1: {
setState(1590);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1589);
match(CypherParser::SP);
}
setState(1592);
match(CypherParser::YIELD);
setState(1593);
match(CypherParser::SP);
setState(1594);
oC_YieldItems();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_MatchContext::OC_MatchContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_MatchContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
CypherParser::OC_PatternContext* CypherParser::OC_MatchContext::oC_Pattern() {
return getRuleContext<CypherParser::OC_PatternContext>(0);
}
tree::TerminalNode* CypherParser::OC_MatchContext::OPTIONAL() {
return getToken(CypherParser::OPTIONAL, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_MatchContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_MatchContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_WhereContext* CypherParser::OC_MatchContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
CypherParser::IC_HintContext* CypherParser::OC_MatchContext::iC_Hint() {
return getRuleContext<CypherParser::IC_HintContext>(0);
}
size_t CypherParser::OC_MatchContext::getRuleIndex() const {
return CypherParser::RuleOC_Match;
}
CypherParser::OC_MatchContext* CypherParser::oC_Match() {
OC_MatchContext *_localctx = _tracker.createInstance<OC_MatchContext>(_ctx, getState());
enterRule(_localctx, 168, CypherParser::RuleOC_Match);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1599);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::OPTIONAL) {
setState(1597);
match(CypherParser::OPTIONAL);
setState(1598);
match(CypherParser::SP);
}
setState(1601);
match(CypherParser::MATCH);
setState(1603);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1602);
match(CypherParser::SP);
}
setState(1605);
oC_Pattern();
setState(1608);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 218, _ctx)) {
case 1: {
setState(1606);
match(CypherParser::SP);
setState(1607);
oC_Where();
break;
}
default:
break;
}
setState(1612);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 219, _ctx)) {
case 1: {
setState(1610);
match(CypherParser::SP);
setState(1611);
iC_Hint();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_HintContext::IC_HintContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_HintContext::HINT() {
return getToken(CypherParser::HINT, 0);
}
tree::TerminalNode* CypherParser::IC_HintContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::IC_JoinNodeContext* CypherParser::IC_HintContext::iC_JoinNode() {
return getRuleContext<CypherParser::IC_JoinNodeContext>(0);
}
size_t CypherParser::IC_HintContext::getRuleIndex() const {
return CypherParser::RuleIC_Hint;
}
CypherParser::IC_HintContext* CypherParser::iC_Hint() {
IC_HintContext *_localctx = _tracker.createInstance<IC_HintContext>(_ctx, getState());
enterRule(_localctx, 170, CypherParser::RuleIC_Hint);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1614);
match(CypherParser::HINT);
setState(1615);
match(CypherParser::SP);
setState(1616);
iC_JoinNode(0);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_JoinNodeContext::IC_JoinNodeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_JoinNodeContext *> CypherParser::IC_JoinNodeContext::iC_JoinNode() {
return getRuleContexts<CypherParser::IC_JoinNodeContext>();
}
CypherParser::IC_JoinNodeContext* CypherParser::IC_JoinNodeContext::iC_JoinNode(size_t i) {
return getRuleContext<CypherParser::IC_JoinNodeContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_JoinNodeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_JoinNodeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_SchemaNameContext *> CypherParser::IC_JoinNodeContext::oC_SchemaName() {
return getRuleContexts<CypherParser::OC_SchemaNameContext>();
}
CypherParser::OC_SchemaNameContext* CypherParser::IC_JoinNodeContext::oC_SchemaName(size_t i) {
return getRuleContext<CypherParser::OC_SchemaNameContext>(i);
}
tree::TerminalNode* CypherParser::IC_JoinNodeContext::JOIN() {
return getToken(CypherParser::JOIN, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_JoinNodeContext::MULTI_JOIN() {
return getTokens(CypherParser::MULTI_JOIN);
}
tree::TerminalNode* CypherParser::IC_JoinNodeContext::MULTI_JOIN(size_t i) {
return getToken(CypherParser::MULTI_JOIN, i);
}
size_t CypherParser::IC_JoinNodeContext::getRuleIndex() const {
return CypherParser::RuleIC_JoinNode;
}
CypherParser::IC_JoinNodeContext* CypherParser::iC_JoinNode() {
return iC_JoinNode(0);
}
CypherParser::IC_JoinNodeContext* CypherParser::iC_JoinNode(int precedence) {
ParserRuleContext *parentContext = _ctx;
size_t parentState = getState();
CypherParser::IC_JoinNodeContext *_localctx = _tracker.createInstance<IC_JoinNodeContext>(_ctx, parentState);
CypherParser::IC_JoinNodeContext *previousContext = _localctx;
(void)previousContext; size_t startState = 172;
enterRecursionRule(_localctx, 172, CypherParser::RuleIC_JoinNode, precedence);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
unrollRecursionContexts(parentContext);
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1630);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::T__1: {
setState(1619);
match(CypherParser::T__1);
setState(1621);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1620);
match(CypherParser::SP);
}
setState(1623);
iC_JoinNode(0);
setState(1625);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1624);
match(CypherParser::SP);
}
setState(1627);
match(CypherParser::T__2);
break;
}
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
setState(1629);
oC_SchemaName();
break;
}
default:
throw NoViableAltException(this);
}
_ctx->stop = _input->LT(-1);
setState(1648);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
if (!_parseListeners.empty())
triggerExitRuleEvent();
previousContext = _localctx;
setState(1646);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 224, _ctx)) {
case 1: {
_localctx = _tracker.createInstance<IC_JoinNodeContext>(parentContext, parentState);
pushNewRecursionContext(_localctx, startState, RuleIC_JoinNode);
setState(1632);
if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
setState(1633);
match(CypherParser::SP);
setState(1634);
match(CypherParser::JOIN);
setState(1635);
match(CypherParser::SP);
setState(1636);
iC_JoinNode(5);
break;
}
case 2: {
_localctx = _tracker.createInstance<IC_JoinNodeContext>(parentContext, parentState);
pushNewRecursionContext(_localctx, startState, RuleIC_JoinNode);
setState(1637);
if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1642);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(1638);
match(CypherParser::SP);
setState(1639);
match(CypherParser::MULTI_JOIN);
setState(1640);
match(CypherParser::SP);
setState(1641);
oC_SchemaName();
break;
}
default:
throw NoViableAltException(this);
}
setState(1644);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 223, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
break;
}
default:
break;
}
}
setState(1650);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_UnwindContext::OC_UnwindContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_UnwindContext::UNWIND() {
return getToken(CypherParser::UNWIND, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_UnwindContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_UnwindContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_UnwindContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_UnwindContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::OC_VariableContext* CypherParser::OC_UnwindContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
size_t CypherParser::OC_UnwindContext::getRuleIndex() const {
return CypherParser::RuleOC_Unwind;
}
CypherParser::OC_UnwindContext* CypherParser::oC_Unwind() {
OC_UnwindContext *_localctx = _tracker.createInstance<OC_UnwindContext>(_ctx, getState());
enterRule(_localctx, 174, CypherParser::RuleOC_Unwind);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1651);
match(CypherParser::UNWIND);
setState(1653);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1652);
match(CypherParser::SP);
}
setState(1655);
oC_Expression();
setState(1656);
match(CypherParser::SP);
setState(1657);
match(CypherParser::AS);
setState(1658);
match(CypherParser::SP);
setState(1659);
oC_Variable();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_CreateContext::OC_CreateContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_CreateContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
CypherParser::OC_PatternContext* CypherParser::OC_CreateContext::oC_Pattern() {
return getRuleContext<CypherParser::OC_PatternContext>(0);
}
tree::TerminalNode* CypherParser::OC_CreateContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_CreateContext::getRuleIndex() const {
return CypherParser::RuleOC_Create;
}
CypherParser::OC_CreateContext* CypherParser::oC_Create() {
OC_CreateContext *_localctx = _tracker.createInstance<OC_CreateContext>(_ctx, getState());
enterRule(_localctx, 176, CypherParser::RuleOC_Create);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1661);
match(CypherParser::CREATE);
setState(1663);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1662);
match(CypherParser::SP);
}
setState(1665);
oC_Pattern();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_MergeContext::OC_MergeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_MergeContext::MERGE() {
return getToken(CypherParser::MERGE, 0);
}
CypherParser::OC_PatternContext* CypherParser::OC_MergeContext::oC_Pattern() {
return getRuleContext<CypherParser::OC_PatternContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_MergeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_MergeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_MergeActionContext *> CypherParser::OC_MergeContext::oC_MergeAction() {
return getRuleContexts<CypherParser::OC_MergeActionContext>();
}
CypherParser::OC_MergeActionContext* CypherParser::OC_MergeContext::oC_MergeAction(size_t i) {
return getRuleContext<CypherParser::OC_MergeActionContext>(i);
}
size_t CypherParser::OC_MergeContext::getRuleIndex() const {
return CypherParser::RuleOC_Merge;
}
CypherParser::OC_MergeContext* CypherParser::oC_Merge() {
OC_MergeContext *_localctx = _tracker.createInstance<OC_MergeContext>(_ctx, getState());
enterRule(_localctx, 178, CypherParser::RuleOC_Merge);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1667);
match(CypherParser::MERGE);
setState(1669);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1668);
match(CypherParser::SP);
}
setState(1671);
oC_Pattern();
setState(1676);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 229, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1672);
match(CypherParser::SP);
setState(1673);
oC_MergeAction();
}
setState(1678);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 229, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_MergeActionContext::OC_MergeActionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_MergeActionContext::ON() {
return getToken(CypherParser::ON, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_MergeActionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_MergeActionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_MergeActionContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
CypherParser::OC_SetContext* CypherParser::OC_MergeActionContext::oC_Set() {
return getRuleContext<CypherParser::OC_SetContext>(0);
}
tree::TerminalNode* CypherParser::OC_MergeActionContext::CREATE() {
return getToken(CypherParser::CREATE, 0);
}
size_t CypherParser::OC_MergeActionContext::getRuleIndex() const {
return CypherParser::RuleOC_MergeAction;
}
CypherParser::OC_MergeActionContext* CypherParser::oC_MergeAction() {
OC_MergeActionContext *_localctx = _tracker.createInstance<OC_MergeActionContext>(_ctx, getState());
enterRule(_localctx, 180, CypherParser::RuleOC_MergeAction);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1689);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1679);
match(CypherParser::ON);
setState(1680);
match(CypherParser::SP);
setState(1681);
match(CypherParser::MATCH);
setState(1682);
match(CypherParser::SP);
setState(1683);
oC_Set();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1684);
match(CypherParser::ON);
setState(1685);
match(CypherParser::SP);
setState(1686);
match(CypherParser::CREATE);
setState(1687);
match(CypherParser::SP);
setState(1688);
oC_Set();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_SetContext::OC_SetContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_SetContext::SET() {
return getToken(CypherParser::SET, 0);
}
std::vector<CypherParser::OC_SetItemContext *> CypherParser::OC_SetContext::oC_SetItem() {
return getRuleContexts<CypherParser::OC_SetItemContext>();
}
CypherParser::OC_SetItemContext* CypherParser::OC_SetContext::oC_SetItem(size_t i) {
return getRuleContext<CypherParser::OC_SetItemContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_SetContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_SetContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_AtomContext* CypherParser::OC_SetContext::oC_Atom() {
return getRuleContext<CypherParser::OC_AtomContext>(0);
}
CypherParser::IC_PropertiesContext* CypherParser::OC_SetContext::iC_Properties() {
return getRuleContext<CypherParser::IC_PropertiesContext>(0);
}
size_t CypherParser::OC_SetContext::getRuleIndex() const {
return CypherParser::RuleOC_Set;
}
CypherParser::OC_SetContext* CypherParser::oC_Set() {
OC_SetContext *_localctx = _tracker.createInstance<OC_SetContext>(_ctx, getState());
enterRule(_localctx, 182, CypherParser::RuleOC_Set);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1723);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 238, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1691);
match(CypherParser::SET);
setState(1693);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1692);
match(CypherParser::SP);
}
setState(1695);
oC_SetItem();
setState(1706);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1697);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1696);
match(CypherParser::SP);
}
setState(1699);
match(CypherParser::T__3);
setState(1701);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1700);
match(CypherParser::SP);
}
setState(1703);
oC_SetItem();
}
setState(1708);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx);
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1709);
match(CypherParser::SET);
setState(1711);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1710);
match(CypherParser::SP);
}
setState(1713);
oC_Atom();
setState(1715);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1714);
match(CypherParser::SP);
}
setState(1717);
match(CypherParser::T__5);
setState(1719);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1718);
match(CypherParser::SP);
}
setState(1721);
iC_Properties();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_SetItemContext::OC_SetItemContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_PropertyExpressionContext* CypherParser::OC_SetItemContext::oC_PropertyExpression() {
return getRuleContext<CypherParser::OC_PropertyExpressionContext>(0);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_SetItemContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_SetItemContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_SetItemContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_SetItemContext::getRuleIndex() const {
return CypherParser::RuleOC_SetItem;
}
CypherParser::OC_SetItemContext* CypherParser::oC_SetItem() {
OC_SetItemContext *_localctx = _tracker.createInstance<OC_SetItemContext>(_ctx, getState());
enterRule(_localctx, 184, CypherParser::RuleOC_SetItem);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1725);
oC_PropertyExpression();
setState(1727);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1726);
match(CypherParser::SP);
}
setState(1729);
match(CypherParser::T__5);
setState(1731);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1730);
match(CypherParser::SP);
}
setState(1733);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_DeleteContext::OC_DeleteContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_DeleteContext::DELETE() {
return getToken(CypherParser::DELETE, 0);
}
std::vector<CypherParser::OC_ExpressionContext *> CypherParser::OC_DeleteContext::oC_Expression() {
return getRuleContexts<CypherParser::OC_ExpressionContext>();
}
CypherParser::OC_ExpressionContext* CypherParser::OC_DeleteContext::oC_Expression(size_t i) {
return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}
tree::TerminalNode* CypherParser::OC_DeleteContext::DETACH() {
return getToken(CypherParser::DETACH, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_DeleteContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_DeleteContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_DeleteContext::getRuleIndex() const {
return CypherParser::RuleOC_Delete;
}
CypherParser::OC_DeleteContext* CypherParser::oC_Delete() {
OC_DeleteContext *_localctx = _tracker.createInstance<OC_DeleteContext>(_ctx, getState());
enterRule(_localctx, 186, CypherParser::RuleOC_Delete);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1737);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::DETACH) {
setState(1735);
match(CypherParser::DETACH);
setState(1736);
match(CypherParser::SP);
}
setState(1739);
match(CypherParser::DELETE);
setState(1741);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1740);
match(CypherParser::SP);
}
setState(1743);
oC_Expression();
setState(1754);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1745);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1744);
match(CypherParser::SP);
}
setState(1747);
match(CypherParser::T__3);
setState(1749);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1748);
match(CypherParser::SP);
}
setState(1751);
oC_Expression();
}
setState(1756);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_WithContext::OC_WithContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_WithContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
CypherParser::OC_ProjectionBodyContext* CypherParser::OC_WithContext::oC_ProjectionBody() {
return getRuleContext<CypherParser::OC_ProjectionBodyContext>(0);
}
CypherParser::OC_WhereContext* CypherParser::OC_WithContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
tree::TerminalNode* CypherParser::OC_WithContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_WithContext::getRuleIndex() const {
return CypherParser::RuleOC_With;
}
CypherParser::OC_WithContext* CypherParser::oC_With() {
OC_WithContext *_localctx = _tracker.createInstance<OC_WithContext>(_ctx, getState());
enterRule(_localctx, 188, CypherParser::RuleOC_With);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1757);
match(CypherParser::WITH);
setState(1758);
oC_ProjectionBody();
setState(1763);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _ctx)) {
case 1: {
setState(1760);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1759);
match(CypherParser::SP);
}
setState(1762);
oC_Where();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ReturnContext::OC_ReturnContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_ReturnContext::RETURN() {
return getToken(CypherParser::RETURN, 0);
}
CypherParser::OC_ProjectionBodyContext* CypherParser::OC_ReturnContext::oC_ProjectionBody() {
return getRuleContext<CypherParser::OC_ProjectionBodyContext>(0);
}
size_t CypherParser::OC_ReturnContext::getRuleIndex() const {
return CypherParser::RuleOC_Return;
}
CypherParser::OC_ReturnContext* CypherParser::oC_Return() {
OC_ReturnContext *_localctx = _tracker.createInstance<OC_ReturnContext>(_ctx, getState());
enterRule(_localctx, 190, CypherParser::RuleOC_Return);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1765);
match(CypherParser::RETURN);
setState(1766);
oC_ProjectionBody();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ProjectionBodyContext::OC_ProjectionBodyContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_ProjectionBodyContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ProjectionBodyContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_ProjectionItemsContext* CypherParser::OC_ProjectionBodyContext::oC_ProjectionItems() {
return getRuleContext<CypherParser::OC_ProjectionItemsContext>(0);
}
tree::TerminalNode* CypherParser::OC_ProjectionBodyContext::DISTINCT() {
return getToken(CypherParser::DISTINCT, 0);
}
CypherParser::OC_OrderContext* CypherParser::OC_ProjectionBodyContext::oC_Order() {
return getRuleContext<CypherParser::OC_OrderContext>(0);
}
CypherParser::OC_SkipContext* CypherParser::OC_ProjectionBodyContext::oC_Skip() {
return getRuleContext<CypherParser::OC_SkipContext>(0);
}
CypherParser::OC_LimitContext* CypherParser::OC_ProjectionBodyContext::oC_Limit() {
return getRuleContext<CypherParser::OC_LimitContext>(0);
}
size_t CypherParser::OC_ProjectionBodyContext::getRuleIndex() const {
return CypherParser::RuleOC_ProjectionBody;
}
CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() {
OC_ProjectionBodyContext *_localctx = _tracker.createInstance<OC_ProjectionBodyContext>(_ctx, getState());
enterRule(_localctx, 192, CypherParser::RuleOC_ProjectionBody);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1772);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 249, _ctx)) {
case 1: {
setState(1769);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1768);
match(CypherParser::SP);
}
setState(1771);
match(CypherParser::DISTINCT);
break;
}
default:
break;
}
setState(1774);
match(CypherParser::SP);
setState(1775);
oC_ProjectionItems();
setState(1778);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 250, _ctx)) {
case 1: {
setState(1776);
match(CypherParser::SP);
setState(1777);
oC_Order();
break;
}
default:
break;
}
setState(1782);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx)) {
case 1: {
setState(1780);
match(CypherParser::SP);
setState(1781);
oC_Skip();
break;
}
default:
break;
}
setState(1786);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
case 1: {
setState(1784);
match(CypherParser::SP);
setState(1785);
oC_Limit();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ProjectionItemsContext::OC_ProjectionItemsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_ProjectionItemsContext::STAR() {
return getToken(CypherParser::STAR, 0);
}
std::vector<CypherParser::OC_ProjectionItemContext *> CypherParser::OC_ProjectionItemsContext::oC_ProjectionItem() {
return getRuleContexts<CypherParser::OC_ProjectionItemContext>();
}
CypherParser::OC_ProjectionItemContext* CypherParser::OC_ProjectionItemsContext::oC_ProjectionItem(size_t i) {
return getRuleContext<CypherParser::OC_ProjectionItemContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_ProjectionItemsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ProjectionItemsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_ProjectionItemsContext::getRuleIndex() const {
return CypherParser::RuleOC_ProjectionItems;
}
CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() {
OC_ProjectionItemsContext *_localctx = _tracker.createInstance<OC_ProjectionItemsContext>(_ctx, getState());
enterRule(_localctx, 194, CypherParser::RuleOC_ProjectionItems);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1816);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::STAR: {
enterOuterAlt(_localctx, 1);
setState(1788);
match(CypherParser::STAR);
setState(1799);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 255, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1790);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1789);
match(CypherParser::SP);
}
setState(1792);
match(CypherParser::T__3);
setState(1794);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1793);
match(CypherParser::SP);
}
setState(1796);
oC_ProjectionItem();
}
setState(1801);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 255, _ctx);
}
break;
}
case CypherParser::T__1:
case CypherParser::T__6:
case CypherParser::T__8:
case CypherParser::T__24:
case CypherParser::ANY:
case CypherParser::ADD:
case CypherParser::ALL:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CASE:
case CypherParser::CAST:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXISTS:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FALSE:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::NOT:
case CypherParser::NONE:
case CypherParser::NULL_:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TRUE:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::SINGLE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::MINUS:
case CypherParser::StringLiteral:
case CypherParser::DecimalInteger:
case CypherParser::HexLetter:
case CypherParser::ExponentDecimalReal:
case CypherParser::RegularDecimalReal:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
enterOuterAlt(_localctx, 2);
setState(1802);
oC_ProjectionItem();
setState(1813);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 258, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1804);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1803);
match(CypherParser::SP);
}
setState(1806);
match(CypherParser::T__3);
setState(1808);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1807);
match(CypherParser::SP);
}
setState(1810);
oC_ProjectionItem();
}
setState(1815);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 258, _ctx);
}
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ProjectionItemContext::OC_ProjectionItemContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ExpressionContext* CypherParser::OC_ProjectionItemContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_ProjectionItemContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ProjectionItemContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_ProjectionItemContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::OC_VariableContext* CypherParser::OC_ProjectionItemContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
size_t CypherParser::OC_ProjectionItemContext::getRuleIndex() const {
return CypherParser::RuleOC_ProjectionItem;
}
CypherParser::OC_ProjectionItemContext* CypherParser::oC_ProjectionItem() {
OC_ProjectionItemContext *_localctx = _tracker.createInstance<OC_ProjectionItemContext>(_ctx, getState());
enterRule(_localctx, 196, CypherParser::RuleOC_ProjectionItem);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1825);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 260, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1818);
oC_Expression();
setState(1819);
match(CypherParser::SP);
setState(1820);
match(CypherParser::AS);
setState(1821);
match(CypherParser::SP);
setState(1822);
oC_Variable();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1824);
oC_Expression();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_OrderContext::OC_OrderContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_OrderContext::ORDER() {
return getToken(CypherParser::ORDER, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_OrderContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_OrderContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_OrderContext::BY() {
return getToken(CypherParser::BY, 0);
}
std::vector<CypherParser::OC_SortItemContext *> CypherParser::OC_OrderContext::oC_SortItem() {
return getRuleContexts<CypherParser::OC_SortItemContext>();
}
CypherParser::OC_SortItemContext* CypherParser::OC_OrderContext::oC_SortItem(size_t i) {
return getRuleContext<CypherParser::OC_SortItemContext>(i);
}
size_t CypherParser::OC_OrderContext::getRuleIndex() const {
return CypherParser::RuleOC_Order;
}
CypherParser::OC_OrderContext* CypherParser::oC_Order() {
OC_OrderContext *_localctx = _tracker.createInstance<OC_OrderContext>(_ctx, getState());
enterRule(_localctx, 198, CypherParser::RuleOC_Order);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1827);
match(CypherParser::ORDER);
setState(1828);
match(CypherParser::SP);
setState(1829);
match(CypherParser::BY);
setState(1830);
match(CypherParser::SP);
setState(1831);
oC_SortItem();
setState(1839);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3) {
setState(1832);
match(CypherParser::T__3);
setState(1834);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1833);
match(CypherParser::SP);
}
setState(1836);
oC_SortItem();
setState(1841);
_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;
}
CypherParser::OC_SkipContext::OC_SkipContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_SkipContext::L_SKIP() {
return getToken(CypherParser::L_SKIP, 0);
}
tree::TerminalNode* CypherParser::OC_SkipContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_SkipContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
size_t CypherParser::OC_SkipContext::getRuleIndex() const {
return CypherParser::RuleOC_Skip;
}
CypherParser::OC_SkipContext* CypherParser::oC_Skip() {
OC_SkipContext *_localctx = _tracker.createInstance<OC_SkipContext>(_ctx, getState());
enterRule(_localctx, 200, CypherParser::RuleOC_Skip);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1842);
match(CypherParser::L_SKIP);
setState(1843);
match(CypherParser::SP);
setState(1844);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_LimitContext::OC_LimitContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_LimitContext::LIMIT() {
return getToken(CypherParser::LIMIT, 0);
}
tree::TerminalNode* CypherParser::OC_LimitContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_LimitContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
size_t CypherParser::OC_LimitContext::getRuleIndex() const {
return CypherParser::RuleOC_Limit;
}
CypherParser::OC_LimitContext* CypherParser::oC_Limit() {
OC_LimitContext *_localctx = _tracker.createInstance<OC_LimitContext>(_ctx, getState());
enterRule(_localctx, 202, CypherParser::RuleOC_Limit);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1846);
match(CypherParser::LIMIT);
setState(1847);
match(CypherParser::SP);
setState(1848);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_SortItemContext::OC_SortItemContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ExpressionContext* CypherParser::OC_SortItemContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
tree::TerminalNode* CypherParser::OC_SortItemContext::ASCENDING() {
return getToken(CypherParser::ASCENDING, 0);
}
tree::TerminalNode* CypherParser::OC_SortItemContext::ASC() {
return getToken(CypherParser::ASC, 0);
}
tree::TerminalNode* CypherParser::OC_SortItemContext::DESCENDING() {
return getToken(CypherParser::DESCENDING, 0);
}
tree::TerminalNode* CypherParser::OC_SortItemContext::DESC() {
return getToken(CypherParser::DESC, 0);
}
tree::TerminalNode* CypherParser::OC_SortItemContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_SortItemContext::getRuleIndex() const {
return CypherParser::RuleOC_SortItem;
}
CypherParser::OC_SortItemContext* CypherParser::oC_SortItem() {
OC_SortItemContext *_localctx = _tracker.createInstance<OC_SortItemContext>(_ctx, getState());
enterRule(_localctx, 204, CypherParser::RuleOC_SortItem);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1850);
oC_Expression();
setState(1855);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 264, _ctx)) {
case 1: {
setState(1852);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1851);
match(CypherParser::SP);
}
setState(1854);
_la = _input->LA(1);
if (!(((((_la - 52) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 52)) & 12582915) != 0))) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_WhereContext::OC_WhereContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_WhereContext::WHERE() {
return getToken(CypherParser::WHERE, 0);
}
tree::TerminalNode* CypherParser::OC_WhereContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_WhereContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
size_t CypherParser::OC_WhereContext::getRuleIndex() const {
return CypherParser::RuleOC_Where;
}
CypherParser::OC_WhereContext* CypherParser::oC_Where() {
OC_WhereContext *_localctx = _tracker.createInstance<OC_WhereContext>(_ctx, getState());
enterRule(_localctx, 206, CypherParser::RuleOC_Where);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1857);
match(CypherParser::WHERE);
setState(1858);
match(CypherParser::SP);
setState(1859);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PatternContext::OC_PatternContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_PatternPartContext *> CypherParser::OC_PatternContext::oC_PatternPart() {
return getRuleContexts<CypherParser::OC_PatternPartContext>();
}
CypherParser::OC_PatternPartContext* CypherParser::OC_PatternContext::oC_PatternPart(size_t i) {
return getRuleContext<CypherParser::OC_PatternPartContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_PatternContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_PatternContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_PatternContext::getRuleIndex() const {
return CypherParser::RuleOC_Pattern;
}
CypherParser::OC_PatternContext* CypherParser::oC_Pattern() {
OC_PatternContext *_localctx = _tracker.createInstance<OC_PatternContext>(_ctx, getState());
enterRule(_localctx, 208, CypherParser::RuleOC_Pattern);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(1861);
oC_PatternPart();
setState(1872);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 267, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1863);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1862);
match(CypherParser::SP);
}
setState(1865);
match(CypherParser::T__3);
setState(1867);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1866);
match(CypherParser::SP);
}
setState(1869);
oC_PatternPart();
}
setState(1874);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 267, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PatternPartContext::OC_PatternPartContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_VariableContext* CypherParser::OC_PatternPartContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::OC_AnonymousPatternPartContext* CypherParser::OC_PatternPartContext::oC_AnonymousPatternPart() {
return getRuleContext<CypherParser::OC_AnonymousPatternPartContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_PatternPartContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_PatternPartContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_PatternPartContext::getRuleIndex() const {
return CypherParser::RuleOC_PatternPart;
}
CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() {
OC_PatternPartContext *_localctx = _tracker.createInstance<OC_PatternPartContext>(_ctx, getState());
enterRule(_localctx, 210, CypherParser::RuleOC_PatternPart);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1886);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
enterOuterAlt(_localctx, 1);
setState(1875);
oC_Variable();
setState(1877);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1876);
match(CypherParser::SP);
}
setState(1879);
match(CypherParser::T__5);
setState(1881);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1880);
match(CypherParser::SP);
}
setState(1883);
oC_AnonymousPatternPart();
break;
}
case CypherParser::T__1: {
enterOuterAlt(_localctx, 2);
setState(1885);
oC_AnonymousPatternPart();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_AnonymousPatternPartContext::OC_AnonymousPatternPartContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_PatternElementContext* CypherParser::OC_AnonymousPatternPartContext::oC_PatternElement() {
return getRuleContext<CypherParser::OC_PatternElementContext>(0);
}
size_t CypherParser::OC_AnonymousPatternPartContext::getRuleIndex() const {
return CypherParser::RuleOC_AnonymousPatternPart;
}
CypherParser::OC_AnonymousPatternPartContext* CypherParser::oC_AnonymousPatternPart() {
OC_AnonymousPatternPartContext *_localctx = _tracker.createInstance<OC_AnonymousPatternPartContext>(_ctx, getState());
enterRule(_localctx, 212, CypherParser::RuleOC_AnonymousPatternPart);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1888);
oC_PatternElement();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PatternElementContext::OC_PatternElementContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_NodePatternContext* CypherParser::OC_PatternElementContext::oC_NodePattern() {
return getRuleContext<CypherParser::OC_NodePatternContext>(0);
}
std::vector<CypherParser::OC_PatternElementChainContext *> CypherParser::OC_PatternElementContext::oC_PatternElementChain() {
return getRuleContexts<CypherParser::OC_PatternElementChainContext>();
}
CypherParser::OC_PatternElementChainContext* CypherParser::OC_PatternElementContext::oC_PatternElementChain(size_t i) {
return getRuleContext<CypherParser::OC_PatternElementChainContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_PatternElementContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_PatternElementContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_PatternElementContext* CypherParser::OC_PatternElementContext::oC_PatternElement() {
return getRuleContext<CypherParser::OC_PatternElementContext>(0);
}
size_t CypherParser::OC_PatternElementContext::getRuleIndex() const {
return CypherParser::RuleOC_PatternElement;
}
CypherParser::OC_PatternElementContext* CypherParser::oC_PatternElement() {
OC_PatternElementContext *_localctx = _tracker.createInstance<OC_PatternElementContext>(_ctx, getState());
enterRule(_localctx, 214, CypherParser::RuleOC_PatternElement);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(1904);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 273, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1890);
oC_NodePattern();
setState(1897);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 272, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(1892);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1891);
match(CypherParser::SP);
}
setState(1894);
oC_PatternElementChain();
}
setState(1899);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 272, _ctx);
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1900);
match(CypherParser::T__1);
setState(1901);
oC_PatternElement();
setState(1902);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_NodePatternContext::OC_NodePatternContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_NodePatternContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_NodePatternContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_VariableContext* CypherParser::OC_NodePatternContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::OC_NodeLabelsContext* CypherParser::OC_NodePatternContext::oC_NodeLabels() {
return getRuleContext<CypherParser::OC_NodeLabelsContext>(0);
}
CypherParser::IC_PropertiesContext* CypherParser::OC_NodePatternContext::iC_Properties() {
return getRuleContext<CypherParser::IC_PropertiesContext>(0);
}
size_t CypherParser::OC_NodePatternContext::getRuleIndex() const {
return CypherParser::RuleOC_NodePattern;
}
CypherParser::OC_NodePatternContext* CypherParser::oC_NodePattern() {
OC_NodePatternContext *_localctx = _tracker.createInstance<OC_NodePatternContext>(_ctx, getState());
enterRule(_localctx, 216, CypherParser::RuleOC_NodePattern);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1906);
match(CypherParser::T__1);
setState(1908);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1907);
match(CypherParser::SP);
}
setState(1914);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -287985230644762313) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5068755015275819) != 0)) {
setState(1910);
oC_Variable();
setState(1912);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1911);
match(CypherParser::SP);
}
}
setState(1920);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::COLON) {
setState(1916);
oC_NodeLabels();
setState(1918);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1917);
match(CypherParser::SP);
}
}
setState(1926);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__8) {
setState(1922);
iC_Properties();
setState(1924);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1923);
match(CypherParser::SP);
}
}
setState(1928);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PatternElementChainContext::OC_PatternElementChainContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_RelationshipPatternContext* CypherParser::OC_PatternElementChainContext::oC_RelationshipPattern() {
return getRuleContext<CypherParser::OC_RelationshipPatternContext>(0);
}
CypherParser::OC_NodePatternContext* CypherParser::OC_PatternElementChainContext::oC_NodePattern() {
return getRuleContext<CypherParser::OC_NodePatternContext>(0);
}
tree::TerminalNode* CypherParser::OC_PatternElementChainContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_PatternElementChainContext::getRuleIndex() const {
return CypherParser::RuleOC_PatternElementChain;
}
CypherParser::OC_PatternElementChainContext* CypherParser::oC_PatternElementChain() {
OC_PatternElementChainContext *_localctx = _tracker.createInstance<OC_PatternElementChainContext>(_ctx, getState());
enterRule(_localctx, 218, CypherParser::RuleOC_PatternElementChain);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1930);
oC_RelationshipPattern();
setState(1932);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1931);
match(CypherParser::SP);
}
setState(1934);
oC_NodePattern();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RelationshipPatternContext::OC_RelationshipPatternContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_LeftArrowHeadContext* CypherParser::OC_RelationshipPatternContext::oC_LeftArrowHead() {
return getRuleContext<CypherParser::OC_LeftArrowHeadContext>(0);
}
std::vector<CypherParser::OC_DashContext *> CypherParser::OC_RelationshipPatternContext::oC_Dash() {
return getRuleContexts<CypherParser::OC_DashContext>();
}
CypherParser::OC_DashContext* CypherParser::OC_RelationshipPatternContext::oC_Dash(size_t i) {
return getRuleContext<CypherParser::OC_DashContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_RelationshipPatternContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_RelationshipPatternContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_RelationshipDetailContext* CypherParser::OC_RelationshipPatternContext::oC_RelationshipDetail() {
return getRuleContext<CypherParser::OC_RelationshipDetailContext>(0);
}
CypherParser::OC_RightArrowHeadContext* CypherParser::OC_RelationshipPatternContext::oC_RightArrowHead() {
return getRuleContext<CypherParser::OC_RightArrowHeadContext>(0);
}
size_t CypherParser::OC_RelationshipPatternContext::getRuleIndex() const {
return CypherParser::RuleOC_RelationshipPattern;
}
CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPattern() {
OC_RelationshipPatternContext *_localctx = _tracker.createInstance<OC_RelationshipPatternContext>(_ctx, getState());
enterRule(_localctx, 220, CypherParser::RuleOC_RelationshipPattern);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(1980);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(1936);
oC_LeftArrowHead();
setState(1938);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1937);
match(CypherParser::SP);
}
setState(1940);
oC_Dash();
setState(1942);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 283, _ctx)) {
case 1: {
setState(1941);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1945);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__6) {
setState(1944);
oC_RelationshipDetail();
}
setState(1948);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1947);
match(CypherParser::SP);
}
setState(1950);
oC_Dash();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(1952);
oC_Dash();
setState(1954);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 286, _ctx)) {
case 1: {
setState(1953);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1957);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__6) {
setState(1956);
oC_RelationshipDetail();
}
setState(1960);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1959);
match(CypherParser::SP);
}
setState(1962);
oC_Dash();
setState(1964);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1963);
match(CypherParser::SP);
}
setState(1966);
oC_RightArrowHead();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(1968);
oC_Dash();
setState(1970);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 290, _ctx)) {
case 1: {
setState(1969);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(1973);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__6) {
setState(1972);
oC_RelationshipDetail();
}
setState(1976);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1975);
match(CypherParser::SP);
}
setState(1978);
oC_Dash();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RelationshipDetailContext::OC_RelationshipDetailContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_RelationshipDetailContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_RelationshipDetailContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_VariableContext* CypherParser::OC_RelationshipDetailContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::OC_RelationshipTypesContext* CypherParser::OC_RelationshipDetailContext::oC_RelationshipTypes() {
return getRuleContext<CypherParser::OC_RelationshipTypesContext>(0);
}
CypherParser::IC_RecursiveDetailContext* CypherParser::OC_RelationshipDetailContext::iC_RecursiveDetail() {
return getRuleContext<CypherParser::IC_RecursiveDetailContext>(0);
}
CypherParser::IC_PropertiesContext* CypherParser::OC_RelationshipDetailContext::iC_Properties() {
return getRuleContext<CypherParser::IC_PropertiesContext>(0);
}
size_t CypherParser::OC_RelationshipDetailContext::getRuleIndex() const {
return CypherParser::RuleOC_RelationshipDetail;
}
CypherParser::OC_RelationshipDetailContext* CypherParser::oC_RelationshipDetail() {
OC_RelationshipDetailContext *_localctx = _tracker.createInstance<OC_RelationshipDetailContext>(_ctx, getState());
enterRule(_localctx, 222, CypherParser::RuleOC_RelationshipDetail);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(1982);
match(CypherParser::T__6);
setState(1984);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1983);
match(CypherParser::SP);
}
setState(1990);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -287985230644762313) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5068755015275819) != 0)) {
setState(1986);
oC_Variable();
setState(1988);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1987);
match(CypherParser::SP);
}
}
setState(1996);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::COLON) {
setState(1992);
oC_RelationshipTypes();
setState(1994);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1993);
match(CypherParser::SP);
}
}
setState(2002);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::STAR) {
setState(1998);
iC_RecursiveDetail();
setState(2000);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(1999);
match(CypherParser::SP);
}
}
setState(2008);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__8) {
setState(2004);
iC_Properties();
setState(2006);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2005);
match(CypherParser::SP);
}
}
setState(2010);
match(CypherParser::T__7);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_PropertiesContext::IC_PropertiesContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::IC_PropertiesContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_PropertiesContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<CypherParser::OC_PropertyKeyNameContext *> CypherParser::IC_PropertiesContext::oC_PropertyKeyName() {
return getRuleContexts<CypherParser::OC_PropertyKeyNameContext>();
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_PropertiesContext::oC_PropertyKeyName(size_t i) {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_PropertiesContext::COLON() {
return getTokens(CypherParser::COLON);
}
tree::TerminalNode* CypherParser::IC_PropertiesContext::COLON(size_t i) {
return getToken(CypherParser::COLON, i);
}
std::vector<CypherParser::OC_ExpressionContext *> CypherParser::IC_PropertiesContext::oC_Expression() {
return getRuleContexts<CypherParser::OC_ExpressionContext>();
}
CypherParser::OC_ExpressionContext* CypherParser::IC_PropertiesContext::oC_Expression(size_t i) {
return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}
size_t CypherParser::IC_PropertiesContext::getRuleIndex() const {
return CypherParser::RuleIC_Properties;
}
CypherParser::IC_PropertiesContext* CypherParser::iC_Properties() {
IC_PropertiesContext *_localctx = _tracker.createInstance<IC_PropertiesContext>(_ctx, getState());
enterRule(_localctx, 224, CypherParser::RuleIC_Properties);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2012);
match(CypherParser::T__8);
setState(2014);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2013);
match(CypherParser::SP);
}
setState(2049);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -287985230644762313) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5068755015275819) != 0)) {
setState(2016);
oC_PropertyKeyName();
setState(2018);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2017);
match(CypherParser::SP);
}
setState(2020);
match(CypherParser::COLON);
setState(2022);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2021);
match(CypherParser::SP);
}
setState(2024);
oC_Expression();
setState(2026);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2025);
match(CypherParser::SP);
}
setState(2046);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3) {
setState(2028);
match(CypherParser::T__3);
setState(2030);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2029);
match(CypherParser::SP);
}
setState(2032);
oC_PropertyKeyName();
setState(2034);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2033);
match(CypherParser::SP);
}
setState(2036);
match(CypherParser::COLON);
setState(2038);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2037);
match(CypherParser::SP);
}
setState(2040);
oC_Expression();
setState(2042);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2041);
match(CypherParser::SP);
}
setState(2048);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
setState(2051);
match(CypherParser::T__9);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RelationshipTypesContext::OC_RelationshipTypesContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_RelationshipTypesContext::COLON() {
return getTokens(CypherParser::COLON);
}
tree::TerminalNode* CypherParser::OC_RelationshipTypesContext::COLON(size_t i) {
return getToken(CypherParser::COLON, i);
}
std::vector<CypherParser::OC_RelTypeNameContext *> CypherParser::OC_RelationshipTypesContext::oC_RelTypeName() {
return getRuleContexts<CypherParser::OC_RelTypeNameContext>();
}
CypherParser::OC_RelTypeNameContext* CypherParser::OC_RelationshipTypesContext::oC_RelTypeName(size_t i) {
return getRuleContext<CypherParser::OC_RelTypeNameContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_RelationshipTypesContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_RelationshipTypesContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_RelationshipTypesContext::getRuleIndex() const {
return CypherParser::RuleOC_RelationshipTypes;
}
CypherParser::OC_RelationshipTypesContext* CypherParser::oC_RelationshipTypes() {
OC_RelationshipTypesContext *_localctx = _tracker.createInstance<OC_RelationshipTypesContext>(_ctx, getState());
enterRule(_localctx, 226, CypherParser::RuleOC_RelationshipTypes);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2053);
match(CypherParser::COLON);
setState(2055);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2054);
match(CypherParser::SP);
}
setState(2057);
oC_RelTypeName();
setState(2071);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 317, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2059);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2058);
match(CypherParser::SP);
}
setState(2061);
match(CypherParser::T__10);
setState(2063);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::COLON) {
setState(2062);
match(CypherParser::COLON);
}
setState(2066);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2065);
match(CypherParser::SP);
}
setState(2068);
oC_RelTypeName();
}
setState(2073);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 317, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_NodeLabelsContext::OC_NodeLabelsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_NodeLabelsContext::COLON() {
return getTokens(CypherParser::COLON);
}
tree::TerminalNode* CypherParser::OC_NodeLabelsContext::COLON(size_t i) {
return getToken(CypherParser::COLON, i);
}
std::vector<CypherParser::OC_LabelNameContext *> CypherParser::OC_NodeLabelsContext::oC_LabelName() {
return getRuleContexts<CypherParser::OC_LabelNameContext>();
}
CypherParser::OC_LabelNameContext* CypherParser::OC_NodeLabelsContext::oC_LabelName(size_t i) {
return getRuleContext<CypherParser::OC_LabelNameContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_NodeLabelsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_NodeLabelsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_NodeLabelsContext::getRuleIndex() const {
return CypherParser::RuleOC_NodeLabels;
}
CypherParser::OC_NodeLabelsContext* CypherParser::oC_NodeLabels() {
OC_NodeLabelsContext *_localctx = _tracker.createInstance<OC_NodeLabelsContext>(_ctx, getState());
enterRule(_localctx, 228, CypherParser::RuleOC_NodeLabels);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2074);
match(CypherParser::COLON);
setState(2076);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2075);
match(CypherParser::SP);
}
setState(2078);
oC_LabelName();
setState(2095);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 323, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2080);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2079);
match(CypherParser::SP);
}
setState(2087);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::T__10: {
setState(2082);
match(CypherParser::T__10);
setState(2084);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::COLON) {
setState(2083);
match(CypherParser::COLON);
}
break;
}
case CypherParser::COLON: {
setState(2086);
match(CypherParser::COLON);
break;
}
default:
throw NoViableAltException(this);
}
setState(2090);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2089);
match(CypherParser::SP);
}
setState(2092);
oC_LabelName();
}
setState(2097);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 323, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_RecursiveDetailContext::IC_RecursiveDetailContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_RecursiveDetailContext::STAR() {
return getToken(CypherParser::STAR, 0);
}
CypherParser::IC_RecursiveTypeContext* CypherParser::IC_RecursiveDetailContext::iC_RecursiveType() {
return getRuleContext<CypherParser::IC_RecursiveTypeContext>(0);
}
CypherParser::OC_RangeLiteralContext* CypherParser::IC_RecursiveDetailContext::oC_RangeLiteral() {
return getRuleContext<CypherParser::OC_RangeLiteralContext>(0);
}
CypherParser::IC_RecursiveComprehensionContext* CypherParser::IC_RecursiveDetailContext::iC_RecursiveComprehension() {
return getRuleContext<CypherParser::IC_RecursiveComprehensionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_RecursiveDetailContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_RecursiveDetailContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_RecursiveDetailContext::getRuleIndex() const {
return CypherParser::RuleIC_RecursiveDetail;
}
CypherParser::IC_RecursiveDetailContext* CypherParser::iC_RecursiveDetail() {
IC_RecursiveDetailContext *_localctx = _tracker.createInstance<IC_RecursiveDetailContext>(_ctx, getState());
enterRule(_localctx, 230, CypherParser::RuleIC_RecursiveDetail);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2098);
match(CypherParser::STAR);
setState(2103);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 325, _ctx)) {
case 1: {
setState(2100);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2099);
match(CypherParser::SP);
}
setState(2102);
iC_RecursiveType();
break;
}
default:
break;
}
setState(2109);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx)) {
case 1: {
setState(2106);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 326, _ctx)) {
case 1: {
setState(2105);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(2108);
oC_RangeLiteral();
break;
}
default:
break;
}
setState(2115);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 329, _ctx)) {
case 1: {
setState(2112);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2111);
match(CypherParser::SP);
}
setState(2114);
iC_RecursiveComprehension();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_RecursiveTypeContext::IC_RecursiveTypeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_RecursiveTypeContext::WSHORTEST() {
return getToken(CypherParser::WSHORTEST, 0);
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::IC_RecursiveTypeContext::oC_PropertyKeyName() {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_RecursiveTypeContext::ALL() {
return getToken(CypherParser::ALL, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_RecursiveTypeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_RecursiveTypeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::IC_RecursiveTypeContext::SHORTEST() {
return getToken(CypherParser::SHORTEST, 0);
}
tree::TerminalNode* CypherParser::IC_RecursiveTypeContext::TRAIL() {
return getToken(CypherParser::TRAIL, 0);
}
tree::TerminalNode* CypherParser::IC_RecursiveTypeContext::ACYCLIC() {
return getToken(CypherParser::ACYCLIC, 0);
}
size_t CypherParser::IC_RecursiveTypeContext::getRuleIndex() const {
return CypherParser::RuleIC_RecursiveType;
}
CypherParser::IC_RecursiveTypeContext* CypherParser::iC_RecursiveType() {
IC_RecursiveTypeContext *_localctx = _tracker.createInstance<IC_RecursiveTypeContext>(_ctx, getState());
enterRule(_localctx, 232, CypherParser::RuleIC_RecursiveType);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2141);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 334, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2119);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::ALL) {
setState(2117);
match(CypherParser::ALL);
setState(2118);
match(CypherParser::SP);
}
setState(2121);
match(CypherParser::WSHORTEST);
setState(2123);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2122);
match(CypherParser::SP);
}
setState(2125);
match(CypherParser::T__1);
setState(2127);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2126);
match(CypherParser::SP);
}
setState(2129);
oC_PropertyKeyName();
setState(2131);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2130);
match(CypherParser::SP);
}
setState(2133);
match(CypherParser::T__2);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2135);
match(CypherParser::SHORTEST);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(2136);
match(CypherParser::ALL);
setState(2137);
match(CypherParser::SP);
setState(2138);
match(CypherParser::SHORTEST);
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(2139);
match(CypherParser::TRAIL);
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(2140);
match(CypherParser::ACYCLIC);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RangeLiteralContext::OC_RangeLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_RangeLiteralContext::DOTDOT() {
return getToken(CypherParser::DOTDOT, 0);
}
CypherParser::OC_LowerBoundContext* CypherParser::OC_RangeLiteralContext::oC_LowerBound() {
return getRuleContext<CypherParser::OC_LowerBoundContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_RangeLiteralContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_RangeLiteralContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_UpperBoundContext* CypherParser::OC_RangeLiteralContext::oC_UpperBound() {
return getRuleContext<CypherParser::OC_UpperBoundContext>(0);
}
CypherParser::OC_IntegerLiteralContext* CypherParser::OC_RangeLiteralContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
size_t CypherParser::OC_RangeLiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_RangeLiteral;
}
CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() {
OC_RangeLiteralContext *_localctx = _tracker.createInstance<OC_RangeLiteralContext>(_ctx, getState());
enterRule(_localctx, 234, CypherParser::RuleOC_RangeLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2157);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 339, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2144);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::DecimalInteger) {
setState(2143);
oC_LowerBound();
}
setState(2147);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2146);
match(CypherParser::SP);
}
setState(2149);
match(CypherParser::DOTDOT);
setState(2151);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 337, _ctx)) {
case 1: {
setState(2150);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(2154);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::DecimalInteger) {
setState(2153);
oC_UpperBound();
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2156);
oC_IntegerLiteral();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_RecursiveComprehensionContext::IC_RecursiveComprehensionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_VariableContext *> CypherParser::IC_RecursiveComprehensionContext::oC_Variable() {
return getRuleContexts<CypherParser::OC_VariableContext>();
}
CypherParser::OC_VariableContext* CypherParser::IC_RecursiveComprehensionContext::oC_Variable(size_t i) {
return getRuleContext<CypherParser::OC_VariableContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_RecursiveComprehensionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_RecursiveComprehensionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_WhereContext* CypherParser::IC_RecursiveComprehensionContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
std::vector<CypherParser::IC_RecursiveProjectionItemsContext *> CypherParser::IC_RecursiveComprehensionContext::iC_RecursiveProjectionItems() {
return getRuleContexts<CypherParser::IC_RecursiveProjectionItemsContext>();
}
CypherParser::IC_RecursiveProjectionItemsContext* CypherParser::IC_RecursiveComprehensionContext::iC_RecursiveProjectionItems(size_t i) {
return getRuleContext<CypherParser::IC_RecursiveProjectionItemsContext>(i);
}
size_t CypherParser::IC_RecursiveComprehensionContext::getRuleIndex() const {
return CypherParser::RuleIC_RecursiveComprehension;
}
CypherParser::IC_RecursiveComprehensionContext* CypherParser::iC_RecursiveComprehension() {
IC_RecursiveComprehensionContext *_localctx = _tracker.createInstance<IC_RecursiveComprehensionContext>(_ctx, getState());
enterRule(_localctx, 236, CypherParser::RuleIC_RecursiveComprehension);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2159);
match(CypherParser::T__1);
setState(2161);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2160);
match(CypherParser::SP);
}
setState(2163);
oC_Variable();
setState(2165);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2164);
match(CypherParser::SP);
}
setState(2167);
match(CypherParser::T__3);
setState(2169);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2168);
match(CypherParser::SP);
}
setState(2171);
oC_Variable();
setState(2183);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 346, _ctx)) {
case 1: {
setState(2173);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2172);
match(CypherParser::SP);
}
setState(2175);
match(CypherParser::T__10);
setState(2177);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2176);
match(CypherParser::SP);
}
setState(2179);
oC_Where();
setState(2181);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 345, _ctx)) {
case 1: {
setState(2180);
match(CypherParser::SP);
break;
}
default:
break;
}
break;
}
default:
break;
}
setState(2204);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__10 || _la == CypherParser::SP) {
setState(2186);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2185);
match(CypherParser::SP);
}
setState(2188);
match(CypherParser::T__10);
setState(2190);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2189);
match(CypherParser::SP);
}
setState(2192);
iC_RecursiveProjectionItems();
setState(2194);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2193);
match(CypherParser::SP);
}
setState(2196);
match(CypherParser::T__3);
setState(2198);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2197);
match(CypherParser::SP);
}
setState(2200);
iC_RecursiveProjectionItems();
setState(2202);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2201);
match(CypherParser::SP);
}
}
setState(2206);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_RecursiveProjectionItemsContext::IC_RecursiveProjectionItemsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::IC_RecursiveProjectionItemsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_RecursiveProjectionItemsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_ProjectionItemsContext* CypherParser::IC_RecursiveProjectionItemsContext::oC_ProjectionItems() {
return getRuleContext<CypherParser::OC_ProjectionItemsContext>(0);
}
size_t CypherParser::IC_RecursiveProjectionItemsContext::getRuleIndex() const {
return CypherParser::RuleIC_RecursiveProjectionItems;
}
CypherParser::IC_RecursiveProjectionItemsContext* CypherParser::iC_RecursiveProjectionItems() {
IC_RecursiveProjectionItemsContext *_localctx = _tracker.createInstance<IC_RecursiveProjectionItemsContext>(_ctx, getState());
enterRule(_localctx, 238, CypherParser::RuleIC_RecursiveProjectionItems);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2208);
match(CypherParser::T__8);
setState(2210);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 353, _ctx)) {
case 1: {
setState(2209);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(2213);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -286014905805559497) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5492412753616171) != 0)) {
setState(2212);
oC_ProjectionItems();
}
setState(2216);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2215);
match(CypherParser::SP);
}
setState(2218);
match(CypherParser::T__9);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_LowerBoundContext::OC_LowerBoundContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_LowerBoundContext::DecimalInteger() {
return getToken(CypherParser::DecimalInteger, 0);
}
size_t CypherParser::OC_LowerBoundContext::getRuleIndex() const {
return CypherParser::RuleOC_LowerBound;
}
CypherParser::OC_LowerBoundContext* CypherParser::oC_LowerBound() {
OC_LowerBoundContext *_localctx = _tracker.createInstance<OC_LowerBoundContext>(_ctx, getState());
enterRule(_localctx, 240, CypherParser::RuleOC_LowerBound);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2220);
match(CypherParser::DecimalInteger);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_UpperBoundContext::OC_UpperBoundContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_UpperBoundContext::DecimalInteger() {
return getToken(CypherParser::DecimalInteger, 0);
}
size_t CypherParser::OC_UpperBoundContext::getRuleIndex() const {
return CypherParser::RuleOC_UpperBound;
}
CypherParser::OC_UpperBoundContext* CypherParser::oC_UpperBound() {
OC_UpperBoundContext *_localctx = _tracker.createInstance<OC_UpperBoundContext>(_ctx, getState());
enterRule(_localctx, 242, CypherParser::RuleOC_UpperBound);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2222);
match(CypherParser::DecimalInteger);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_LabelNameContext::OC_LabelNameContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_SchemaNameContext *> CypherParser::OC_LabelNameContext::oC_SchemaName() {
return getRuleContexts<CypherParser::OC_SchemaNameContext>();
}
CypherParser::OC_SchemaNameContext* CypherParser::OC_LabelNameContext::oC_SchemaName(size_t i) {
return getRuleContext<CypherParser::OC_SchemaNameContext>(i);
}
size_t CypherParser::OC_LabelNameContext::getRuleIndex() const {
return CypherParser::RuleOC_LabelName;
}
CypherParser::OC_LabelNameContext* CypherParser::oC_LabelName() {
OC_LabelNameContext *_localctx = _tracker.createInstance<OC_LabelNameContext>(_ctx, getState());
enterRule(_localctx, 244, CypherParser::RuleOC_LabelName);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2224);
oC_SchemaName();
setState(2227);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::T__4) {
setState(2225);
match(CypherParser::T__4);
setState(2226);
oC_SchemaName();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RelTypeNameContext::OC_RelTypeNameContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SchemaNameContext* CypherParser::OC_RelTypeNameContext::oC_SchemaName() {
return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}
size_t CypherParser::OC_RelTypeNameContext::getRuleIndex() const {
return CypherParser::RuleOC_RelTypeName;
}
CypherParser::OC_RelTypeNameContext* CypherParser::oC_RelTypeName() {
OC_RelTypeNameContext *_localctx = _tracker.createInstance<OC_RelTypeNameContext>(_ctx, getState());
enterRule(_localctx, 246, CypherParser::RuleOC_RelTypeName);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2229);
oC_SchemaName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ExpressionContext::OC_ExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_OrExpressionContext* CypherParser::OC_ExpressionContext::oC_OrExpression() {
return getRuleContext<CypherParser::OC_OrExpressionContext>(0);
}
size_t CypherParser::OC_ExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_Expression;
}
CypherParser::OC_ExpressionContext* CypherParser::oC_Expression() {
OC_ExpressionContext *_localctx = _tracker.createInstance<OC_ExpressionContext>(_ctx, getState());
enterRule(_localctx, 248, CypherParser::RuleOC_Expression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2231);
oC_OrExpression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_OrExpressionContext::OC_OrExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_XorExpressionContext *> CypherParser::OC_OrExpressionContext::oC_XorExpression() {
return getRuleContexts<CypherParser::OC_XorExpressionContext>();
}
CypherParser::OC_XorExpressionContext* CypherParser::OC_OrExpressionContext::oC_XorExpression(size_t i) {
return getRuleContext<CypherParser::OC_XorExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_OrExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_OrExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_OrExpressionContext::OR() {
return getTokens(CypherParser::OR);
}
tree::TerminalNode* CypherParser::OC_OrExpressionContext::OR(size_t i) {
return getToken(CypherParser::OR, i);
}
size_t CypherParser::OC_OrExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_OrExpression;
}
CypherParser::OC_OrExpressionContext* CypherParser::oC_OrExpression() {
OC_OrExpressionContext *_localctx = _tracker.createInstance<OC_OrExpressionContext>(_ctx, getState());
enterRule(_localctx, 250, CypherParser::RuleOC_OrExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2233);
oC_XorExpression();
setState(2240);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 357, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2234);
match(CypherParser::SP);
setState(2235);
match(CypherParser::OR);
setState(2236);
match(CypherParser::SP);
setState(2237);
oC_XorExpression();
}
setState(2242);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 357, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_XorExpressionContext::OC_XorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_AndExpressionContext *> CypherParser::OC_XorExpressionContext::oC_AndExpression() {
return getRuleContexts<CypherParser::OC_AndExpressionContext>();
}
CypherParser::OC_AndExpressionContext* CypherParser::OC_XorExpressionContext::oC_AndExpression(size_t i) {
return getRuleContext<CypherParser::OC_AndExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_XorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_XorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_XorExpressionContext::XOR() {
return getTokens(CypherParser::XOR);
}
tree::TerminalNode* CypherParser::OC_XorExpressionContext::XOR(size_t i) {
return getToken(CypherParser::XOR, i);
}
size_t CypherParser::OC_XorExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_XorExpression;
}
CypherParser::OC_XorExpressionContext* CypherParser::oC_XorExpression() {
OC_XorExpressionContext *_localctx = _tracker.createInstance<OC_XorExpressionContext>(_ctx, getState());
enterRule(_localctx, 252, CypherParser::RuleOC_XorExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2243);
oC_AndExpression();
setState(2250);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 358, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2244);
match(CypherParser::SP);
setState(2245);
match(CypherParser::XOR);
setState(2246);
match(CypherParser::SP);
setState(2247);
oC_AndExpression();
}
setState(2252);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 358, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_AndExpressionContext::OC_AndExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_NotExpressionContext *> CypherParser::OC_AndExpressionContext::oC_NotExpression() {
return getRuleContexts<CypherParser::OC_NotExpressionContext>();
}
CypherParser::OC_NotExpressionContext* CypherParser::OC_AndExpressionContext::oC_NotExpression(size_t i) {
return getRuleContext<CypherParser::OC_NotExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_AndExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_AndExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_AndExpressionContext::AND() {
return getTokens(CypherParser::AND);
}
tree::TerminalNode* CypherParser::OC_AndExpressionContext::AND(size_t i) {
return getToken(CypherParser::AND, i);
}
size_t CypherParser::OC_AndExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_AndExpression;
}
CypherParser::OC_AndExpressionContext* CypherParser::oC_AndExpression() {
OC_AndExpressionContext *_localctx = _tracker.createInstance<OC_AndExpressionContext>(_ctx, getState());
enterRule(_localctx, 254, CypherParser::RuleOC_AndExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2253);
oC_NotExpression();
setState(2260);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 359, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2254);
match(CypherParser::SP);
setState(2255);
match(CypherParser::AND);
setState(2256);
match(CypherParser::SP);
setState(2257);
oC_NotExpression();
}
setState(2262);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 359, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_NotExpressionContext::OC_NotExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ComparisonExpressionContext* CypherParser::OC_NotExpressionContext::oC_ComparisonExpression() {
return getRuleContext<CypherParser::OC_ComparisonExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_NotExpressionContext::NOT() {
return getTokens(CypherParser::NOT);
}
tree::TerminalNode* CypherParser::OC_NotExpressionContext::NOT(size_t i) {
return getToken(CypherParser::NOT, i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_NotExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_NotExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_NotExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_NotExpression;
}
CypherParser::OC_NotExpressionContext* CypherParser::oC_NotExpression() {
OC_NotExpressionContext *_localctx = _tracker.createInstance<OC_NotExpressionContext>(_ctx, getState());
enterRule(_localctx, 256, CypherParser::RuleOC_NotExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2269);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::NOT) {
setState(2263);
match(CypherParser::NOT);
setState(2265);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2264);
match(CypherParser::SP);
}
setState(2271);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(2272);
oC_ComparisonExpression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ComparisonExpressionContext::OC_ComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_BitwiseOrOperatorExpressionContext *> CypherParser::OC_ComparisonExpressionContext::iC_BitwiseOrOperatorExpression() {
return getRuleContexts<CypherParser::IC_BitwiseOrOperatorExpressionContext>();
}
CypherParser::IC_BitwiseOrOperatorExpressionContext* CypherParser::OC_ComparisonExpressionContext::iC_BitwiseOrOperatorExpression(size_t i) {
return getRuleContext<CypherParser::IC_BitwiseOrOperatorExpressionContext>(i);
}
std::vector<CypherParser::IC_ComparisonOperatorContext *> CypherParser::OC_ComparisonExpressionContext::iC_ComparisonOperator() {
return getRuleContexts<CypherParser::IC_ComparisonOperatorContext>();
}
CypherParser::IC_ComparisonOperatorContext* CypherParser::OC_ComparisonExpressionContext::iC_ComparisonOperator(size_t i) {
return getRuleContext<CypherParser::IC_ComparisonOperatorContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_ComparisonExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ComparisonExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_ComparisonExpressionContext::INVALID_NOT_EQUAL() {
return getToken(CypherParser::INVALID_NOT_EQUAL, 0);
}
size_t CypherParser::OC_ComparisonExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_ComparisonExpression;
}
CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpression() {
OC_ComparisonExpressionContext *_localctx = _tracker.createInstance<OC_ComparisonExpressionContext>(_ctx, getState());
enterRule(_localctx, 258, CypherParser::RuleOC_ComparisonExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
setState(2322);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2274);
iC_BitwiseOrOperatorExpression();
setState(2284);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 364, _ctx)) {
case 1: {
setState(2276);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2275);
match(CypherParser::SP);
}
setState(2278);
iC_ComparisonOperator();
setState(2280);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2279);
match(CypherParser::SP);
}
setState(2282);
iC_BitwiseOrOperatorExpression();
break;
}
default:
break;
}
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2286);
iC_BitwiseOrOperatorExpression();
setState(2288);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2287);
match(CypherParser::SP);
}
setState(2290);
antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken = match(CypherParser::INVALID_NOT_EQUAL);
setState(2292);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2291);
match(CypherParser::SP);
}
setState(2294);
iC_BitwiseOrOperatorExpression();
notifyInvalidNotEqualOperator(antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(2298);
iC_BitwiseOrOperatorExpression();
setState(2300);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2299);
match(CypherParser::SP);
}
setState(2302);
iC_ComparisonOperator();
setState(2304);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2303);
match(CypherParser::SP);
}
setState(2306);
iC_BitwiseOrOperatorExpression();
setState(2316);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(2308);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2307);
match(CypherParser::SP);
}
setState(2310);
iC_ComparisonOperator();
setState(2312);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2311);
match(CypherParser::SP);
}
setState(2314);
iC_BitwiseOrOperatorExpression();
break;
}
default:
throw NoViableAltException(this);
}
setState(2318);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 371, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
notifyNonBinaryComparison(_localctx->start);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ComparisonOperatorContext::IC_ComparisonOperatorContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t CypherParser::IC_ComparisonOperatorContext::getRuleIndex() const {
return CypherParser::RuleIC_ComparisonOperator;
}
CypherParser::IC_ComparisonOperatorContext* CypherParser::iC_ComparisonOperator() {
IC_ComparisonOperatorContext *_localctx = _tracker.createInstance<IC_ComparisonOperatorContext>(_ctx, getState());
enterRule(_localctx, 260, CypherParser::RuleIC_ComparisonOperator);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2324);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 127040) != 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;
}
CypherParser::IC_BitwiseOrOperatorExpressionContext::IC_BitwiseOrOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_BitwiseAndOperatorExpressionContext *> CypherParser::IC_BitwiseOrOperatorExpressionContext::iC_BitwiseAndOperatorExpression() {
return getRuleContexts<CypherParser::IC_BitwiseAndOperatorExpressionContext>();
}
CypherParser::IC_BitwiseAndOperatorExpressionContext* CypherParser::IC_BitwiseOrOperatorExpressionContext::iC_BitwiseAndOperatorExpression(size_t i) {
return getRuleContext<CypherParser::IC_BitwiseAndOperatorExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_BitwiseOrOperatorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_BitwiseOrOperatorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_BitwiseOrOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleIC_BitwiseOrOperatorExpression;
}
CypherParser::IC_BitwiseOrOperatorExpressionContext* CypherParser::iC_BitwiseOrOperatorExpression() {
IC_BitwiseOrOperatorExpressionContext *_localctx = _tracker.createInstance<IC_BitwiseOrOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 262, CypherParser::RuleIC_BitwiseOrOperatorExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2326);
iC_BitwiseAndOperatorExpression();
setState(2337);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2328);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2327);
match(CypherParser::SP);
}
setState(2330);
match(CypherParser::T__10);
setState(2332);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2331);
match(CypherParser::SP);
}
setState(2334);
iC_BitwiseAndOperatorExpression();
}
setState(2339);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_BitwiseAndOperatorExpressionContext::IC_BitwiseAndOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_BitShiftOperatorExpressionContext *> CypherParser::IC_BitwiseAndOperatorExpressionContext::iC_BitShiftOperatorExpression() {
return getRuleContexts<CypherParser::IC_BitShiftOperatorExpressionContext>();
}
CypherParser::IC_BitShiftOperatorExpressionContext* CypherParser::IC_BitwiseAndOperatorExpressionContext::iC_BitShiftOperatorExpression(size_t i) {
return getRuleContext<CypherParser::IC_BitShiftOperatorExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_BitwiseAndOperatorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_BitwiseAndOperatorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_BitwiseAndOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleIC_BitwiseAndOperatorExpression;
}
CypherParser::IC_BitwiseAndOperatorExpressionContext* CypherParser::iC_BitwiseAndOperatorExpression() {
IC_BitwiseAndOperatorExpressionContext *_localctx = _tracker.createInstance<IC_BitwiseAndOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 264, CypherParser::RuleIC_BitwiseAndOperatorExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2340);
iC_BitShiftOperatorExpression();
setState(2351);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 378, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2342);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2341);
match(CypherParser::SP);
}
setState(2344);
match(CypherParser::T__16);
setState(2346);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2345);
match(CypherParser::SP);
}
setState(2348);
iC_BitShiftOperatorExpression();
}
setState(2353);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 378, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_BitShiftOperatorExpressionContext::IC_BitShiftOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_AddOrSubtractExpressionContext *> CypherParser::IC_BitShiftOperatorExpressionContext::oC_AddOrSubtractExpression() {
return getRuleContexts<CypherParser::OC_AddOrSubtractExpressionContext>();
}
CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::IC_BitShiftOperatorExpressionContext::oC_AddOrSubtractExpression(size_t i) {
return getRuleContext<CypherParser::OC_AddOrSubtractExpressionContext>(i);
}
std::vector<CypherParser::IC_BitShiftOperatorContext *> CypherParser::IC_BitShiftOperatorExpressionContext::iC_BitShiftOperator() {
return getRuleContexts<CypherParser::IC_BitShiftOperatorContext>();
}
CypherParser::IC_BitShiftOperatorContext* CypherParser::IC_BitShiftOperatorExpressionContext::iC_BitShiftOperator(size_t i) {
return getRuleContext<CypherParser::IC_BitShiftOperatorContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_BitShiftOperatorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_BitShiftOperatorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_BitShiftOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleIC_BitShiftOperatorExpression;
}
CypherParser::IC_BitShiftOperatorExpressionContext* CypherParser::iC_BitShiftOperatorExpression() {
IC_BitShiftOperatorExpressionContext *_localctx = _tracker.createInstance<IC_BitShiftOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 266, CypherParser::RuleIC_BitShiftOperatorExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2354);
oC_AddOrSubtractExpression();
setState(2366);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 381, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2356);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2355);
match(CypherParser::SP);
}
setState(2358);
iC_BitShiftOperator();
setState(2360);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2359);
match(CypherParser::SP);
}
setState(2362);
oC_AddOrSubtractExpression();
}
setState(2368);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 381, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_BitShiftOperatorContext::IC_BitShiftOperatorContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t CypherParser::IC_BitShiftOperatorContext::getRuleIndex() const {
return CypherParser::RuleIC_BitShiftOperator;
}
CypherParser::IC_BitShiftOperatorContext* CypherParser::iC_BitShiftOperator() {
IC_BitShiftOperatorContext *_localctx = _tracker.createInstance<IC_BitShiftOperatorContext>(_ctx, getState());
enterRule(_localctx, 268, CypherParser::RuleIC_BitShiftOperator);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2369);
_la = _input->LA(1);
if (!(_la == CypherParser::T__17
|| _la == CypherParser::T__18)) {
_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;
}
CypherParser::OC_AddOrSubtractExpressionContext::OC_AddOrSubtractExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_MultiplyDivideModuloExpressionContext *> CypherParser::OC_AddOrSubtractExpressionContext::oC_MultiplyDivideModuloExpression() {
return getRuleContexts<CypherParser::OC_MultiplyDivideModuloExpressionContext>();
}
CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::OC_AddOrSubtractExpressionContext::oC_MultiplyDivideModuloExpression(size_t i) {
return getRuleContext<CypherParser::OC_MultiplyDivideModuloExpressionContext>(i);
}
std::vector<CypherParser::IC_AddOrSubtractOperatorContext *> CypherParser::OC_AddOrSubtractExpressionContext::iC_AddOrSubtractOperator() {
return getRuleContexts<CypherParser::IC_AddOrSubtractOperatorContext>();
}
CypherParser::IC_AddOrSubtractOperatorContext* CypherParser::OC_AddOrSubtractExpressionContext::iC_AddOrSubtractOperator(size_t i) {
return getRuleContext<CypherParser::IC_AddOrSubtractOperatorContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_AddOrSubtractExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_AddOrSubtractExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_AddOrSubtractExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_AddOrSubtractExpression;
}
CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::oC_AddOrSubtractExpression() {
OC_AddOrSubtractExpressionContext *_localctx = _tracker.createInstance<OC_AddOrSubtractExpressionContext>(_ctx, getState());
enterRule(_localctx, 270, CypherParser::RuleOC_AddOrSubtractExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2371);
oC_MultiplyDivideModuloExpression();
setState(2383);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 384, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2373);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2372);
match(CypherParser::SP);
}
setState(2375);
iC_AddOrSubtractOperator();
setState(2377);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2376);
match(CypherParser::SP);
}
setState(2379);
oC_MultiplyDivideModuloExpression();
}
setState(2385);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 384, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_AddOrSubtractOperatorContext::IC_AddOrSubtractOperatorContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_AddOrSubtractOperatorContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
size_t CypherParser::IC_AddOrSubtractOperatorContext::getRuleIndex() const {
return CypherParser::RuleIC_AddOrSubtractOperator;
}
CypherParser::IC_AddOrSubtractOperatorContext* CypherParser::iC_AddOrSubtractOperator() {
IC_AddOrSubtractOperatorContext *_localctx = _tracker.createInstance<IC_AddOrSubtractOperatorContext>(_ctx, getState());
enterRule(_localctx, 272, CypherParser::RuleIC_AddOrSubtractOperator);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2386);
_la = _input->LA(1);
if (!(_la == CypherParser::T__19 || _la == CypherParser::MINUS)) {
_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;
}
CypherParser::OC_MultiplyDivideModuloExpressionContext::OC_MultiplyDivideModuloExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_PowerOfExpressionContext *> CypherParser::OC_MultiplyDivideModuloExpressionContext::oC_PowerOfExpression() {
return getRuleContexts<CypherParser::OC_PowerOfExpressionContext>();
}
CypherParser::OC_PowerOfExpressionContext* CypherParser::OC_MultiplyDivideModuloExpressionContext::oC_PowerOfExpression(size_t i) {
return getRuleContext<CypherParser::OC_PowerOfExpressionContext>(i);
}
std::vector<CypherParser::IC_MultiplyDivideModuloOperatorContext *> CypherParser::OC_MultiplyDivideModuloExpressionContext::iC_MultiplyDivideModuloOperator() {
return getRuleContexts<CypherParser::IC_MultiplyDivideModuloOperatorContext>();
}
CypherParser::IC_MultiplyDivideModuloOperatorContext* CypherParser::OC_MultiplyDivideModuloExpressionContext::iC_MultiplyDivideModuloOperator(size_t i) {
return getRuleContext<CypherParser::IC_MultiplyDivideModuloOperatorContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_MultiplyDivideModuloExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_MultiplyDivideModuloExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_MultiplyDivideModuloExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_MultiplyDivideModuloExpression;
}
CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::oC_MultiplyDivideModuloExpression() {
OC_MultiplyDivideModuloExpressionContext *_localctx = _tracker.createInstance<OC_MultiplyDivideModuloExpressionContext>(_ctx, getState());
enterRule(_localctx, 274, CypherParser::RuleOC_MultiplyDivideModuloExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2388);
oC_PowerOfExpression();
setState(2400);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 387, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2390);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2389);
match(CypherParser::SP);
}
setState(2392);
iC_MultiplyDivideModuloOperator();
setState(2394);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2393);
match(CypherParser::SP);
}
setState(2396);
oC_PowerOfExpression();
}
setState(2402);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 387, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_MultiplyDivideModuloOperatorContext::IC_MultiplyDivideModuloOperatorContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_MultiplyDivideModuloOperatorContext::STAR() {
return getToken(CypherParser::STAR, 0);
}
size_t CypherParser::IC_MultiplyDivideModuloOperatorContext::getRuleIndex() const {
return CypherParser::RuleIC_MultiplyDivideModuloOperator;
}
CypherParser::IC_MultiplyDivideModuloOperatorContext* CypherParser::iC_MultiplyDivideModuloOperator() {
IC_MultiplyDivideModuloOperatorContext *_localctx = _tracker.createInstance<IC_MultiplyDivideModuloOperatorContext>(_ctx, getState());
enterRule(_localctx, 276, CypherParser::RuleIC_MultiplyDivideModuloOperator);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2403);
_la = _input->LA(1);
if (!(_la == CypherParser::T__20
|| _la == CypherParser::T__21 || _la == CypherParser::STAR)) {
_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;
}
CypherParser::OC_PowerOfExpressionContext::OC_PowerOfExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_StringListNullOperatorExpressionContext *> CypherParser::OC_PowerOfExpressionContext::oC_StringListNullOperatorExpression() {
return getRuleContexts<CypherParser::OC_StringListNullOperatorExpressionContext>();
}
CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::OC_PowerOfExpressionContext::oC_StringListNullOperatorExpression(size_t i) {
return getRuleContext<CypherParser::OC_StringListNullOperatorExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_PowerOfExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_PowerOfExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_PowerOfExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_PowerOfExpression;
}
CypherParser::OC_PowerOfExpressionContext* CypherParser::oC_PowerOfExpression() {
OC_PowerOfExpressionContext *_localctx = _tracker.createInstance<OC_PowerOfExpressionContext>(_ctx, getState());
enterRule(_localctx, 278, CypherParser::RuleOC_PowerOfExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2405);
oC_StringListNullOperatorExpression();
setState(2416);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 390, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2407);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2406);
match(CypherParser::SP);
}
setState(2409);
match(CypherParser::T__22);
setState(2411);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2410);
match(CypherParser::SP);
}
setState(2413);
oC_StringListNullOperatorExpression();
}
setState(2418);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 390, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_StringListNullOperatorExpressionContext::OC_StringListNullOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_UnaryAddSubtractOrFactorialExpression() {
return getRuleContext<CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext>(0);
}
CypherParser::OC_StringOperatorExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_StringOperatorExpression() {
return getRuleContext<CypherParser::OC_StringOperatorExpressionContext>(0);
}
CypherParser::OC_NullOperatorExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_NullOperatorExpression() {
return getRuleContext<CypherParser::OC_NullOperatorExpressionContext>(0);
}
std::vector<CypherParser::OC_ListOperatorExpressionContext *> CypherParser::OC_StringListNullOperatorExpressionContext::oC_ListOperatorExpression() {
return getRuleContexts<CypherParser::OC_ListOperatorExpressionContext>();
}
CypherParser::OC_ListOperatorExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_ListOperatorExpression(size_t i) {
return getRuleContext<CypherParser::OC_ListOperatorExpressionContext>(i);
}
size_t CypherParser::OC_StringListNullOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_StringListNullOperatorExpression;
}
CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_StringListNullOperatorExpression() {
OC_StringListNullOperatorExpressionContext *_localctx = _tracker.createInstance<OC_StringListNullOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 280, CypherParser::RuleOC_StringListNullOperatorExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2419);
oC_UnaryAddSubtractOrFactorialExpression();
setState(2427);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 392, _ctx)) {
case 1: {
setState(2420);
oC_StringOperatorExpression();
break;
}
case 2: {
setState(2422);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(2421);
oC_ListOperatorExpression();
break;
}
default:
throw NoViableAltException(this);
}
setState(2424);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 391, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
break;
}
case 3: {
setState(2426);
oC_NullOperatorExpression();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ListOperatorExpressionContext::OC_ListOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_ListOperatorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ListOperatorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_ListOperatorExpressionContext::IN() {
return getToken(CypherParser::IN, 0);
}
CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::OC_ListOperatorExpressionContext::oC_PropertyOrLabelsExpression() {
return getRuleContext<CypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}
std::vector<CypherParser::OC_ExpressionContext *> CypherParser::OC_ListOperatorExpressionContext::oC_Expression() {
return getRuleContexts<CypherParser::OC_ExpressionContext>();
}
CypherParser::OC_ExpressionContext* CypherParser::OC_ListOperatorExpressionContext::oC_Expression(size_t i) {
return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}
tree::TerminalNode* CypherParser::OC_ListOperatorExpressionContext::COLON() {
return getToken(CypherParser::COLON, 0);
}
tree::TerminalNode* CypherParser::OC_ListOperatorExpressionContext::DOTDOT() {
return getToken(CypherParser::DOTDOT, 0);
}
size_t CypherParser::OC_ListOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_ListOperatorExpression;
}
CypherParser::OC_ListOperatorExpressionContext* CypherParser::oC_ListOperatorExpression() {
OC_ListOperatorExpressionContext *_localctx = _tracker.createInstance<OC_ListOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 282, CypherParser::RuleOC_ListOperatorExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2448);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 396, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2429);
match(CypherParser::SP);
setState(2430);
match(CypherParser::IN);
setState(2432);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2431);
match(CypherParser::SP);
}
setState(2434);
oC_PropertyOrLabelsExpression();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2435);
match(CypherParser::T__6);
setState(2436);
oC_Expression();
setState(2437);
match(CypherParser::T__7);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(2439);
match(CypherParser::T__6);
setState(2441);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -286014905805559497) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5492410606132523) != 0)) {
setState(2440);
oC_Expression();
}
setState(2443);
_la = _input->LA(1);
if (!(_la == CypherParser::COLON
|| _la == CypherParser::DOTDOT)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(2445);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -286014905805559497) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5492410606132523) != 0)) {
setState(2444);
oC_Expression();
}
setState(2447);
match(CypherParser::T__7);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_StringOperatorExpressionContext::OC_StringOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::OC_StringOperatorExpressionContext::oC_PropertyOrLabelsExpression() {
return getRuleContext<CypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}
CypherParser::OC_RegularExpressionContext* CypherParser::OC_StringOperatorExpressionContext::oC_RegularExpression() {
return getRuleContext<CypherParser::OC_RegularExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_StringOperatorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_StringOperatorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_StringOperatorExpressionContext::STARTS() {
return getToken(CypherParser::STARTS, 0);
}
tree::TerminalNode* CypherParser::OC_StringOperatorExpressionContext::WITH() {
return getToken(CypherParser::WITH, 0);
}
tree::TerminalNode* CypherParser::OC_StringOperatorExpressionContext::ENDS() {
return getToken(CypherParser::ENDS, 0);
}
tree::TerminalNode* CypherParser::OC_StringOperatorExpressionContext::CONTAINS() {
return getToken(CypherParser::CONTAINS, 0);
}
size_t CypherParser::OC_StringOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_StringOperatorExpression;
}
CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperatorExpression() {
OC_StringOperatorExpressionContext *_localctx = _tracker.createInstance<OC_StringOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 284, CypherParser::RuleOC_StringOperatorExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2461);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 397, _ctx)) {
case 1: {
setState(2450);
oC_RegularExpression();
break;
}
case 2: {
setState(2451);
match(CypherParser::SP);
setState(2452);
match(CypherParser::STARTS);
setState(2453);
match(CypherParser::SP);
setState(2454);
match(CypherParser::WITH);
break;
}
case 3: {
setState(2455);
match(CypherParser::SP);
setState(2456);
match(CypherParser::ENDS);
setState(2457);
match(CypherParser::SP);
setState(2458);
match(CypherParser::WITH);
break;
}
case 4: {
setState(2459);
match(CypherParser::SP);
setState(2460);
match(CypherParser::CONTAINS);
break;
}
default:
break;
}
setState(2464);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2463);
match(CypherParser::SP);
}
setState(2466);
oC_PropertyOrLabelsExpression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_RegularExpressionContext::OC_RegularExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_RegularExpressionContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_RegularExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_RegularExpression;
}
CypherParser::OC_RegularExpressionContext* CypherParser::oC_RegularExpression() {
OC_RegularExpressionContext *_localctx = _tracker.createInstance<OC_RegularExpressionContext>(_ctx, getState());
enterRule(_localctx, 286, CypherParser::RuleOC_RegularExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2469);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2468);
match(CypherParser::SP);
}
setState(2471);
match(CypherParser::T__23);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_NullOperatorExpressionContext::OC_NullOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_NullOperatorExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_NullOperatorExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_NullOperatorExpressionContext::IS() {
return getToken(CypherParser::IS, 0);
}
tree::TerminalNode* CypherParser::OC_NullOperatorExpressionContext::NULL_() {
return getToken(CypherParser::NULL_, 0);
}
tree::TerminalNode* CypherParser::OC_NullOperatorExpressionContext::NOT() {
return getToken(CypherParser::NOT, 0);
}
size_t CypherParser::OC_NullOperatorExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_NullOperatorExpression;
}
CypherParser::OC_NullOperatorExpressionContext* CypherParser::oC_NullOperatorExpression() {
OC_NullOperatorExpressionContext *_localctx = _tracker.createInstance<OC_NullOperatorExpressionContext>(_ctx, getState());
enterRule(_localctx, 288, CypherParser::RuleOC_NullOperatorExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2483);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2473);
match(CypherParser::SP);
setState(2474);
match(CypherParser::IS);
setState(2475);
match(CypherParser::SP);
setState(2476);
match(CypherParser::NULL_);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2477);
match(CypherParser::SP);
setState(2478);
match(CypherParser::IS);
setState(2479);
match(CypherParser::SP);
setState(2480);
match(CypherParser::NOT);
setState(2481);
match(CypherParser::SP);
setState(2482);
match(CypherParser::NULL_);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::OC_UnaryAddSubtractOrFactorialExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::oC_PropertyOrLabelsExpression() {
return getRuleContext<CypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::MINUS() {
return getTokens(CypherParser::MINUS);
}
tree::TerminalNode* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::MINUS(size_t i) {
return getToken(CypherParser::MINUS, i);
}
tree::TerminalNode* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::FACTORIAL() {
return getToken(CypherParser::FACTORIAL, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression;
}
CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::oC_UnaryAddSubtractOrFactorialExpression() {
OC_UnaryAddSubtractOrFactorialExpressionContext *_localctx = _tracker.createInstance<OC_UnaryAddSubtractOrFactorialExpressionContext>(_ctx, getState());
enterRule(_localctx, 290, CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2491);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::MINUS) {
setState(2485);
match(CypherParser::MINUS);
setState(2487);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2486);
match(CypherParser::SP);
}
setState(2493);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(2494);
oC_PropertyOrLabelsExpression();
setState(2499);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 404, _ctx)) {
case 1: {
setState(2496);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2495);
match(CypherParser::SP);
}
setState(2498);
match(CypherParser::FACTORIAL);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PropertyOrLabelsExpressionContext::OC_PropertyOrLabelsExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_AtomContext* CypherParser::OC_PropertyOrLabelsExpressionContext::oC_Atom() {
return getRuleContext<CypherParser::OC_AtomContext>(0);
}
std::vector<CypherParser::OC_PropertyLookupContext *> CypherParser::OC_PropertyOrLabelsExpressionContext::oC_PropertyLookup() {
return getRuleContexts<CypherParser::OC_PropertyLookupContext>();
}
CypherParser::OC_PropertyLookupContext* CypherParser::OC_PropertyOrLabelsExpressionContext::oC_PropertyLookup(size_t i) {
return getRuleContext<CypherParser::OC_PropertyLookupContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_PropertyOrLabelsExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_PropertyOrLabelsExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_PropertyOrLabelsExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_PropertyOrLabelsExpression;
}
CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::oC_PropertyOrLabelsExpression() {
OC_PropertyOrLabelsExpressionContext *_localctx = _tracker.createInstance<OC_PropertyOrLabelsExpressionContext>(_ctx, getState());
enterRule(_localctx, 292, CypherParser::RuleOC_PropertyOrLabelsExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2501);
oC_Atom();
setState(2508);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx);
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
if (alt == 1) {
setState(2503);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2502);
match(CypherParser::SP);
}
setState(2505);
oC_PropertyLookup();
}
setState(2510);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_AtomContext::OC_AtomContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_LiteralContext* CypherParser::OC_AtomContext::oC_Literal() {
return getRuleContext<CypherParser::OC_LiteralContext>(0);
}
CypherParser::OC_ParameterContext* CypherParser::OC_AtomContext::oC_Parameter() {
return getRuleContext<CypherParser::OC_ParameterContext>(0);
}
CypherParser::OC_CaseExpressionContext* CypherParser::OC_AtomContext::oC_CaseExpression() {
return getRuleContext<CypherParser::OC_CaseExpressionContext>(0);
}
CypherParser::OC_ParenthesizedExpressionContext* CypherParser::OC_AtomContext::oC_ParenthesizedExpression() {
return getRuleContext<CypherParser::OC_ParenthesizedExpressionContext>(0);
}
CypherParser::OC_FunctionInvocationContext* CypherParser::OC_AtomContext::oC_FunctionInvocation() {
return getRuleContext<CypherParser::OC_FunctionInvocationContext>(0);
}
CypherParser::OC_PathPatternsContext* CypherParser::OC_AtomContext::oC_PathPatterns() {
return getRuleContext<CypherParser::OC_PathPatternsContext>(0);
}
CypherParser::OC_ExistCountSubqueryContext* CypherParser::OC_AtomContext::oC_ExistCountSubquery() {
return getRuleContext<CypherParser::OC_ExistCountSubqueryContext>(0);
}
CypherParser::OC_VariableContext* CypherParser::OC_AtomContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
CypherParser::OC_QuantifierContext* CypherParser::OC_AtomContext::oC_Quantifier() {
return getRuleContext<CypherParser::OC_QuantifierContext>(0);
}
size_t CypherParser::OC_AtomContext::getRuleIndex() const {
return CypherParser::RuleOC_Atom;
}
CypherParser::OC_AtomContext* CypherParser::oC_Atom() {
OC_AtomContext *_localctx = _tracker.createInstance<OC_AtomContext>(_ctx, getState());
enterRule(_localctx, 294, CypherParser::RuleOC_Atom);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2520);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 407, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2511);
oC_Literal();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2512);
oC_Parameter();
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(2513);
oC_CaseExpression();
break;
}
case 4: {
enterOuterAlt(_localctx, 4);
setState(2514);
oC_ParenthesizedExpression();
break;
}
case 5: {
enterOuterAlt(_localctx, 5);
setState(2515);
oC_FunctionInvocation();
break;
}
case 6: {
enterOuterAlt(_localctx, 6);
setState(2516);
oC_PathPatterns();
break;
}
case 7: {
enterOuterAlt(_localctx, 7);
setState(2517);
oC_ExistCountSubquery();
break;
}
case 8: {
enterOuterAlt(_localctx, 8);
setState(2518);
oC_Variable();
break;
}
case 9: {
enterOuterAlt(_localctx, 9);
setState(2519);
oC_Quantifier();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_QuantifierContext::OC_QuantifierContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_QuantifierContext::ALL() {
return getToken(CypherParser::ALL, 0);
}
CypherParser::OC_FilterExpressionContext* CypherParser::OC_QuantifierContext::oC_FilterExpression() {
return getRuleContext<CypherParser::OC_FilterExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_QuantifierContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_QuantifierContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_QuantifierContext::ANY() {
return getToken(CypherParser::ANY, 0);
}
tree::TerminalNode* CypherParser::OC_QuantifierContext::NONE() {
return getToken(CypherParser::NONE, 0);
}
tree::TerminalNode* CypherParser::OC_QuantifierContext::SINGLE() {
return getToken(CypherParser::SINGLE, 0);
}
size_t CypherParser::OC_QuantifierContext::getRuleIndex() const {
return CypherParser::RuleOC_Quantifier;
}
CypherParser::OC_QuantifierContext* CypherParser::oC_Quantifier() {
OC_QuantifierContext *_localctx = _tracker.createInstance<OC_QuantifierContext>(_ctx, getState());
enterRule(_localctx, 296, CypherParser::RuleOC_Quantifier);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2578);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ALL: {
enterOuterAlt(_localctx, 1);
setState(2522);
match(CypherParser::ALL);
setState(2524);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2523);
match(CypherParser::SP);
}
setState(2526);
match(CypherParser::T__1);
setState(2528);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2527);
match(CypherParser::SP);
}
setState(2530);
oC_FilterExpression();
setState(2532);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2531);
match(CypherParser::SP);
}
setState(2534);
match(CypherParser::T__2);
break;
}
case CypherParser::ANY: {
enterOuterAlt(_localctx, 2);
setState(2536);
match(CypherParser::ANY);
setState(2538);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2537);
match(CypherParser::SP);
}
setState(2540);
match(CypherParser::T__1);
setState(2542);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2541);
match(CypherParser::SP);
}
setState(2544);
oC_FilterExpression();
setState(2546);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2545);
match(CypherParser::SP);
}
setState(2548);
match(CypherParser::T__2);
break;
}
case CypherParser::NONE: {
enterOuterAlt(_localctx, 3);
setState(2550);
match(CypherParser::NONE);
setState(2552);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2551);
match(CypherParser::SP);
}
setState(2554);
match(CypherParser::T__1);
setState(2556);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2555);
match(CypherParser::SP);
}
setState(2558);
oC_FilterExpression();
setState(2560);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2559);
match(CypherParser::SP);
}
setState(2562);
match(CypherParser::T__2);
break;
}
case CypherParser::SINGLE: {
enterOuterAlt(_localctx, 4);
setState(2564);
match(CypherParser::SINGLE);
setState(2566);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2565);
match(CypherParser::SP);
}
setState(2568);
match(CypherParser::T__1);
setState(2570);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2569);
match(CypherParser::SP);
}
setState(2572);
oC_FilterExpression();
setState(2574);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2573);
match(CypherParser::SP);
}
setState(2576);
match(CypherParser::T__2);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_FilterExpressionContext::OC_FilterExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_IdInCollContext* CypherParser::OC_FilterExpressionContext::oC_IdInColl() {
return getRuleContext<CypherParser::OC_IdInCollContext>(0);
}
tree::TerminalNode* CypherParser::OC_FilterExpressionContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_WhereContext* CypherParser::OC_FilterExpressionContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
size_t CypherParser::OC_FilterExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_FilterExpression;
}
CypherParser::OC_FilterExpressionContext* CypherParser::oC_FilterExpression() {
OC_FilterExpressionContext *_localctx = _tracker.createInstance<OC_FilterExpressionContext>(_ctx, getState());
enterRule(_localctx, 298, CypherParser::RuleOC_FilterExpression);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2580);
oC_IdInColl();
setState(2581);
match(CypherParser::SP);
setState(2582);
oC_Where();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_IdInCollContext::OC_IdInCollContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_VariableContext* CypherParser::OC_IdInCollContext::oC_Variable() {
return getRuleContext<CypherParser::OC_VariableContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_IdInCollContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_IdInCollContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_IdInCollContext::IN() {
return getToken(CypherParser::IN, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_IdInCollContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
size_t CypherParser::OC_IdInCollContext::getRuleIndex() const {
return CypherParser::RuleOC_IdInColl;
}
CypherParser::OC_IdInCollContext* CypherParser::oC_IdInColl() {
OC_IdInCollContext *_localctx = _tracker.createInstance<OC_IdInCollContext>(_ctx, getState());
enterRule(_localctx, 300, CypherParser::RuleOC_IdInColl);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2584);
oC_Variable();
setState(2585);
match(CypherParser::SP);
setState(2586);
match(CypherParser::IN);
setState(2587);
match(CypherParser::SP);
setState(2588);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_LiteralContext::OC_LiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_NumberLiteralContext* CypherParser::OC_LiteralContext::oC_NumberLiteral() {
return getRuleContext<CypherParser::OC_NumberLiteralContext>(0);
}
tree::TerminalNode* CypherParser::OC_LiteralContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
CypherParser::OC_BooleanLiteralContext* CypherParser::OC_LiteralContext::oC_BooleanLiteral() {
return getRuleContext<CypherParser::OC_BooleanLiteralContext>(0);
}
tree::TerminalNode* CypherParser::OC_LiteralContext::NULL_() {
return getToken(CypherParser::NULL_, 0);
}
CypherParser::OC_ListLiteralContext* CypherParser::OC_LiteralContext::oC_ListLiteral() {
return getRuleContext<CypherParser::OC_ListLiteralContext>(0);
}
CypherParser::IC_StructLiteralContext* CypherParser::OC_LiteralContext::iC_StructLiteral() {
return getRuleContext<CypherParser::IC_StructLiteralContext>(0);
}
size_t CypherParser::OC_LiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_Literal;
}
CypherParser::OC_LiteralContext* CypherParser::oC_Literal() {
OC_LiteralContext *_localctx = _tracker.createInstance<OC_LiteralContext>(_ctx, getState());
enterRule(_localctx, 302, CypherParser::RuleOC_Literal);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2596);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::DecimalInteger:
case CypherParser::ExponentDecimalReal:
case CypherParser::RegularDecimalReal: {
enterOuterAlt(_localctx, 1);
setState(2590);
oC_NumberLiteral();
break;
}
case CypherParser::StringLiteral: {
enterOuterAlt(_localctx, 2);
setState(2591);
match(CypherParser::StringLiteral);
break;
}
case CypherParser::FALSE:
case CypherParser::TRUE: {
enterOuterAlt(_localctx, 3);
setState(2592);
oC_BooleanLiteral();
break;
}
case CypherParser::NULL_: {
enterOuterAlt(_localctx, 4);
setState(2593);
match(CypherParser::NULL_);
break;
}
case CypherParser::T__6: {
enterOuterAlt(_localctx, 5);
setState(2594);
oC_ListLiteral();
break;
}
case CypherParser::T__8: {
enterOuterAlt(_localctx, 6);
setState(2595);
iC_StructLiteral();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_BooleanLiteralContext::OC_BooleanLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_BooleanLiteralContext::TRUE() {
return getToken(CypherParser::TRUE, 0);
}
tree::TerminalNode* CypherParser::OC_BooleanLiteralContext::FALSE() {
return getToken(CypherParser::FALSE, 0);
}
size_t CypherParser::OC_BooleanLiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_BooleanLiteral;
}
CypherParser::OC_BooleanLiteralContext* CypherParser::oC_BooleanLiteral() {
OC_BooleanLiteralContext *_localctx = _tracker.createInstance<OC_BooleanLiteralContext>(_ctx, getState());
enterRule(_localctx, 304, CypherParser::RuleOC_BooleanLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2598);
_la = _input->LA(1);
if (!(_la == CypherParser::FALSE
|| _la == CypherParser::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;
}
CypherParser::OC_ListLiteralContext::OC_ListLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<tree::TerminalNode *> CypherParser::OC_ListLiteralContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ListLiteralContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_ExpressionContext* CypherParser::OC_ListLiteralContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
std::vector<CypherParser::IC_ListEntryContext *> CypherParser::OC_ListLiteralContext::iC_ListEntry() {
return getRuleContexts<CypherParser::IC_ListEntryContext>();
}
CypherParser::IC_ListEntryContext* CypherParser::OC_ListLiteralContext::iC_ListEntry(size_t i) {
return getRuleContext<CypherParser::IC_ListEntryContext>(i);
}
size_t CypherParser::OC_ListLiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_ListLiteral;
}
CypherParser::OC_ListLiteralContext* CypherParser::oC_ListLiteral() {
OC_ListLiteralContext *_localctx = _tracker.createInstance<OC_ListLiteralContext>(_ctx, getState());
enterRule(_localctx, 306, CypherParser::RuleOC_ListLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2600);
match(CypherParser::T__6);
setState(2602);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2601);
match(CypherParser::SP);
}
setState(2617);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -286014905805559497) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5492410606132523) != 0)) {
setState(2604);
oC_Expression();
setState(2606);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2605);
match(CypherParser::SP);
}
setState(2614);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3) {
setState(2608);
iC_ListEntry();
setState(2610);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2609);
match(CypherParser::SP);
}
setState(2616);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
setState(2619);
match(CypherParser::T__7);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_ListEntryContext::IC_ListEntryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_ListEntryContext::SP() {
return getToken(CypherParser::SP, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::IC_ListEntryContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
size_t CypherParser::IC_ListEntryContext::getRuleIndex() const {
return CypherParser::RuleIC_ListEntry;
}
CypherParser::IC_ListEntryContext* CypherParser::iC_ListEntry() {
IC_ListEntryContext *_localctx = _tracker.createInstance<IC_ListEntryContext>(_ctx, getState());
enterRule(_localctx, 308, CypherParser::RuleIC_ListEntry);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2621);
match(CypherParser::T__3);
setState(2623);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 427, _ctx)) {
case 1: {
setState(2622);
match(CypherParser::SP);
break;
}
default:
break;
}
setState(2626);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -286014905805559497) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5492410606132523) != 0)) {
setState(2625);
oC_Expression();
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_StructLiteralContext::IC_StructLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::IC_StructFieldContext *> CypherParser::IC_StructLiteralContext::iC_StructField() {
return getRuleContexts<CypherParser::IC_StructFieldContext>();
}
CypherParser::IC_StructFieldContext* CypherParser::IC_StructLiteralContext::iC_StructField(size_t i) {
return getRuleContext<CypherParser::IC_StructFieldContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_StructLiteralContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_StructLiteralContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_StructLiteralContext::getRuleIndex() const {
return CypherParser::RuleIC_StructLiteral;
}
CypherParser::IC_StructLiteralContext* CypherParser::iC_StructLiteral() {
IC_StructLiteralContext *_localctx = _tracker.createInstance<IC_StructLiteralContext>(_ctx, getState());
enterRule(_localctx, 310, CypherParser::RuleIC_StructLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2628);
match(CypherParser::T__8);
setState(2630);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2629);
match(CypherParser::SP);
}
setState(2632);
iC_StructField();
setState(2634);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2633);
match(CypherParser::SP);
}
setState(2646);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3) {
setState(2636);
match(CypherParser::T__3);
setState(2638);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2637);
match(CypherParser::SP);
}
setState(2640);
iC_StructField();
setState(2642);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2641);
match(CypherParser::SP);
}
setState(2648);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(2649);
match(CypherParser::T__9);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_StructFieldContext::IC_StructFieldContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_StructFieldContext::COLON() {
return getToken(CypherParser::COLON, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::IC_StructFieldContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_StructFieldContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_StructFieldContext::StringLiteral() {
return getToken(CypherParser::StringLiteral, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_StructFieldContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_StructFieldContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_StructFieldContext::getRuleIndex() const {
return CypherParser::RuleIC_StructField;
}
CypherParser::IC_StructFieldContext* CypherParser::iC_StructField() {
IC_StructFieldContext *_localctx = _tracker.createInstance<IC_StructFieldContext>(_ctx, getState());
enterRule(_localctx, 312, CypherParser::RuleIC_StructField);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2653);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
setState(2651);
oC_SymbolicName();
break;
}
case CypherParser::StringLiteral: {
setState(2652);
match(CypherParser::StringLiteral);
break;
}
default:
throw NoViableAltException(this);
}
setState(2656);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2655);
match(CypherParser::SP);
}
setState(2658);
match(CypherParser::COLON);
setState(2660);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2659);
match(CypherParser::SP);
}
setState(2662);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ParenthesizedExpressionContext::OC_ParenthesizedExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ExpressionContext* CypherParser::OC_ParenthesizedExpressionContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_ParenthesizedExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ParenthesizedExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_ParenthesizedExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_ParenthesizedExpression;
}
CypherParser::OC_ParenthesizedExpressionContext* CypherParser::oC_ParenthesizedExpression() {
OC_ParenthesizedExpressionContext *_localctx = _tracker.createInstance<OC_ParenthesizedExpressionContext>(_ctx, getState());
enterRule(_localctx, 314, CypherParser::RuleOC_ParenthesizedExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2664);
match(CypherParser::T__1);
setState(2666);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2665);
match(CypherParser::SP);
}
setState(2668);
oC_Expression();
setState(2670);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2669);
match(CypherParser::SP);
}
setState(2672);
match(CypherParser::T__2);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_FunctionInvocationContext::OC_FunctionInvocationContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::COUNT() {
return getToken(CypherParser::COUNT, 0);
}
tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::STAR() {
return getToken(CypherParser::STAR, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_FunctionInvocationContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::CAST() {
return getToken(CypherParser::CAST, 0);
}
std::vector<CypherParser::IC_FunctionParameterContext *> CypherParser::OC_FunctionInvocationContext::iC_FunctionParameter() {
return getRuleContexts<CypherParser::IC_FunctionParameterContext>();
}
CypherParser::IC_FunctionParameterContext* CypherParser::OC_FunctionInvocationContext::iC_FunctionParameter(size_t i) {
return getRuleContext<CypherParser::IC_FunctionParameterContext>(i);
}
tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::AS() {
return getToken(CypherParser::AS, 0);
}
CypherParser::IC_DataTypeContext* CypherParser::OC_FunctionInvocationContext::iC_DataType() {
return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}
CypherParser::OC_FunctionNameContext* CypherParser::OC_FunctionInvocationContext::oC_FunctionName() {
return getRuleContext<CypherParser::OC_FunctionNameContext>(0);
}
tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::DISTINCT() {
return getToken(CypherParser::DISTINCT, 0);
}
size_t CypherParser::OC_FunctionInvocationContext::getRuleIndex() const {
return CypherParser::RuleOC_FunctionInvocation;
}
CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation() {
OC_FunctionInvocationContext *_localctx = _tracker.createInstance<OC_FunctionInvocationContext>(_ctx, getState());
enterRule(_localctx, 316, CypherParser::RuleOC_FunctionInvocation);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2751);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 458, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2674);
match(CypherParser::COUNT);
setState(2676);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2675);
match(CypherParser::SP);
}
setState(2678);
match(CypherParser::T__1);
setState(2680);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2679);
match(CypherParser::SP);
}
setState(2682);
match(CypherParser::STAR);
setState(2684);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2683);
match(CypherParser::SP);
}
setState(2686);
match(CypherParser::T__2);
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2687);
match(CypherParser::CAST);
setState(2689);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2688);
match(CypherParser::SP);
}
setState(2691);
match(CypherParser::T__1);
setState(2693);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2692);
match(CypherParser::SP);
}
setState(2695);
iC_FunctionParameter();
setState(2697);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2696);
match(CypherParser::SP);
}
setState(2709);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::AS: {
setState(2699);
match(CypherParser::AS);
setState(2701);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2700);
match(CypherParser::SP);
}
setState(2703);
iC_DataType(0);
break;
}
case CypherParser::T__3: {
setState(2704);
match(CypherParser::T__3);
setState(2706);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2705);
match(CypherParser::SP);
}
setState(2708);
iC_FunctionParameter();
break;
}
default:
throw NoViableAltException(this);
}
setState(2712);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2711);
match(CypherParser::SP);
}
setState(2714);
match(CypherParser::T__2);
break;
}
case 3: {
enterOuterAlt(_localctx, 3);
setState(2716);
oC_FunctionName();
setState(2718);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2717);
match(CypherParser::SP);
}
setState(2720);
match(CypherParser::T__1);
setState(2722);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2721);
match(CypherParser::SP);
}
setState(2728);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::DISTINCT) {
setState(2724);
match(CypherParser::DISTINCT);
setState(2726);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2725);
match(CypherParser::SP);
}
}
setState(2747);
_errHandler->sync(this);
_la = _input->LA(1);
if ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 65)) & -286014905805559497) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 130)) & 5492410606132523) != 0)) {
setState(2730);
iC_FunctionParameter();
setState(2732);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2731);
match(CypherParser::SP);
}
setState(2744);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3) {
setState(2734);
match(CypherParser::T__3);
setState(2736);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2735);
match(CypherParser::SP);
}
setState(2738);
iC_FunctionParameter();
setState(2740);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2739);
match(CypherParser::SP);
}
setState(2746);
_errHandler->sync(this);
_la = _input->LA(1);
}
}
setState(2749);
match(CypherParser::T__2);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_FunctionNameContext::OC_FunctionNameContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::OC_FunctionNameContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
size_t CypherParser::OC_FunctionNameContext::getRuleIndex() const {
return CypherParser::RuleOC_FunctionName;
}
CypherParser::OC_FunctionNameContext* CypherParser::oC_FunctionName() {
OC_FunctionNameContext *_localctx = _tracker.createInstance<OC_FunctionNameContext>(_ctx, getState());
enterRule(_localctx, 318, CypherParser::RuleOC_FunctionName);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2753);
oC_SymbolicName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_FunctionParameterContext::IC_FunctionParameterContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_ExpressionContext* CypherParser::IC_FunctionParameterContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_FunctionParameterContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
tree::TerminalNode* CypherParser::IC_FunctionParameterContext::COLON() {
return getToken(CypherParser::COLON, 0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_FunctionParameterContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_FunctionParameterContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::IC_LambdaParameterContext* CypherParser::IC_FunctionParameterContext::iC_LambdaParameter() {
return getRuleContext<CypherParser::IC_LambdaParameterContext>(0);
}
size_t CypherParser::IC_FunctionParameterContext::getRuleIndex() const {
return CypherParser::RuleIC_FunctionParameter;
}
CypherParser::IC_FunctionParameterContext* CypherParser::iC_FunctionParameter() {
IC_FunctionParameterContext *_localctx = _tracker.createInstance<IC_FunctionParameterContext>(_ctx, getState());
enterRule(_localctx, 320, CypherParser::RuleIC_FunctionParameter);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2768);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 462, _ctx)) {
case 1: {
enterOuterAlt(_localctx, 1);
setState(2764);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 461, _ctx)) {
case 1: {
setState(2755);
oC_SymbolicName();
setState(2757);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2756);
match(CypherParser::SP);
}
setState(2759);
match(CypherParser::COLON);
setState(2760);
match(CypherParser::T__5);
setState(2762);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2761);
match(CypherParser::SP);
}
break;
}
default:
break;
}
setState(2766);
oC_Expression();
break;
}
case 2: {
enterOuterAlt(_localctx, 2);
setState(2767);
iC_LambdaParameter();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_LambdaParameterContext::IC_LambdaParameterContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::IC_LambdaVarsContext* CypherParser::IC_LambdaParameterContext::iC_LambdaVars() {
return getRuleContext<CypherParser::IC_LambdaVarsContext>(0);
}
tree::TerminalNode* CypherParser::IC_LambdaParameterContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
CypherParser::OC_ExpressionContext* CypherParser::IC_LambdaParameterContext::oC_Expression() {
return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}
std::vector<tree::TerminalNode *> CypherParser::IC_LambdaParameterContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_LambdaParameterContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_LambdaParameterContext::getRuleIndex() const {
return CypherParser::RuleIC_LambdaParameter;
}
CypherParser::IC_LambdaParameterContext* CypherParser::iC_LambdaParameter() {
IC_LambdaParameterContext *_localctx = _tracker.createInstance<IC_LambdaParameterContext>(_ctx, getState());
enterRule(_localctx, 322, CypherParser::RuleIC_LambdaParameter);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2770);
iC_LambdaVars();
setState(2772);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2771);
match(CypherParser::SP);
}
setState(2774);
match(CypherParser::MINUS);
setState(2775);
match(CypherParser::T__14);
setState(2777);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2776);
match(CypherParser::SP);
}
setState(2779);
oC_Expression();
setState(2781);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 465, _ctx)) {
case 1: {
setState(2780);
match(CypherParser::SP);
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_LambdaVarsContext::IC_LambdaVarsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_SymbolicNameContext *> CypherParser::IC_LambdaVarsContext::oC_SymbolicName() {
return getRuleContexts<CypherParser::OC_SymbolicNameContext>();
}
CypherParser::OC_SymbolicNameContext* CypherParser::IC_LambdaVarsContext::oC_SymbolicName(size_t i) {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::IC_LambdaVarsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::IC_LambdaVarsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::IC_LambdaVarsContext::getRuleIndex() const {
return CypherParser::RuleIC_LambdaVars;
}
CypherParser::IC_LambdaVarsContext* CypherParser::iC_LambdaVars() {
IC_LambdaVarsContext *_localctx = _tracker.createInstance<IC_LambdaVarsContext>(_ctx, getState());
enterRule(_localctx, 324, CypherParser::RuleIC_LambdaVars);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2807);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
enterOuterAlt(_localctx, 1);
setState(2783);
oC_SymbolicName();
break;
}
case CypherParser::T__1: {
enterOuterAlt(_localctx, 2);
setState(2784);
match(CypherParser::T__1);
setState(2786);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2785);
match(CypherParser::SP);
}
setState(2788);
oC_SymbolicName();
setState(2790);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2789);
match(CypherParser::SP);
}
setState(2802);
_errHandler->sync(this);
_la = _input->LA(1);
while (_la == CypherParser::T__3) {
setState(2792);
match(CypherParser::T__3);
setState(2794);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2793);
match(CypherParser::SP);
}
setState(2796);
oC_SymbolicName();
setState(2798);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2797);
match(CypherParser::SP);
}
setState(2804);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(2805);
match(CypherParser::T__2);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PathPatternsContext::OC_PathPatternsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_NodePatternContext* CypherParser::OC_PathPatternsContext::oC_NodePattern() {
return getRuleContext<CypherParser::OC_NodePatternContext>(0);
}
std::vector<CypherParser::OC_PatternElementChainContext *> CypherParser::OC_PathPatternsContext::oC_PatternElementChain() {
return getRuleContexts<CypherParser::OC_PatternElementChainContext>();
}
CypherParser::OC_PatternElementChainContext* CypherParser::OC_PathPatternsContext::oC_PatternElementChain(size_t i) {
return getRuleContext<CypherParser::OC_PatternElementChainContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_PathPatternsContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_PathPatternsContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_PathPatternsContext::getRuleIndex() const {
return CypherParser::RuleOC_PathPatterns;
}
CypherParser::OC_PathPatternsContext* CypherParser::oC_PathPatterns() {
OC_PathPatternsContext *_localctx = _tracker.createInstance<OC_PathPatternsContext>(_ctx, getState());
enterRule(_localctx, 326, CypherParser::RuleOC_PathPatterns);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2809);
oC_NodePattern();
setState(2814);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(2811);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2810);
match(CypherParser::SP);
}
setState(2813);
oC_PatternElementChain();
break;
}
default:
throw NoViableAltException(this);
}
setState(2816);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 473, _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;
}
CypherParser::OC_ExistCountSubqueryContext::OC_ExistCountSubqueryContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
CypherParser::OC_PatternContext* CypherParser::OC_ExistCountSubqueryContext::oC_Pattern() {
return getRuleContext<CypherParser::OC_PatternContext>(0);
}
tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::EXISTS() {
return getToken(CypherParser::EXISTS, 0);
}
tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::COUNT() {
return getToken(CypherParser::COUNT, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_ExistCountSubqueryContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
CypherParser::OC_WhereContext* CypherParser::OC_ExistCountSubqueryContext::oC_Where() {
return getRuleContext<CypherParser::OC_WhereContext>(0);
}
CypherParser::IC_HintContext* CypherParser::OC_ExistCountSubqueryContext::iC_Hint() {
return getRuleContext<CypherParser::IC_HintContext>(0);
}
size_t CypherParser::OC_ExistCountSubqueryContext::getRuleIndex() const {
return CypherParser::RuleOC_ExistCountSubquery;
}
CypherParser::OC_ExistCountSubqueryContext* CypherParser::oC_ExistCountSubquery() {
OC_ExistCountSubqueryContext *_localctx = _tracker.createInstance<OC_ExistCountSubqueryContext>(_ctx, getState());
enterRule(_localctx, 328, CypherParser::RuleOC_ExistCountSubquery);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2818);
_la = _input->LA(1);
if (!(_la == CypherParser::COUNT
|| _la == CypherParser::EXISTS)) {
_errHandler->recoverInline(this);
}
else {
_errHandler->reportMatch(this);
consume();
}
setState(2820);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2819);
match(CypherParser::SP);
}
setState(2822);
match(CypherParser::T__8);
setState(2824);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2823);
match(CypherParser::SP);
}
setState(2826);
match(CypherParser::MATCH);
setState(2828);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2827);
match(CypherParser::SP);
}
setState(2830);
oC_Pattern();
setState(2835);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 478, _ctx)) {
case 1: {
setState(2832);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2831);
match(CypherParser::SP);
}
setState(2834);
oC_Where();
break;
}
default:
break;
}
setState(2841);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 480, _ctx)) {
case 1: {
setState(2838);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2837);
match(CypherParser::SP);
}
setState(2840);
iC_Hint();
break;
}
default:
break;
}
setState(2844);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2843);
match(CypherParser::SP);
}
setState(2846);
match(CypherParser::T__9);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PropertyLookupContext::OC_PropertyLookupContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::OC_PropertyLookupContext::oC_PropertyKeyName() {
return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}
tree::TerminalNode* CypherParser::OC_PropertyLookupContext::STAR() {
return getToken(CypherParser::STAR, 0);
}
tree::TerminalNode* CypherParser::OC_PropertyLookupContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_PropertyLookupContext::getRuleIndex() const {
return CypherParser::RuleOC_PropertyLookup;
}
CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() {
OC_PropertyLookupContext *_localctx = _tracker.createInstance<OC_PropertyLookupContext>(_ctx, getState());
enterRule(_localctx, 330, CypherParser::RuleOC_PropertyLookup);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2848);
match(CypherParser::T__4);
setState(2850);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2849);
match(CypherParser::SP);
}
setState(2854);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
setState(2852);
oC_PropertyKeyName();
break;
}
case CypherParser::STAR: {
setState(2853);
match(CypherParser::STAR);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_CaseExpressionContext::OC_CaseExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_CaseExpressionContext::END() {
return getToken(CypherParser::END, 0);
}
tree::TerminalNode* CypherParser::OC_CaseExpressionContext::ELSE() {
return getToken(CypherParser::ELSE, 0);
}
std::vector<CypherParser::OC_ExpressionContext *> CypherParser::OC_CaseExpressionContext::oC_Expression() {
return getRuleContexts<CypherParser::OC_ExpressionContext>();
}
CypherParser::OC_ExpressionContext* CypherParser::OC_CaseExpressionContext::oC_Expression(size_t i) {
return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}
std::vector<tree::TerminalNode *> CypherParser::OC_CaseExpressionContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_CaseExpressionContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
tree::TerminalNode* CypherParser::OC_CaseExpressionContext::CASE() {
return getToken(CypherParser::CASE, 0);
}
std::vector<CypherParser::OC_CaseAlternativeContext *> CypherParser::OC_CaseExpressionContext::oC_CaseAlternative() {
return getRuleContexts<CypherParser::OC_CaseAlternativeContext>();
}
CypherParser::OC_CaseAlternativeContext* CypherParser::OC_CaseExpressionContext::oC_CaseAlternative(size_t i) {
return getRuleContext<CypherParser::OC_CaseAlternativeContext>(i);
}
size_t CypherParser::OC_CaseExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_CaseExpression;
}
CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() {
OC_CaseExpressionContext *_localctx = _tracker.createInstance<OC_CaseExpressionContext>(_ctx, getState());
enterRule(_localctx, 332, CypherParser::RuleOC_CaseExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
setState(2878);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 489, _ctx)) {
case 1: {
setState(2856);
match(CypherParser::CASE);
setState(2861);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(2858);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2857);
match(CypherParser::SP);
}
setState(2860);
oC_CaseAlternative();
break;
}
default:
throw NoViableAltException(this);
}
setState(2863);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 485, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
break;
}
case 2: {
setState(2865);
match(CypherParser::CASE);
setState(2867);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2866);
match(CypherParser::SP);
}
setState(2869);
oC_Expression();
setState(2874);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(2871);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2870);
match(CypherParser::SP);
}
setState(2873);
oC_CaseAlternative();
break;
}
default:
throw NoViableAltException(this);
}
setState(2876);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 488, _ctx);
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
break;
}
default:
break;
}
setState(2888);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 492, _ctx)) {
case 1: {
setState(2881);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2880);
match(CypherParser::SP);
}
setState(2883);
match(CypherParser::ELSE);
setState(2885);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2884);
match(CypherParser::SP);
}
setState(2887);
oC_Expression();
break;
}
default:
break;
}
setState(2891);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2890);
match(CypherParser::SP);
}
setState(2893);
match(CypherParser::END);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_CaseAlternativeContext::OC_CaseAlternativeContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_CaseAlternativeContext::WHEN() {
return getToken(CypherParser::WHEN, 0);
}
std::vector<CypherParser::OC_ExpressionContext *> CypherParser::OC_CaseAlternativeContext::oC_Expression() {
return getRuleContexts<CypherParser::OC_ExpressionContext>();
}
CypherParser::OC_ExpressionContext* CypherParser::OC_CaseAlternativeContext::oC_Expression(size_t i) {
return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}
tree::TerminalNode* CypherParser::OC_CaseAlternativeContext::THEN() {
return getToken(CypherParser::THEN, 0);
}
std::vector<tree::TerminalNode *> CypherParser::OC_CaseAlternativeContext::SP() {
return getTokens(CypherParser::SP);
}
tree::TerminalNode* CypherParser::OC_CaseAlternativeContext::SP(size_t i) {
return getToken(CypherParser::SP, i);
}
size_t CypherParser::OC_CaseAlternativeContext::getRuleIndex() const {
return CypherParser::RuleOC_CaseAlternative;
}
CypherParser::OC_CaseAlternativeContext* CypherParser::oC_CaseAlternative() {
OC_CaseAlternativeContext *_localctx = _tracker.createInstance<OC_CaseAlternativeContext>(_ctx, getState());
enterRule(_localctx, 334, CypherParser::RuleOC_CaseAlternative);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2895);
match(CypherParser::WHEN);
setState(2897);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2896);
match(CypherParser::SP);
}
setState(2899);
oC_Expression();
setState(2901);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2900);
match(CypherParser::SP);
}
setState(2903);
match(CypherParser::THEN);
setState(2905);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2904);
match(CypherParser::SP);
}
setState(2907);
oC_Expression();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_VariableContext::OC_VariableContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::OC_VariableContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
size_t CypherParser::OC_VariableContext::getRuleIndex() const {
return CypherParser::RuleOC_Variable;
}
CypherParser::OC_VariableContext* CypherParser::oC_Variable() {
OC_VariableContext *_localctx = _tracker.createInstance<OC_VariableContext>(_ctx, getState());
enterRule(_localctx, 336, CypherParser::RuleOC_Variable);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2909);
oC_SymbolicName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_NumberLiteralContext::OC_NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_DoubleLiteralContext* CypherParser::OC_NumberLiteralContext::oC_DoubleLiteral() {
return getRuleContext<CypherParser::OC_DoubleLiteralContext>(0);
}
CypherParser::OC_IntegerLiteralContext* CypherParser::OC_NumberLiteralContext::oC_IntegerLiteral() {
return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}
size_t CypherParser::OC_NumberLiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_NumberLiteral;
}
CypherParser::OC_NumberLiteralContext* CypherParser::oC_NumberLiteral() {
OC_NumberLiteralContext *_localctx = _tracker.createInstance<OC_NumberLiteralContext>(_ctx, getState());
enterRule(_localctx, 338, CypherParser::RuleOC_NumberLiteral);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2913);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ExponentDecimalReal:
case CypherParser::RegularDecimalReal: {
enterOuterAlt(_localctx, 1);
setState(2911);
oC_DoubleLiteral();
break;
}
case CypherParser::DecimalInteger: {
enterOuterAlt(_localctx, 2);
setState(2912);
oC_IntegerLiteral();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_ParameterContext::OC_ParameterContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::OC_ParameterContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
tree::TerminalNode* CypherParser::OC_ParameterContext::DecimalInteger() {
return getToken(CypherParser::DecimalInteger, 0);
}
size_t CypherParser::OC_ParameterContext::getRuleIndex() const {
return CypherParser::RuleOC_Parameter;
}
CypherParser::OC_ParameterContext* CypherParser::oC_Parameter() {
OC_ParameterContext *_localctx = _tracker.createInstance<OC_ParameterContext>(_ctx, getState());
enterRule(_localctx, 340, CypherParser::RuleOC_Parameter);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2915);
match(CypherParser::T__24);
setState(2918);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP:
case CypherParser::HexLetter:
case CypherParser::UnescapedSymbolicName:
case CypherParser::EscapedSymbolicName: {
setState(2916);
oC_SymbolicName();
break;
}
case CypherParser::DecimalInteger: {
setState(2917);
match(CypherParser::DecimalInteger);
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PropertyExpressionContext::OC_PropertyExpressionContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_AtomContext* CypherParser::OC_PropertyExpressionContext::oC_Atom() {
return getRuleContext<CypherParser::OC_AtomContext>(0);
}
CypherParser::OC_PropertyLookupContext* CypherParser::OC_PropertyExpressionContext::oC_PropertyLookup() {
return getRuleContext<CypherParser::OC_PropertyLookupContext>(0);
}
tree::TerminalNode* CypherParser::OC_PropertyExpressionContext::SP() {
return getToken(CypherParser::SP, 0);
}
size_t CypherParser::OC_PropertyExpressionContext::getRuleIndex() const {
return CypherParser::RuleOC_PropertyExpression;
}
CypherParser::OC_PropertyExpressionContext* CypherParser::oC_PropertyExpression() {
OC_PropertyExpressionContext *_localctx = _tracker.createInstance<OC_PropertyExpressionContext>(_ctx, getState());
enterRule(_localctx, 342, CypherParser::RuleOC_PropertyExpression);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2920);
oC_Atom();
setState(2922);
_errHandler->sync(this);
_la = _input->LA(1);
if (_la == CypherParser::SP) {
setState(2921);
match(CypherParser::SP);
}
setState(2924);
oC_PropertyLookup();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_PropertyKeyNameContext::OC_PropertyKeyNameContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
CypherParser::OC_SymbolicNameContext* CypherParser::OC_PropertyKeyNameContext::oC_SymbolicName() {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}
size_t CypherParser::OC_PropertyKeyNameContext::getRuleIndex() const {
return CypherParser::RuleOC_PropertyKeyName;
}
CypherParser::OC_PropertyKeyNameContext* CypherParser::oC_PropertyKeyName() {
OC_PropertyKeyNameContext *_localctx = _tracker.createInstance<OC_PropertyKeyNameContext>(_ctx, getState());
enterRule(_localctx, 344, CypherParser::RuleOC_PropertyKeyName);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2926);
oC_SymbolicName();
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_IntegerLiteralContext::OC_IntegerLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_IntegerLiteralContext::DecimalInteger() {
return getToken(CypherParser::DecimalInteger, 0);
}
size_t CypherParser::OC_IntegerLiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_IntegerLiteral;
}
CypherParser::OC_IntegerLiteralContext* CypherParser::oC_IntegerLiteral() {
OC_IntegerLiteralContext *_localctx = _tracker.createInstance<OC_IntegerLiteralContext>(_ctx, getState());
enterRule(_localctx, 346, CypherParser::RuleOC_IntegerLiteral);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2928);
match(CypherParser::DecimalInteger);
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_DoubleLiteralContext::OC_DoubleLiteralContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_DoubleLiteralContext::ExponentDecimalReal() {
return getToken(CypherParser::ExponentDecimalReal, 0);
}
tree::TerminalNode* CypherParser::OC_DoubleLiteralContext::RegularDecimalReal() {
return getToken(CypherParser::RegularDecimalReal, 0);
}
size_t CypherParser::OC_DoubleLiteralContext::getRuleIndex() const {
return CypherParser::RuleOC_DoubleLiteral;
}
CypherParser::OC_DoubleLiteralContext* CypherParser::oC_DoubleLiteral() {
OC_DoubleLiteralContext *_localctx = _tracker.createInstance<OC_DoubleLiteralContext>(_ctx, getState());
enterRule(_localctx, 348, CypherParser::RuleOC_DoubleLiteral);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2930);
_la = _input->LA(1);
if (!(_la == CypherParser::ExponentDecimalReal
|| _la == CypherParser::RegularDecimalReal)) {
_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;
}
CypherParser::OC_SchemaNameContext::OC_SchemaNameContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
std::vector<CypherParser::OC_SymbolicNameContext *> CypherParser::OC_SchemaNameContext::oC_SymbolicName() {
return getRuleContexts<CypherParser::OC_SymbolicNameContext>();
}
CypherParser::OC_SymbolicNameContext* CypherParser::OC_SchemaNameContext::oC_SymbolicName(size_t i) {
return getRuleContext<CypherParser::OC_SymbolicNameContext>(i);
}
size_t CypherParser::OC_SchemaNameContext::getRuleIndex() const {
return CypherParser::RuleOC_SchemaName;
}
CypherParser::OC_SchemaNameContext* CypherParser::oC_SchemaName() {
OC_SchemaNameContext *_localctx = _tracker.createInstance<OC_SchemaNameContext>(_ctx, getState());
enterRule(_localctx, 350, CypherParser::RuleOC_SchemaName);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2932);
oC_SymbolicName();
setState(2935);
_errHandler->sync(this);
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 500, _ctx)) {
case 1: {
setState(2933);
match(CypherParser::T__4);
setState(2934);
oC_SymbolicName();
break;
}
default:
break;
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::OC_SymbolicNameContext::OC_SymbolicNameContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_SymbolicNameContext::UnescapedSymbolicName() {
return getToken(CypherParser::UnescapedSymbolicName, 0);
}
tree::TerminalNode* CypherParser::OC_SymbolicNameContext::EscapedSymbolicName() {
return getToken(CypherParser::EscapedSymbolicName, 0);
}
tree::TerminalNode* CypherParser::OC_SymbolicNameContext::HexLetter() {
return getToken(CypherParser::HexLetter, 0);
}
CypherParser::IC_NonReservedKeywordsContext* CypherParser::OC_SymbolicNameContext::iC_NonReservedKeywords() {
return getRuleContext<CypherParser::IC_NonReservedKeywordsContext>(0);
}
size_t CypherParser::OC_SymbolicNameContext::getRuleIndex() const {
return CypherParser::RuleOC_SymbolicName;
}
CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() {
OC_SymbolicNameContext *_localctx = _tracker.createInstance<OC_SymbolicNameContext>(_ctx, getState());
enterRule(_localctx, 352, CypherParser::RuleOC_SymbolicName);
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
setState(2942);
_errHandler->sync(this);
switch (_input->LA(1)) {
case CypherParser::UnescapedSymbolicName: {
enterOuterAlt(_localctx, 1);
setState(2937);
match(CypherParser::UnescapedSymbolicName);
break;
}
case CypherParser::EscapedSymbolicName: {
enterOuterAlt(_localctx, 2);
setState(2938);
antlrcpp::downCast<OC_SymbolicNameContext *>(_localctx)->escapedsymbolicnameToken = match(CypherParser::EscapedSymbolicName);
if ((antlrcpp::downCast<OC_SymbolicNameContext *>(_localctx)->escapedsymbolicnameToken != nullptr ? antlrcpp::downCast<OC_SymbolicNameContext *>(_localctx)->escapedsymbolicnameToken->getText() : "") == "``") { notifyEmptyToken(antlrcpp::downCast<OC_SymbolicNameContext *>(_localctx)->escapedsymbolicnameToken); }
break;
}
case CypherParser::HexLetter: {
enterOuterAlt(_localctx, 3);
setState(2940);
match(CypherParser::HexLetter);
break;
}
case CypherParser::ADD:
case CypherParser::ALTER:
case CypherParser::AS:
case CypherParser::ATTACH:
case CypherParser::BEGIN:
case CypherParser::BY:
case CypherParser::CALL:
case CypherParser::CHECKPOINT:
case CypherParser::COMMENT:
case CypherParser::COMMIT:
case CypherParser::CONTAINS:
case CypherParser::COPY:
case CypherParser::COUNT:
case CypherParser::CYCLE:
case CypherParser::DATABASE:
case CypherParser::DELETE:
case CypherParser::DETACH:
case CypherParser::DROP:
case CypherParser::EXPLAIN:
case CypherParser::EXPORT:
case CypherParser::EXTENSION:
case CypherParser::FROM:
case CypherParser::FORCE:
case CypherParser::GRAPH:
case CypherParser::IMPORT:
case CypherParser::IF:
case CypherParser::INCREMENT:
case CypherParser::IS:
case CypherParser::KEY:
case CypherParser::LIMIT:
case CypherParser::LOAD:
case CypherParser::LOGICAL:
case CypherParser::MATCH:
case CypherParser::MAXVALUE:
case CypherParser::MERGE:
case CypherParser::MINVALUE:
case CypherParser::NO:
case CypherParser::NODE:
case CypherParser::PROJECT:
case CypherParser::READ:
case CypherParser::REL:
case CypherParser::RENAME:
case CypherParser::RETURN:
case CypherParser::ROLLBACK:
case CypherParser::SEQUENCE:
case CypherParser::SET:
case CypherParser::START:
case CypherParser::STRUCT:
case CypherParser::TO:
case CypherParser::TRANSACTION:
case CypherParser::TYPE:
case CypherParser::UNINSTALL:
case CypherParser::UPDATE:
case CypherParser::USE:
case CypherParser::WRITE:
case CypherParser::YIELD:
case CypherParser::USER:
case CypherParser::PASSWORD:
case CypherParser::ROLE:
case CypherParser::MAP:
case CypherParser::DECIMAL:
case CypherParser::L_SKIP: {
enterOuterAlt(_localctx, 4);
setState(2941);
iC_NonReservedKeywords();
break;
}
default:
throw NoViableAltException(this);
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
CypherParser::IC_NonReservedKeywordsContext::IC_NonReservedKeywordsContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COMMENT() {
return getToken(CypherParser::COMMENT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ADD() {
return getToken(CypherParser::ADD, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ALTER() {
return getToken(CypherParser::ALTER, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::AS() {
return getToken(CypherParser::AS, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ATTACH() {
return getToken(CypherParser::ATTACH, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::BEGIN() {
return getToken(CypherParser::BEGIN, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::BY() {
return getToken(CypherParser::BY, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CALL() {
return getToken(CypherParser::CALL, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CHECKPOINT() {
return getToken(CypherParser::CHECKPOINT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COMMIT() {
return getToken(CypherParser::COMMIT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CONTAINS() {
return getToken(CypherParser::CONTAINS, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COPY() {
return getToken(CypherParser::COPY, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COUNT() {
return getToken(CypherParser::COUNT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CYCLE() {
return getToken(CypherParser::CYCLE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DATABASE() {
return getToken(CypherParser::DATABASE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DECIMAL() {
return getToken(CypherParser::DECIMAL, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DELETE() {
return getToken(CypherParser::DELETE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DETACH() {
return getToken(CypherParser::DETACH, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DROP() {
return getToken(CypherParser::DROP, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::EXPLAIN() {
return getToken(CypherParser::EXPLAIN, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::EXPORT() {
return getToken(CypherParser::EXPORT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::EXTENSION() {
return getToken(CypherParser::EXTENSION, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::FORCE() {
return getToken(CypherParser::FORCE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::GRAPH() {
return getToken(CypherParser::GRAPH, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::IF() {
return getToken(CypherParser::IF, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::IS() {
return getToken(CypherParser::IS, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::IMPORT() {
return getToken(CypherParser::IMPORT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::INCREMENT() {
return getToken(CypherParser::INCREMENT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::KEY() {
return getToken(CypherParser::KEY, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::LOAD() {
return getToken(CypherParser::LOAD, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::LOGICAL() {
return getToken(CypherParser::LOGICAL, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MATCH() {
return getToken(CypherParser::MATCH, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MAXVALUE() {
return getToken(CypherParser::MAXVALUE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MERGE() {
return getToken(CypherParser::MERGE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MINVALUE() {
return getToken(CypherParser::MINVALUE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::NO() {
return getToken(CypherParser::NO, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::NODE() {
return getToken(CypherParser::NODE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::PROJECT() {
return getToken(CypherParser::PROJECT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::READ() {
return getToken(CypherParser::READ, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::REL() {
return getToken(CypherParser::REL, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::RENAME() {
return getToken(CypherParser::RENAME, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::RETURN() {
return getToken(CypherParser::RETURN, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ROLLBACK() {
return getToken(CypherParser::ROLLBACK, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ROLE() {
return getToken(CypherParser::ROLE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::SEQUENCE() {
return getToken(CypherParser::SEQUENCE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::SET() {
return getToken(CypherParser::SET, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::START() {
return getToken(CypherParser::START, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::STRUCT() {
return getToken(CypherParser::STRUCT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::L_SKIP() {
return getToken(CypherParser::L_SKIP, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::LIMIT() {
return getToken(CypherParser::LIMIT, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::TRANSACTION() {
return getToken(CypherParser::TRANSACTION, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::TYPE() {
return getToken(CypherParser::TYPE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::USE() {
return getToken(CypherParser::USE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::UNINSTALL() {
return getToken(CypherParser::UNINSTALL, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::UPDATE() {
return getToken(CypherParser::UPDATE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::WRITE() {
return getToken(CypherParser::WRITE, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::FROM() {
return getToken(CypherParser::FROM, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::TO() {
return getToken(CypherParser::TO, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::YIELD() {
return getToken(CypherParser::YIELD, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::USER() {
return getToken(CypherParser::USER, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::PASSWORD() {
return getToken(CypherParser::PASSWORD, 0);
}
tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MAP() {
return getToken(CypherParser::MAP, 0);
}
size_t CypherParser::IC_NonReservedKeywordsContext::getRuleIndex() const {
return CypherParser::RuleIC_NonReservedKeywords;
}
CypherParser::IC_NonReservedKeywordsContext* CypherParser::iC_NonReservedKeywords() {
IC_NonReservedKeywordsContext *_localctx = _tracker.createInstance<IC_NonReservedKeywordsContext>(_ctx, getState());
enterRule(_localctx, 354, CypherParser::RuleIC_NonReservedKeywords);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2944);
_la = _input->LA(1);
if (!(((((_la - 47) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 47)) & 8923191552623093653) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) &&
((1ULL << (_la - 111)) & 3361330146570243) != 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;
}
CypherParser::OC_LeftArrowHeadContext::OC_LeftArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t CypherParser::OC_LeftArrowHeadContext::getRuleIndex() const {
return CypherParser::RuleOC_LeftArrowHead;
}
CypherParser::OC_LeftArrowHeadContext* CypherParser::oC_LeftArrowHead() {
OC_LeftArrowHeadContext *_localctx = _tracker.createInstance<OC_LeftArrowHeadContext>(_ctx, getState());
enterRule(_localctx, 356, CypherParser::RuleOC_LeftArrowHead);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2946);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 1006641152) != 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;
}
CypherParser::OC_RightArrowHeadContext::OC_RightArrowHeadContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
size_t CypherParser::OC_RightArrowHeadContext::getRuleIndex() const {
return CypherParser::RuleOC_RightArrowHead;
}
CypherParser::OC_RightArrowHeadContext* CypherParser::oC_RightArrowHead() {
OC_RightArrowHeadContext *_localctx = _tracker.createInstance<OC_RightArrowHeadContext>(_ctx, getState());
enterRule(_localctx, 358, CypherParser::RuleOC_RightArrowHead);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2948);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 16106160128) != 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;
}
CypherParser::OC_DashContext::OC_DashContext(ParserRuleContext *parent, size_t invokingState)
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* CypherParser::OC_DashContext::MINUS() {
return getToken(CypherParser::MINUS, 0);
}
size_t CypherParser::OC_DashContext::getRuleIndex() const {
return CypherParser::RuleOC_Dash;
}
CypherParser::OC_DashContext* CypherParser::oC_Dash() {
OC_DashContext *_localctx = _tracker.createInstance<OC_DashContext>(_ctx, getState());
enterRule(_localctx, 360, CypherParser::RuleOC_Dash);
size_t _la = 0;
#if __cplusplus > 201703L
auto onExit = finally([=, this] {
#else
auto onExit = finally([=] {
#endif
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
setState(2950);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & 35167192219648) != 0) || _la == CypherParser::MINUS)) {
_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;
}
bool CypherParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
switch (ruleIndex) {
case 59: return iC_DataTypeSempred(antlrcpp::downCast<IC_DataTypeContext *>(context), predicateIndex);
case 86: return iC_JoinNodeSempred(antlrcpp::downCast<IC_JoinNodeContext *>(context), predicateIndex);
default:
break;
}
return true;
}
bool CypherParser::iC_DataTypeSempred(IC_DataTypeContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 0: return precpred(_ctx, 5);
default:
break;
}
return true;
}
bool CypherParser::iC_JoinNodeSempred(IC_JoinNodeContext *_localctx, size_t predicateIndex) {
switch (predicateIndex) {
case 1: return precpred(_ctx, 4);
case 2: return precpred(_ctx, 3);
default:
break;
}
return true;
}
void CypherParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
cypherParserInitialize();
#else
::antlr4::internal::call_once(cypherParserOnceFlag, cypherParserInitialize);
#endif
}