
// Generated from Cypher.g4 by ANTLR 4.13.1



#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>{
      "ku_Statements", "oC_Cypher", "oC_Statement", "kU_CopyFrom", "kU_ColumnNames", 
      "kU_ScanSource", "kU_CopyFromByColumn", "kU_CopyTO", "kU_ExportDatabase", 
      "kU_ImportDatabase", "kU_AttachDatabase", "kU_DetachDatabase", "kU_UseDatabase", 
      "kU_StandaloneCall", "kU_CommentOn", "kU_CreateMacro", "kU_PositionalArgs", 
      "kU_DefaultArg", "kU_FilePaths", "kU_ParsingOptions", "kU_ParsingOption", 
      "kU_CreateNodeTable", "kU_CreateRelTable", "kU_CreateRelTableGroup", 
      "kU_RelTableConnection", "kU_CreateRdfGraph", "kU_DropTable", "kU_AlterTable", 
      "kU_AlterOptions", "kU_AddProperty", "kU_DropProperty", "kU_RenameTable", 
      "kU_RenameProperty", "kU_PropertyDefinitions", "kU_PropertyDefinition", 
      "kU_CreateNodeConstraint", "kU_DataType", "kU_ListIdentifiers", "kU_ListIdentifier", 
      "oC_AnyCypherOption", "oC_Explain", "oC_Profile", "kU_Transaction", 
      "kU_Extension", "kU_LoadExtension", "kU_InstallExtension", "oC_Query", 
      "oC_RegularQuery", "oC_Union", "oC_SingleQuery", "oC_SinglePartQuery", 
      "oC_MultiPartQuery", "kU_QueryPart", "oC_UpdatingClause", "oC_ReadingClause", 
      "kU_LoadFrom", "kU_InQueryCall", "oC_Match", "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", "kU_Properties", "oC_RelationshipTypes", 
      "oC_NodeLabels", "oC_NodeLabel", "oC_RangeLiteral", "kU_RecursiveRelationshipComprehension", 
      "kU_IntermediateNodeProjectionItems", "kU_IntermediateRelProjectionItems", 
      "oC_LowerBound", "oC_UpperBound", "oC_LabelName", "oC_RelTypeName", 
      "oC_Expression", "oC_OrExpression", "oC_XorExpression", "oC_AndExpression", 
      "oC_NotExpression", "oC_ComparisonExpression", "kU_ComparisonOperator", 
      "kU_BitwiseOrOperatorExpression", "kU_BitwiseAndOperatorExpression", 
      "kU_BitShiftOperatorExpression", "kU_BitShiftOperator", "oC_AddOrSubtractExpression", 
      "kU_AddOrSubtractOperator", "oC_MultiplyDivideModuloExpression", "kU_MultiplyDivideModuloOperator", 
      "oC_PowerOfExpression", "oC_UnaryAddSubtractOrFactorialExpression", 
      "oC_StringListNullOperatorExpression", "oC_ListOperatorExpression", 
      "oC_StringOperatorExpression", "oC_RegularExpression", "oC_NullOperatorExpression", 
      "oC_PropertyOrLabelsExpression", "oC_Atom", "oC_Literal", "oC_BooleanLiteral", 
      "oC_ListLiteral", "kU_ListEntry", "kU_StructLiteral", "kU_StructField", 
      "oC_ParenthesizedExpression", "oC_FunctionInvocation", "oC_FunctionName", 
      "kU_FunctionParameter", "oC_PathPatterns", "oC_ExistSubquery", "kU_CountSubquery", 
      "oC_PropertyLookup", "oC_CaseExpression", "oC_CaseAlternative", "oC_Variable", 
      "oC_NumberLiteral", "oC_Parameter", "oC_PropertyExpression", "oC_PropertyKeyName", 
      "oC_IntegerLiteral", "oC_DoubleLiteral", "oC_SchemaName", "oC_SymbolicName", 
      "kU_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>{
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "ATTACH", "DBTYPE", 
      "USE", "CALL", "COMMENT_", "MACRO", "GLOB", "COPY", "FROM", "COLUMN", 
      "EXPORT", "IMPORT", "DATABASE", "NODE", "TABLE", "GROUP", "RDFGRAPH", 
      "DROP", "ALTER", "DEFAULT", "RENAME", "ADD", "PRIMARY", "KEY", "REL", 
      "TO", "EXPLAIN", "PROFILE", "BEGIN", "TRANSACTION", "READ", "ONLY", 
      "WRITE", "COMMIT", "COMMIT_SKIP_CHECKPOINT", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", 
      "INSTALL", "EXTENSION", "UNION", "ALL", "LOAD", "HEADERS", "OPTIONAL", 
      "MATCH", "UNWIND", "CREATE", "MERGE", "ON", "SET", "DETACH", "DELETE", 
      "WITH", "RETURN", "DISTINCT", "STAR", "AS", "ORDER", "BY", "L_SKIP", 
      "LIMIT", "ASCENDING", "ASC", "DESCENDING", "DESC", "WHERE", "SHORTEST", 
      "OR", "XOR", "AND", "NOT", "INVALID_NOT_EQUAL", "MINUS", "FACTORIAL", 
      "COLON", "IN", "STARTS", "ENDS", "CONTAINS", "IS", "NULL_", "TRUE", 
      "FALSE", "COUNT", "EXISTS", "CASE", "ELSE", "END", "WHEN", "THEN", 
      "StringLiteral", "EscapedChar", "DecimalInteger", "HexLetter", "HexDigit", 
      "Digit", "NonZeroDigit", "NonZeroOctDigit", "ZeroDigit", "RegularDecimalReal", 
      "UnescapedSymbolicName", "IdentifierStart", "IdentifierPart", "EscapedSymbolicName", 
      "SP", "WHITESPACE", "Comment", "Unknown"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,153,2340,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,1,0,1,0,3,0,299,8,0,1,0,1,0,3,0,303,8,0,1,0,5,0,306,
  	8,0,10,0,12,0,309,9,0,1,0,3,0,312,8,0,1,0,1,0,1,1,3,1,317,8,1,1,1,3,1,
  	320,8,1,1,1,1,1,3,1,324,8,1,1,1,3,1,327,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,3,2,349,8,2,1,3,
  	1,3,1,3,1,3,3,3,355,8,3,1,3,1,3,3,3,359,8,3,1,3,3,3,362,8,3,1,3,1,3,1,
  	3,1,3,3,3,368,8,3,1,3,3,3,371,8,3,1,4,1,4,3,4,375,8,4,1,4,1,4,3,4,379,
  	8,4,1,4,1,4,3,4,383,8,4,1,4,5,4,386,8,4,10,4,12,4,389,9,4,1,4,3,4,392,
  	8,4,1,4,1,4,1,5,1,5,1,5,3,5,399,8,5,1,5,1,5,3,5,403,8,5,1,5,1,5,1,5,1,
  	5,1,5,1,5,3,5,411,8,5,1,5,1,5,3,5,415,8,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,
  	1,6,3,6,425,8,6,1,6,1,6,3,6,429,8,6,1,6,1,6,3,6,433,8,6,1,6,5,6,436,8,
  	6,10,6,12,6,439,9,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,3,7,451,8,
  	7,1,7,1,7,3,7,455,8,7,1,7,1,7,1,7,1,7,1,7,1,7,3,7,463,8,7,1,7,3,7,466,
  	8,7,1,8,1,8,1,8,1,8,1,8,1,8,3,8,474,8,8,1,8,3,8,477,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,1,10,1,10,3,10,494,8,10,
  	1,10,3,10,497,8,10,1,10,1,10,3,10,501,8,10,1,10,1,10,1,10,1,10,3,10,507,
  	8,10,1,10,3,10,510,8,10,1,11,1,11,1,11,1,11,1,12,1,12,1,12,1,12,1,13,
  	1,13,1,13,1,13,3,13,524,8,13,1,13,1,13,3,13,528,8,13,1,13,1,13,1,14,1,
  	14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,15,1,15,1,15,1,
  	15,1,15,1,15,3,15,550,8,15,1,15,1,15,3,15,554,8,15,1,15,3,15,557,8,15,
  	1,15,3,15,560,8,15,1,15,3,15,563,8,15,1,15,3,15,566,8,15,1,15,1,15,3,
  	15,570,8,15,1,15,5,15,573,8,15,10,15,12,15,576,9,15,1,15,3,15,579,8,15,
  	1,15,1,15,1,15,1,15,1,15,1,15,1,16,1,16,3,16,589,8,16,1,16,1,16,3,16,
  	593,8,16,1,16,5,16,596,8,16,10,16,12,16,599,9,16,1,17,1,17,3,17,603,8,
  	17,1,17,1,17,1,17,3,17,608,8,17,1,17,1,17,1,18,1,18,3,18,614,8,18,1,18,
  	1,18,3,18,618,8,18,1,18,1,18,3,18,622,8,18,1,18,5,18,625,8,18,10,18,12,
  	18,628,9,18,1,18,1,18,1,18,1,18,3,18,634,8,18,1,18,1,18,3,18,638,8,18,
  	1,18,1,18,3,18,642,8,18,1,18,3,18,645,8,18,1,19,1,19,3,19,649,8,19,1,
  	19,1,19,3,19,653,8,19,1,19,1,19,3,19,657,8,19,1,19,5,19,660,8,19,10,19,
  	12,19,663,9,19,1,19,3,19,666,8,19,1,19,1,19,1,20,1,20,3,20,672,8,20,1,
  	20,1,20,3,20,676,8,20,1,20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,
  	21,3,21,688,8,21,1,21,1,21,3,21,692,8,21,1,21,1,21,3,21,696,8,21,1,21,
  	1,21,3,21,700,8,21,1,21,1,21,1,21,3,21,705,8,21,1,21,1,21,1,22,1,22,1,
  	22,1,22,1,22,1,22,1,22,1,22,3,22,717,8,22,1,22,1,22,3,22,721,8,22,1,22,
  	1,22,3,22,725,8,22,1,22,1,22,3,22,729,8,22,1,22,1,22,3,22,733,8,22,3,
  	22,735,8,22,1,22,1,22,3,22,739,8,22,1,22,1,22,3,22,743,8,22,3,22,745,
  	8,22,1,22,1,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,
  	759,8,23,1,23,1,23,3,23,763,8,23,1,23,1,23,3,23,767,8,23,1,23,1,23,3,
  	23,771,8,23,1,23,4,23,774,8,23,11,23,12,23,775,1,23,3,23,779,8,23,1,23,
  	1,23,3,23,783,8,23,1,23,1,23,3,23,787,8,23,3,23,789,8,23,1,23,1,23,3,
  	23,793,8,23,1,23,1,23,3,23,797,8,23,3,23,799,8,23,1,23,1,23,1,24,1,24,
  	1,24,1,24,1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,
  	1,26,1,26,1,26,1,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,3,28,835,8,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
  	3,29,846,8,29,1,30,1,30,1,30,1,30,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,1,32,1,33,1,33,3,33,868,8,33,1,33,1,33,
  	3,33,872,8,33,1,33,5,33,875,8,33,10,33,12,33,878,9,33,1,34,1,34,1,34,
  	1,34,1,35,1,35,1,35,1,35,3,35,888,8,35,1,35,1,35,3,35,892,8,35,1,35,1,
  	35,3,35,896,8,35,1,35,1,35,1,36,1,36,1,36,1,36,3,36,904,8,36,1,36,1,36,
  	3,36,908,8,36,1,36,1,36,3,36,912,8,36,1,36,1,36,1,36,1,36,3,36,918,8,
  	36,1,36,1,36,3,36,922,8,36,1,36,1,36,3,36,926,8,36,1,36,1,36,1,36,1,36,
  	3,36,932,8,36,1,36,1,36,3,36,936,8,36,1,36,1,36,3,36,940,8,36,1,36,1,
  	36,3,36,944,8,36,1,36,1,36,3,36,948,8,36,1,36,1,36,3,36,952,8,36,1,36,
  	1,36,5,36,956,8,36,10,36,12,36,959,9,36,1,37,1,37,5,37,963,8,37,10,37,
  	12,37,966,9,37,1,38,1,38,3,38,970,8,38,1,38,1,38,1,39,1,39,3,39,976,8,
  	39,1,40,1,40,1,41,1,41,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,42,1,
  	42,1,42,1,42,1,42,1,42,3,42,996,8,42,1,43,1,43,3,43,1000,8,43,1,44,1,
  	44,1,44,1,44,1,44,1,44,3,44,1008,8,44,1,45,1,45,1,45,1,45,1,46,1,46,1,
  	47,1,47,3,47,1018,8,47,1,47,5,47,1021,8,47,10,47,12,47,1024,9,47,1,47,
  	1,47,3,47,1028,8,47,4,47,1030,8,47,11,47,12,47,1031,1,47,1,47,1,47,3,
  	47,1037,8,47,1,48,1,48,1,48,1,48,3,48,1043,8,48,1,48,1,48,1,48,3,48,1048,
  	8,48,1,48,3,48,1051,8,48,1,49,1,49,3,49,1055,8,49,1,50,1,50,3,50,1059,
  	8,50,5,50,1061,8,50,10,50,12,50,1064,9,50,1,50,1,50,1,50,3,50,1069,8,
  	50,5,50,1071,8,50,10,50,12,50,1074,9,50,1,50,1,50,3,50,1078,8,50,1,50,
  	5,50,1081,8,50,10,50,12,50,1084,9,50,1,50,3,50,1087,8,50,1,50,3,50,1090,
  	8,50,1,50,1,50,3,50,1094,8,50,4,50,1096,8,50,11,50,12,50,1097,1,50,1,
  	50,3,50,1102,8,50,1,51,1,51,3,51,1106,8,51,4,51,1108,8,51,11,51,12,51,
  	1109,1,51,1,51,1,52,1,52,3,52,1116,8,52,5,52,1118,8,52,10,52,12,52,1121,
  	9,52,1,52,1,52,3,52,1125,8,52,5,52,1127,8,52,10,52,12,52,1130,9,52,1,
  	52,1,52,1,53,1,53,1,53,1,53,3,53,1138,8,53,1,54,1,54,1,54,1,54,3,54,1144,
  	8,54,1,55,1,55,1,55,1,55,1,55,1,55,3,55,1152,8,55,1,55,1,55,3,55,1156,
  	8,55,1,55,1,55,3,55,1160,8,55,1,55,1,55,3,55,1164,8,55,1,55,1,55,1,55,
  	1,55,1,55,3,55,1171,8,55,1,55,3,55,1174,8,55,1,55,3,55,1177,8,55,1,55,
  	3,55,1180,8,55,1,56,1,56,1,56,1,56,3,56,1186,8,56,1,56,3,56,1189,8,56,
  	1,57,1,57,3,57,1193,8,57,1,57,1,57,3,57,1197,8,57,1,57,1,57,3,57,1201,
  	8,57,1,57,3,57,1204,8,57,1,58,1,58,3,58,1208,8,58,1,58,1,58,1,58,1,58,
  	1,58,1,58,1,59,1,59,3,59,1218,8,59,1,59,1,59,1,60,1,60,3,60,1224,8,60,
  	1,60,1,60,1,60,5,60,1229,8,60,10,60,12,60,1232,9,60,1,61,1,61,1,61,1,
  	61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,1244,8,61,1,62,1,62,3,62,1248,8,
  	62,1,62,1,62,3,62,1252,8,62,1,62,1,62,3,62,1256,8,62,1,62,5,62,1259,8,
  	62,10,62,12,62,1262,9,62,1,63,1,63,3,63,1266,8,63,1,63,1,63,3,63,1270,
  	8,63,1,63,1,63,1,64,1,64,3,64,1276,8,64,1,64,1,64,3,64,1280,8,64,1,64,
  	1,64,3,64,1284,8,64,1,64,1,64,3,64,1288,8,64,1,64,5,64,1291,8,64,10,64,
  	12,64,1294,9,64,1,65,1,65,1,65,3,65,1299,8,65,1,65,3,65,1302,8,65,1,66,
  	1,66,1,66,1,67,3,67,1308,8,67,1,67,3,67,1311,8,67,1,67,1,67,1,67,1,67,
  	3,67,1317,8,67,1,67,1,67,3,67,1321,8,67,1,67,1,67,3,67,1325,8,67,1,68,
  	1,68,3,68,1329,8,68,1,68,1,68,3,68,1333,8,68,1,68,5,68,1336,8,68,10,68,
  	12,68,1339,9,68,1,68,1,68,3,68,1343,8,68,1,68,1,68,3,68,1347,8,68,1,68,
  	5,68,1350,8,68,10,68,12,68,1353,9,68,3,68,1355,8,68,1,69,1,69,1,69,1,
  	69,1,69,1,69,1,69,3,69,1364,8,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,3,
  	70,1373,8,70,1,70,5,70,1376,8,70,10,70,12,70,1379,9,70,1,71,1,71,1,71,
  	1,71,1,72,1,72,1,72,1,72,1,73,1,73,3,73,1391,8,73,1,73,3,73,1394,8,73,
  	1,74,1,74,1,74,1,74,1,75,1,75,3,75,1402,8,75,1,75,1,75,3,75,1406,8,75,
  	1,75,5,75,1409,8,75,10,75,12,75,1412,9,75,1,76,1,76,3,76,1416,8,76,1,
  	76,1,76,3,76,1420,8,76,1,76,1,76,1,76,3,76,1425,8,76,1,77,1,77,1,78,1,
  	78,3,78,1431,8,78,1,78,5,78,1434,8,78,10,78,12,78,1437,9,78,1,78,1,78,
  	1,78,1,78,3,78,1443,8,78,1,79,1,79,3,79,1447,8,79,1,79,1,79,3,79,1451,
  	8,79,3,79,1453,8,79,1,79,1,79,3,79,1457,8,79,3,79,1459,8,79,1,79,1,79,
  	3,79,1463,8,79,3,79,1465,8,79,1,79,1,79,1,80,1,80,3,80,1471,8,80,1,80,
  	1,80,1,81,1,81,3,81,1477,8,81,1,81,1,81,3,81,1481,8,81,1,81,3,81,1484,
  	8,81,1,81,3,81,1487,8,81,1,81,1,81,1,81,1,81,3,81,1493,8,81,1,81,3,81,
  	1496,8,81,1,81,3,81,1499,8,81,1,81,1,81,3,81,1503,8,81,1,81,1,81,1,81,
  	1,81,3,81,1509,8,81,1,81,3,81,1512,8,81,1,81,3,81,1515,8,81,1,81,1,81,
  	3,81,1519,8,81,1,82,1,82,3,82,1523,8,82,1,82,1,82,3,82,1527,8,82,3,82,
  	1529,8,82,1,82,1,82,3,82,1533,8,82,3,82,1535,8,82,1,82,1,82,3,82,1539,
  	8,82,3,82,1541,8,82,1,82,1,82,3,82,1545,8,82,3,82,1547,8,82,1,82,1,82,
  	1,83,1,83,3,83,1553,8,83,1,83,1,83,3,83,1557,8,83,1,83,1,83,3,83,1561,
  	8,83,1,83,1,83,3,83,1565,8,83,1,83,1,83,3,83,1569,8,83,1,83,1,83,3,83,
  	1573,8,83,1,83,1,83,3,83,1577,8,83,1,83,1,83,3,83,1581,8,83,5,83,1583,
  	8,83,10,83,12,83,1586,9,83,3,83,1588,8,83,1,83,1,83,1,84,1,84,3,84,1594,
  	8,84,1,84,1,84,3,84,1598,8,84,1,84,1,84,3,84,1602,8,84,1,84,3,84,1605,
  	8,84,1,84,5,84,1608,8,84,10,84,12,84,1611,9,84,1,85,1,85,3,85,1615,8,
  	85,1,85,5,85,1618,8,85,10,85,12,85,1621,9,85,1,86,1,86,3,86,1625,8,86,
  	1,86,1,86,1,87,1,87,3,87,1631,8,87,1,87,1,87,1,87,1,87,3,87,1637,8,87,
  	1,87,3,87,1640,8,87,1,87,3,87,1643,8,87,1,87,3,87,1646,8,87,1,87,1,87,
  	3,87,1650,8,87,1,87,3,87,1653,8,87,1,87,3,87,1656,8,87,1,87,3,87,1659,
  	8,87,1,87,3,87,1662,8,87,1,88,1,88,3,88,1666,8,88,1,88,1,88,3,88,1670,
  	8,88,1,88,1,88,3,88,1674,8,88,1,88,1,88,3,88,1678,8,88,1,88,1,88,3,88,
  	1682,8,88,1,88,3,88,1685,8,88,1,88,3,88,1688,8,88,1,88,1,88,3,88,1692,
  	8,88,1,88,1,88,3,88,1696,8,88,1,88,1,88,3,88,1700,8,88,1,88,1,88,3,88,
  	1704,8,88,3,88,1706,8,88,1,88,1,88,1,89,1,89,3,89,1712,8,89,1,89,3,89,
  	1715,8,89,1,89,3,89,1718,8,89,1,89,1,89,1,90,1,90,3,90,1724,8,90,1,90,
  	3,90,1727,8,90,1,90,3,90,1730,8,90,1,90,1,90,1,91,1,91,1,92,1,92,1,93,
  	1,93,1,94,1,94,1,95,1,95,1,96,1,96,1,96,1,96,1,96,5,96,1749,8,96,10,96,
  	12,96,1752,9,96,1,97,1,97,1,97,1,97,1,97,5,97,1759,8,97,10,97,12,97,1762,
  	9,97,1,98,1,98,1,98,1,98,1,98,5,98,1769,8,98,10,98,12,98,1772,9,98,1,
  	99,1,99,3,99,1776,8,99,5,99,1778,8,99,10,99,12,99,1781,9,99,1,99,1,99,
  	1,100,1,100,3,100,1787,8,100,1,100,1,100,3,100,1791,8,100,1,100,1,100,
  	3,100,1795,8,100,1,100,1,100,3,100,1799,8,100,1,100,1,100,3,100,1803,
  	8,100,1,100,1,100,1,100,1,100,1,100,1,100,3,100,1811,8,100,1,100,1,100,
  	3,100,1815,8,100,1,100,1,100,3,100,1819,8,100,1,100,1,100,3,100,1823,
  	8,100,1,100,1,100,4,100,1827,8,100,11,100,12,100,1828,1,100,1,100,3,100,
  	1833,8,100,1,101,1,101,1,102,1,102,3,102,1839,8,102,1,102,1,102,3,102,
  	1843,8,102,1,102,5,102,1846,8,102,10,102,12,102,1849,9,102,1,103,1,103,
  	3,103,1853,8,103,1,103,1,103,3,103,1857,8,103,1,103,5,103,1860,8,103,
  	10,103,12,103,1863,9,103,1,104,1,104,3,104,1867,8,104,1,104,1,104,3,104,
  	1871,8,104,1,104,1,104,5,104,1875,8,104,10,104,12,104,1878,9,104,1,105,
  	1,105,1,106,1,106,3,106,1884,8,106,1,106,1,106,3,106,1888,8,106,1,106,
  	1,106,5,106,1892,8,106,10,106,12,106,1895,9,106,1,107,1,107,1,108,1,108,
  	3,108,1901,8,108,1,108,1,108,3,108,1905,8,108,1,108,1,108,5,108,1909,
  	8,108,10,108,12,108,1912,9,108,1,109,1,109,1,110,1,110,3,110,1918,8,110,
  	1,110,1,110,3,110,1922,8,110,1,110,5,110,1925,8,110,10,110,12,110,1928,
  	9,110,1,111,1,111,3,111,1932,8,111,5,111,1934,8,111,10,111,12,111,1937,
  	9,111,1,111,1,111,3,111,1941,8,111,1,111,3,111,1944,8,111,1,112,1,112,
  	1,112,4,112,1949,8,112,11,112,12,112,1950,1,112,3,112,1954,8,112,1,113,
  	1,113,1,113,3,113,1959,8,113,1,113,1,113,1,113,1,113,1,113,1,113,1,113,
  	3,113,1968,8,113,1,113,1,113,3,113,1972,8,113,1,113,3,113,1975,8,113,
  	1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,1,114,3,114,
  	1988,8,114,1,114,3,114,1991,8,114,1,114,1,114,1,115,3,115,1996,8,115,
  	1,115,1,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,
  	3,116,2010,8,116,1,117,1,117,3,117,2014,8,117,1,117,5,117,2017,8,117,
  	10,117,12,117,2020,9,117,1,118,1,118,1,118,1,118,1,118,1,118,1,118,1,
  	118,1,118,3,118,2031,8,118,1,119,1,119,1,119,1,119,1,119,1,119,3,119,
  	2039,8,119,1,120,1,120,1,121,1,121,3,121,2045,8,121,1,121,1,121,3,121,
  	2049,8,121,1,121,1,121,3,121,2053,8,121,5,121,2055,8,121,10,121,12,121,
  	2058,9,121,3,121,2060,8,121,1,121,1,121,1,122,1,122,3,122,2066,8,122,
  	1,122,3,122,2069,8,122,1,123,1,123,3,123,2073,8,123,1,123,1,123,3,123,
  	2077,8,123,1,123,1,123,3,123,2081,8,123,1,123,1,123,3,123,2085,8,123,
  	5,123,2087,8,123,10,123,12,123,2090,9,123,1,123,1,123,1,124,1,124,3,124,
  	2096,8,124,1,124,3,124,2099,8,124,1,124,1,124,3,124,2103,8,124,1,124,
  	1,124,1,125,1,125,3,125,2109,8,125,1,125,1,125,3,125,2113,8,125,1,125,
  	1,125,1,126,1,126,3,126,2119,8,126,1,126,1,126,3,126,2123,8,126,1,126,
  	1,126,3,126,2127,8,126,1,126,1,126,1,126,3,126,2132,8,126,1,126,1,126,
  	3,126,2136,8,126,1,126,1,126,3,126,2140,8,126,3,126,2142,8,126,1,126,
  	1,126,3,126,2146,8,126,1,126,1,126,3,126,2150,8,126,1,126,1,126,3,126,
  	2154,8,126,5,126,2156,8,126,10,126,12,126,2159,9,126,3,126,2161,8,126,
  	1,126,1,126,3,126,2165,8,126,1,127,1,127,1,128,1,128,3,128,2171,8,128,
  	1,128,1,128,1,128,3,128,2176,8,128,3,128,2178,8,128,1,128,1,128,1,129,
  	1,129,3,129,2184,8,129,1,129,4,129,2187,8,129,11,129,12,129,2188,1,130,
  	1,130,3,130,2193,8,130,1,130,1,130,3,130,2197,8,130,1,130,1,130,3,130,
  	2201,8,130,1,130,1,130,3,130,2205,8,130,1,130,3,130,2208,8,130,1,130,
  	3,130,2211,8,130,1,130,1,130,1,131,1,131,3,131,2217,8,131,1,131,1,131,
  	3,131,2221,8,131,1,131,1,131,3,131,2225,8,131,1,131,1,131,3,131,2229,
  	8,131,1,131,3,131,2232,8,131,1,131,3,131,2235,8,131,1,131,1,131,1,132,
  	1,132,3,132,2241,8,132,1,132,1,132,3,132,2245,8,132,1,133,1,133,3,133,
  	2249,8,133,1,133,4,133,2252,8,133,11,133,12,133,2253,1,133,1,133,3,133,
  	2258,8,133,1,133,1,133,3,133,2262,8,133,1,133,4,133,2265,8,133,11,133,
  	12,133,2266,3,133,2269,8,133,1,133,3,133,2272,8,133,1,133,1,133,3,133,
  	2276,8,133,1,133,3,133,2279,8,133,1,133,3,133,2282,8,133,1,133,1,133,
  	1,134,1,134,3,134,2288,8,134,1,134,1,134,3,134,2292,8,134,1,134,1,134,
  	3,134,2296,8,134,1,134,1,134,1,135,1,135,1,136,1,136,3,136,2304,8,136,
  	1,137,1,137,1,137,3,137,2309,8,137,1,138,1,138,3,138,2313,8,138,1,138,
  	1,138,1,139,1,139,1,140,1,140,1,141,1,141,1,142,1,142,1,143,1,143,1,143,
  	1,143,1,143,3,143,2330,8,143,1,144,1,144,1,145,1,145,1,146,1,146,1,147,
  	1,147,1,147,0,1,72,148,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,0,11,
  	2,0,60,60,62,62,1,0,107,110,2,0,6,6,13,17,1,0,19,20,2,0,21,21,118,118,
  	2,0,22,23,101,101,1,0,127,128,8,0,48,48,50,50,56,59,70,70,74,74,121,121,
  	129,129,133,133,2,0,14,14,27,30,2,0,16,16,31,34,2,0,35,45,118,118,2648,
  	0,296,1,0,0,0,2,316,1,0,0,0,4,348,1,0,0,0,6,350,1,0,0,0,8,372,1,0,0,0,
  	10,414,1,0,0,0,12,416,1,0,0,0,14,446,1,0,0,0,16,467,1,0,0,0,18,478,1,
  	0,0,0,20,484,1,0,0,0,22,511,1,0,0,0,24,515,1,0,0,0,26,519,1,0,0,0,28,
  	531,1,0,0,0,30,543,1,0,0,0,32,586,1,0,0,0,34,600,1,0,0,0,36,644,1,0,0,
  	0,38,646,1,0,0,0,40,669,1,0,0,0,42,679,1,0,0,0,44,708,1,0,0,0,46,748,
  	1,0,0,0,48,802,1,0,0,0,50,810,1,0,0,0,52,816,1,0,0,0,54,822,1,0,0,0,56,
  	834,1,0,0,0,58,836,1,0,0,0,60,847,1,0,0,0,62,851,1,0,0,0,64,857,1,0,0,
  	0,66,865,1,0,0,0,68,879,1,0,0,0,70,883,1,0,0,0,72,951,1,0,0,0,74,960,
  	1,0,0,0,76,967,1,0,0,0,78,975,1,0,0,0,80,977,1,0,0,0,82,979,1,0,0,0,84,
  	995,1,0,0,0,86,999,1,0,0,0,88,1001,1,0,0,0,90,1009,1,0,0,0,92,1013,1,
  	0,0,0,94,1036,1,0,0,0,96,1050,1,0,0,0,98,1054,1,0,0,0,100,1101,1,0,0,
  	0,102,1107,1,0,0,0,104,1119,1,0,0,0,106,1137,1,0,0,0,108,1143,1,0,0,0,
  	110,1145,1,0,0,0,112,1181,1,0,0,0,114,1192,1,0,0,0,116,1205,1,0,0,0,118,
  	1215,1,0,0,0,120,1221,1,0,0,0,122,1243,1,0,0,0,124,1245,1,0,0,0,126,1263,
  	1,0,0,0,128,1275,1,0,0,0,130,1295,1,0,0,0,132,1303,1,0,0,0,134,1310,1,
  	0,0,0,136,1354,1,0,0,0,138,1363,1,0,0,0,140,1365,1,0,0,0,142,1380,1,0,
  	0,0,144,1384,1,0,0,0,146,1388,1,0,0,0,148,1395,1,0,0,0,150,1399,1,0,0,
  	0,152,1424,1,0,0,0,154,1426,1,0,0,0,156,1442,1,0,0,0,158,1444,1,0,0,0,
  	160,1468,1,0,0,0,162,1518,1,0,0,0,164,1520,1,0,0,0,166,1550,1,0,0,0,168,
  	1591,1,0,0,0,170,1612,1,0,0,0,172,1622,1,0,0,0,174,1628,1,0,0,0,176,1663,
  	1,0,0,0,178,1709,1,0,0,0,180,1721,1,0,0,0,182,1733,1,0,0,0,184,1735,1,
  	0,0,0,186,1737,1,0,0,0,188,1739,1,0,0,0,190,1741,1,0,0,0,192,1743,1,0,
  	0,0,194,1753,1,0,0,0,196,1763,1,0,0,0,198,1779,1,0,0,0,200,1832,1,0,0,
  	0,202,1834,1,0,0,0,204,1836,1,0,0,0,206,1850,1,0,0,0,208,1864,1,0,0,0,
  	210,1879,1,0,0,0,212,1881,1,0,0,0,214,1896,1,0,0,0,216,1898,1,0,0,0,218,
  	1913,1,0,0,0,220,1915,1,0,0,0,222,1935,1,0,0,0,224,1945,1,0,0,0,226,1974,
  	1,0,0,0,228,1987,1,0,0,0,230,1995,1,0,0,0,232,2009,1,0,0,0,234,2011,1,
  	0,0,0,236,2030,1,0,0,0,238,2038,1,0,0,0,240,2040,1,0,0,0,242,2042,1,0,
  	0,0,244,2063,1,0,0,0,246,2070,1,0,0,0,248,2095,1,0,0,0,250,2106,1,0,0,
  	0,252,2164,1,0,0,0,254,2166,1,0,0,0,256,2177,1,0,0,0,258,2181,1,0,0,0,
  	260,2190,1,0,0,0,262,2214,1,0,0,0,264,2238,1,0,0,0,266,2268,1,0,0,0,268,
  	2285,1,0,0,0,270,2299,1,0,0,0,272,2303,1,0,0,0,274,2305,1,0,0,0,276,2310,
  	1,0,0,0,278,2316,1,0,0,0,280,2318,1,0,0,0,282,2320,1,0,0,0,284,2322,1,
  	0,0,0,286,2329,1,0,0,0,288,2331,1,0,0,0,290,2333,1,0,0,0,292,2335,1,0,
  	0,0,294,2337,1,0,0,0,296,307,3,2,1,0,297,299,5,150,0,0,298,297,1,0,0,
  	0,298,299,1,0,0,0,299,300,1,0,0,0,300,302,5,1,0,0,301,303,5,150,0,0,302,
  	301,1,0,0,0,302,303,1,0,0,0,303,304,1,0,0,0,304,306,3,2,1,0,305,298,1,
  	0,0,0,306,309,1,0,0,0,307,305,1,0,0,0,307,308,1,0,0,0,308,311,1,0,0,0,
  	309,307,1,0,0,0,310,312,5,150,0,0,311,310,1,0,0,0,311,312,1,0,0,0,312,
  	313,1,0,0,0,313,314,5,0,0,1,314,1,1,0,0,0,315,317,3,78,39,0,316,315,1,
  	0,0,0,316,317,1,0,0,0,317,319,1,0,0,0,318,320,5,150,0,0,319,318,1,0,0,
  	0,319,320,1,0,0,0,320,321,1,0,0,0,321,326,3,4,2,0,322,324,5,150,0,0,323,
  	322,1,0,0,0,323,324,1,0,0,0,324,325,1,0,0,0,325,327,5,1,0,0,326,323,1,
  	0,0,0,326,327,1,0,0,0,327,3,1,0,0,0,328,349,3,92,46,0,329,349,3,42,21,
  	0,330,349,3,44,22,0,331,349,3,46,23,0,332,349,3,50,25,0,333,349,3,52,
  	26,0,334,349,3,54,27,0,335,349,3,6,3,0,336,349,3,12,6,0,337,349,3,14,
  	7,0,338,349,3,26,13,0,339,349,3,30,15,0,340,349,3,28,14,0,341,349,3,84,
  	42,0,342,349,3,86,43,0,343,349,3,16,8,0,344,349,3,18,9,0,345,349,3,20,
  	10,0,346,349,3,22,11,0,347,349,3,24,12,0,348,328,1,0,0,0,348,329,1,0,
  	0,0,348,330,1,0,0,0,348,331,1,0,0,0,348,332,1,0,0,0,348,333,1,0,0,0,348,
  	334,1,0,0,0,348,335,1,0,0,0,348,336,1,0,0,0,348,337,1,0,0,0,348,338,1,
  	0,0,0,348,339,1,0,0,0,348,340,1,0,0,0,348,341,1,0,0,0,348,342,1,0,0,0,
  	348,343,1,0,0,0,348,344,1,0,0,0,348,345,1,0,0,0,348,346,1,0,0,0,348,347,
  	1,0,0,0,349,5,1,0,0,0,350,351,5,53,0,0,351,352,5,150,0,0,352,361,3,284,
  	142,0,353,355,5,150,0,0,354,353,1,0,0,0,354,355,1,0,0,0,355,356,1,0,0,
  	0,356,358,3,8,4,0,357,359,5,150,0,0,358,357,1,0,0,0,358,359,1,0,0,0,359,
  	362,1,0,0,0,360,362,5,150,0,0,361,354,1,0,0,0,361,360,1,0,0,0,362,363,
  	1,0,0,0,363,364,5,54,0,0,364,365,5,150,0,0,365,370,3,10,5,0,366,368,5,
  	150,0,0,367,366,1,0,0,0,367,368,1,0,0,0,368,369,1,0,0,0,369,371,3,38,
  	19,0,370,367,1,0,0,0,370,371,1,0,0,0,371,7,1,0,0,0,372,374,5,2,0,0,373,
  	375,5,150,0,0,374,373,1,0,0,0,374,375,1,0,0,0,375,376,1,0,0,0,376,387,
  	3,284,142,0,377,379,5,150,0,0,378,377,1,0,0,0,378,379,1,0,0,0,379,380,
  	1,0,0,0,380,382,5,3,0,0,381,383,5,150,0,0,382,381,1,0,0,0,382,383,1,0,
  	0,0,383,384,1,0,0,0,384,386,3,284,142,0,385,378,1,0,0,0,386,389,1,0,0,
  	0,387,385,1,0,0,0,387,388,1,0,0,0,388,391,1,0,0,0,389,387,1,0,0,0,390,
  	392,5,150,0,0,391,390,1,0,0,0,391,392,1,0,0,0,392,393,1,0,0,0,393,394,
  	5,4,0,0,394,9,1,0,0,0,395,415,3,36,18,0,396,398,5,2,0,0,397,399,5,150,
  	0,0,398,397,1,0,0,0,398,399,1,0,0,0,399,400,1,0,0,0,400,402,3,92,46,0,
  	401,403,5,150,0,0,402,401,1,0,0,0,402,403,1,0,0,0,403,404,1,0,0,0,404,
  	405,5,4,0,0,405,415,1,0,0,0,406,415,3,270,135,0,407,408,3,270,135,0,408,
  	410,5,5,0,0,409,411,5,150,0,0,410,409,1,0,0,0,410,411,1,0,0,0,411,412,
  	1,0,0,0,412,413,3,284,142,0,413,415,1,0,0,0,414,395,1,0,0,0,414,396,1,
  	0,0,0,414,406,1,0,0,0,414,407,1,0,0,0,415,11,1,0,0,0,416,417,5,53,0,0,
  	417,418,5,150,0,0,418,419,3,284,142,0,419,420,5,150,0,0,420,421,5,54,
  	0,0,421,422,5,150,0,0,422,424,5,2,0,0,423,425,5,150,0,0,424,423,1,0,0,
  	0,424,425,1,0,0,0,425,426,1,0,0,0,426,437,5,136,0,0,427,429,5,150,0,0,
  	428,427,1,0,0,0,428,429,1,0,0,0,429,430,1,0,0,0,430,432,5,3,0,0,431,433,
  	5,150,0,0,432,431,1,0,0,0,432,433,1,0,0,0,433,434,1,0,0,0,434,436,5,136,
  	0,0,435,428,1,0,0,0,436,439,1,0,0,0,437,435,1,0,0,0,437,438,1,0,0,0,438,
  	440,1,0,0,0,439,437,1,0,0,0,440,441,5,4,0,0,441,442,5,150,0,0,442,443,
  	5,104,0,0,443,444,5,150,0,0,444,445,5,55,0,0,445,13,1,0,0,0,446,447,5,
  	53,0,0,447,448,5,150,0,0,448,450,5,2,0,0,449,451,5,150,0,0,450,449,1,
  	0,0,0,450,451,1,0,0,0,451,452,1,0,0,0,452,454,3,92,46,0,453,455,5,150,
  	0,0,454,453,1,0,0,0,454,455,1,0,0,0,455,456,1,0,0,0,456,457,5,4,0,0,457,
  	458,5,150,0,0,458,459,5,71,0,0,459,460,5,150,0,0,460,465,5,136,0,0,461,
  	463,5,150,0,0,462,461,1,0,0,0,462,463,1,0,0,0,463,464,1,0,0,0,464,466,
  	3,38,19,0,465,462,1,0,0,0,465,466,1,0,0,0,466,15,1,0,0,0,467,468,5,56,
  	0,0,468,469,5,150,0,0,469,470,5,58,0,0,470,471,5,150,0,0,471,476,5,136,
  	0,0,472,474,5,150,0,0,473,472,1,0,0,0,473,474,1,0,0,0,474,475,1,0,0,0,
  	475,477,3,38,19,0,476,473,1,0,0,0,476,477,1,0,0,0,477,17,1,0,0,0,478,
  	479,5,57,0,0,479,480,5,150,0,0,480,481,5,58,0,0,481,482,5,150,0,0,482,
  	483,5,136,0,0,483,19,1,0,0,0,484,485,5,46,0,0,485,486,5,150,0,0,486,493,
  	5,136,0,0,487,488,5,150,0,0,488,489,5,102,0,0,489,490,5,150,0,0,490,491,
  	3,284,142,0,491,492,5,150,0,0,492,494,1,0,0,0,493,487,1,0,0,0,493,494,
  	1,0,0,0,494,509,1,0,0,0,495,497,5,150,0,0,496,495,1,0,0,0,496,497,1,0,
  	0,0,497,498,1,0,0,0,498,500,5,2,0,0,499,501,5,150,0,0,500,499,1,0,0,0,
  	500,501,1,0,0,0,501,502,1,0,0,0,502,503,5,47,0,0,503,504,5,150,0,0,504,
  	506,5,136,0,0,505,507,5,150,0,0,506,505,1,0,0,0,506,507,1,0,0,0,507,508,
  	1,0,0,0,508,510,5,4,0,0,509,496,1,0,0,0,509,510,1,0,0,0,510,21,1,0,0,
  	0,511,512,5,96,0,0,512,513,5,150,0,0,513,514,3,284,142,0,514,23,1,0,0,
  	0,515,516,5,48,0,0,516,517,5,150,0,0,517,518,3,284,142,0,518,25,1,0,0,
  	0,519,520,5,49,0,0,520,521,5,150,0,0,521,523,3,286,143,0,522,524,5,150,
  	0,0,523,522,1,0,0,0,523,524,1,0,0,0,524,525,1,0,0,0,525,527,5,6,0,0,526,
  	528,5,150,0,0,527,526,1,0,0,0,527,528,1,0,0,0,528,529,1,0,0,0,529,530,
  	3,190,95,0,530,27,1,0,0,0,531,532,5,50,0,0,532,533,5,150,0,0,533,534,
  	5,94,0,0,534,535,5,150,0,0,535,536,5,60,0,0,536,537,5,150,0,0,537,538,
  	3,284,142,0,538,539,5,150,0,0,539,540,5,125,0,0,540,541,5,150,0,0,541,
  	542,5,136,0,0,542,29,1,0,0,0,543,544,5,92,0,0,544,545,5,150,0,0,545,546,
  	5,51,0,0,546,547,5,150,0,0,547,549,3,254,127,0,548,550,5,150,0,0,549,
  	548,1,0,0,0,549,550,1,0,0,0,550,551,1,0,0,0,551,553,5,2,0,0,552,554,5,
  	150,0,0,553,552,1,0,0,0,553,554,1,0,0,0,554,556,1,0,0,0,555,557,3,32,
  	16,0,556,555,1,0,0,0,556,557,1,0,0,0,557,559,1,0,0,0,558,560,5,150,0,
  	0,559,558,1,0,0,0,559,560,1,0,0,0,560,562,1,0,0,0,561,563,3,34,17,0,562,
  	561,1,0,0,0,562,563,1,0,0,0,563,574,1,0,0,0,564,566,5,150,0,0,565,564,
  	1,0,0,0,565,566,1,0,0,0,566,567,1,0,0,0,567,569,5,3,0,0,568,570,5,150,
  	0,0,569,568,1,0,0,0,569,570,1,0,0,0,570,571,1,0,0,0,571,573,3,34,17,0,
  	572,565,1,0,0,0,573,576,1,0,0,0,574,572,1,0,0,0,574,575,1,0,0,0,575,578,
  	1,0,0,0,576,574,1,0,0,0,577,579,5,150,0,0,578,577,1,0,0,0,578,579,1,0,
  	0,0,579,580,1,0,0,0,580,581,5,4,0,0,581,582,5,150,0,0,582,583,5,102,0,
  	0,583,584,5,150,0,0,584,585,3,190,95,0,585,31,1,0,0,0,586,597,3,286,143,
  	0,587,589,5,150,0,0,588,587,1,0,0,0,588,589,1,0,0,0,589,590,1,0,0,0,590,
  	592,5,3,0,0,591,593,5,150,0,0,592,591,1,0,0,0,592,593,1,0,0,0,593,594,
  	1,0,0,0,594,596,3,286,143,0,595,588,1,0,0,0,596,599,1,0,0,0,597,595,1,
  	0,0,0,597,598,1,0,0,0,598,33,1,0,0,0,599,597,1,0,0,0,600,602,3,286,143,
  	0,601,603,5,150,0,0,602,601,1,0,0,0,602,603,1,0,0,0,603,604,1,0,0,0,604,
  	605,5,120,0,0,605,607,5,6,0,0,606,608,5,150,0,0,607,606,1,0,0,0,607,608,
  	1,0,0,0,608,609,1,0,0,0,609,610,3,238,119,0,610,35,1,0,0,0,611,613,5,
  	7,0,0,612,614,5,150,0,0,613,612,1,0,0,0,613,614,1,0,0,0,614,615,1,0,0,
  	0,615,626,5,136,0,0,616,618,5,150,0,0,617,616,1,0,0,0,617,618,1,0,0,0,
  	618,619,1,0,0,0,619,621,5,3,0,0,620,622,5,150,0,0,621,620,1,0,0,0,621,
  	622,1,0,0,0,622,623,1,0,0,0,623,625,5,136,0,0,624,617,1,0,0,0,625,628,
  	1,0,0,0,626,624,1,0,0,0,626,627,1,0,0,0,627,629,1,0,0,0,628,626,1,0,0,
  	0,629,645,5,8,0,0,630,645,5,136,0,0,631,633,5,52,0,0,632,634,5,150,0,
  	0,633,632,1,0,0,0,633,634,1,0,0,0,634,635,1,0,0,0,635,637,5,2,0,0,636,
  	638,5,150,0,0,637,636,1,0,0,0,637,638,1,0,0,0,638,639,1,0,0,0,639,641,
  	5,136,0,0,640,642,5,150,0,0,641,640,1,0,0,0,641,642,1,0,0,0,642,643,1,
  	0,0,0,643,645,5,4,0,0,644,611,1,0,0,0,644,630,1,0,0,0,644,631,1,0,0,0,
  	645,37,1,0,0,0,646,648,5,2,0,0,647,649,5,150,0,0,648,647,1,0,0,0,648,
  	649,1,0,0,0,649,650,1,0,0,0,650,661,3,40,20,0,651,653,5,150,0,0,652,651,
  	1,0,0,0,652,653,1,0,0,0,653,654,1,0,0,0,654,656,5,3,0,0,655,657,5,150,
  	0,0,656,655,1,0,0,0,656,657,1,0,0,0,657,658,1,0,0,0,658,660,3,40,20,0,
  	659,652,1,0,0,0,660,663,1,0,0,0,661,659,1,0,0,0,661,662,1,0,0,0,662,665,
  	1,0,0,0,663,661,1,0,0,0,664,666,5,150,0,0,665,664,1,0,0,0,665,666,1,0,
  	0,0,666,667,1,0,0,0,667,668,5,4,0,0,668,39,1,0,0,0,669,671,3,286,143,
  	0,670,672,5,150,0,0,671,670,1,0,0,0,671,672,1,0,0,0,672,673,1,0,0,0,673,
  	675,5,6,0,0,674,676,5,150,0,0,675,674,1,0,0,0,675,676,1,0,0,0,676,677,
  	1,0,0,0,677,678,3,238,119,0,678,41,1,0,0,0,679,680,5,92,0,0,680,681,5,
  	150,0,0,681,682,5,59,0,0,682,683,5,150,0,0,683,684,5,60,0,0,684,685,5,
  	150,0,0,685,687,3,284,142,0,686,688,5,150,0,0,687,686,1,0,0,0,687,688,
  	1,0,0,0,688,689,1,0,0,0,689,691,5,2,0,0,690,692,5,150,0,0,691,690,1,0,
  	0,0,691,692,1,0,0,0,692,693,1,0,0,0,693,695,3,66,33,0,694,696,5,150,0,
  	0,695,694,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,699,5,3,0,0,698,
  	700,5,150,0,0,699,698,1,0,0,0,699,700,1,0,0,0,700,701,1,0,0,0,701,702,
  	3,70,35,0,702,704,1,0,0,0,703,705,5,150,0,0,704,703,1,0,0,0,704,705,1,
  	0,0,0,705,706,1,0,0,0,706,707,5,4,0,0,707,43,1,0,0,0,708,709,5,92,0,0,
  	709,710,5,150,0,0,710,711,5,70,0,0,711,712,5,150,0,0,712,713,5,60,0,0,
  	713,714,5,150,0,0,714,716,3,284,142,0,715,717,5,150,0,0,716,715,1,0,0,
  	0,716,717,1,0,0,0,717,718,1,0,0,0,718,720,5,2,0,0,719,721,5,150,0,0,720,
  	719,1,0,0,0,720,721,1,0,0,0,721,722,1,0,0,0,722,724,3,48,24,0,723,725,
  	5,150,0,0,724,723,1,0,0,0,724,725,1,0,0,0,725,734,1,0,0,0,726,728,5,3,
  	0,0,727,729,5,150,0,0,728,727,1,0,0,0,728,729,1,0,0,0,729,730,1,0,0,0,
  	730,732,3,66,33,0,731,733,5,150,0,0,732,731,1,0,0,0,732,733,1,0,0,0,733,
  	735,1,0,0,0,734,726,1,0,0,0,734,735,1,0,0,0,735,744,1,0,0,0,736,738,5,
  	3,0,0,737,739,5,150,0,0,738,737,1,0,0,0,738,739,1,0,0,0,739,740,1,0,0,
  	0,740,742,3,286,143,0,741,743,5,150,0,0,742,741,1,0,0,0,742,743,1,0,0,
  	0,743,745,1,0,0,0,744,736,1,0,0,0,744,745,1,0,0,0,745,746,1,0,0,0,746,
  	747,5,4,0,0,747,45,1,0,0,0,748,749,5,92,0,0,749,750,5,150,0,0,750,751,
  	5,70,0,0,751,752,5,150,0,0,752,753,5,60,0,0,753,754,5,150,0,0,754,755,
  	5,61,0,0,755,756,5,150,0,0,756,758,3,284,142,0,757,759,5,150,0,0,758,
  	757,1,0,0,0,758,759,1,0,0,0,759,760,1,0,0,0,760,762,5,2,0,0,761,763,5,
  	150,0,0,762,761,1,0,0,0,762,763,1,0,0,0,763,764,1,0,0,0,764,766,3,48,
  	24,0,765,767,5,150,0,0,766,765,1,0,0,0,766,767,1,0,0,0,767,773,1,0,0,
  	0,768,770,5,3,0,0,769,771,5,150,0,0,770,769,1,0,0,0,770,771,1,0,0,0,771,
  	772,1,0,0,0,772,774,3,48,24,0,773,768,1,0,0,0,774,775,1,0,0,0,775,773,
  	1,0,0,0,775,776,1,0,0,0,776,778,1,0,0,0,777,779,5,150,0,0,778,777,1,0,
  	0,0,778,779,1,0,0,0,779,788,1,0,0,0,780,782,5,3,0,0,781,783,5,150,0,0,
  	782,781,1,0,0,0,782,783,1,0,0,0,783,784,1,0,0,0,784,786,3,66,33,0,785,
  	787,5,150,0,0,786,785,1,0,0,0,786,787,1,0,0,0,787,789,1,0,0,0,788,780,
  	1,0,0,0,788,789,1,0,0,0,789,798,1,0,0,0,790,792,5,3,0,0,791,793,5,150,
  	0,0,792,791,1,0,0,0,792,793,1,0,0,0,793,794,1,0,0,0,794,796,3,286,143,
  	0,795,797,5,150,0,0,796,795,1,0,0,0,796,797,1,0,0,0,797,799,1,0,0,0,798,
  	790,1,0,0,0,798,799,1,0,0,0,799,800,1,0,0,0,800,801,5,4,0,0,801,47,1,
  	0,0,0,802,803,5,54,0,0,803,804,5,150,0,0,804,805,3,284,142,0,805,806,
  	5,150,0,0,806,807,5,71,0,0,807,808,5,150,0,0,808,809,3,284,142,0,809,
  	49,1,0,0,0,810,811,5,92,0,0,811,812,5,150,0,0,812,813,5,62,0,0,813,814,
  	5,150,0,0,814,815,3,284,142,0,815,51,1,0,0,0,816,817,5,63,0,0,817,818,
  	5,150,0,0,818,819,7,0,0,0,819,820,5,150,0,0,820,821,3,284,142,0,821,53,
  	1,0,0,0,822,823,5,64,0,0,823,824,5,150,0,0,824,825,5,60,0,0,825,826,5,
  	150,0,0,826,827,3,284,142,0,827,828,5,150,0,0,828,829,3,56,28,0,829,55,
  	1,0,0,0,830,835,3,58,29,0,831,835,3,60,30,0,832,835,3,62,31,0,833,835,
  	3,64,32,0,834,830,1,0,0,0,834,831,1,0,0,0,834,832,1,0,0,0,834,833,1,0,
  	0,0,835,57,1,0,0,0,836,837,5,67,0,0,837,838,5,150,0,0,838,839,3,278,139,
  	0,839,840,5,150,0,0,840,845,3,72,36,0,841,842,5,150,0,0,842,843,5,65,
  	0,0,843,844,5,150,0,0,844,846,3,190,95,0,845,841,1,0,0,0,845,846,1,0,
  	0,0,846,59,1,0,0,0,847,848,5,63,0,0,848,849,5,150,0,0,849,850,3,278,139,
  	0,850,61,1,0,0,0,851,852,5,66,0,0,852,853,5,150,0,0,853,854,5,71,0,0,
  	854,855,5,150,0,0,855,856,3,284,142,0,856,63,1,0,0,0,857,858,5,66,0,0,
  	858,859,5,150,0,0,859,860,3,278,139,0,860,861,5,150,0,0,861,862,5,71,
  	0,0,862,863,5,150,0,0,863,864,3,278,139,0,864,65,1,0,0,0,865,876,3,68,
  	34,0,866,868,5,150,0,0,867,866,1,0,0,0,867,868,1,0,0,0,868,869,1,0,0,
  	0,869,871,5,3,0,0,870,872,5,150,0,0,871,870,1,0,0,0,871,872,1,0,0,0,872,
  	873,1,0,0,0,873,875,3,68,34,0,874,867,1,0,0,0,875,878,1,0,0,0,876,874,
  	1,0,0,0,876,877,1,0,0,0,877,67,1,0,0,0,878,876,1,0,0,0,879,880,3,278,
  	139,0,880,881,5,150,0,0,881,882,3,72,36,0,882,69,1,0,0,0,883,884,5,68,
  	0,0,884,885,5,150,0,0,885,887,5,69,0,0,886,888,5,150,0,0,887,886,1,0,
  	0,0,887,888,1,0,0,0,888,889,1,0,0,0,889,891,5,2,0,0,890,892,5,150,0,0,
  	891,890,1,0,0,0,891,892,1,0,0,0,892,893,1,0,0,0,893,895,3,278,139,0,894,
  	896,5,150,0,0,895,894,1,0,0,0,895,896,1,0,0,0,896,897,1,0,0,0,897,898,
  	5,4,0,0,898,71,1,0,0,0,899,900,6,36,-1,0,900,952,3,286,143,0,901,903,
  	5,85,0,0,902,904,5,150,0,0,903,902,1,0,0,0,903,904,1,0,0,0,904,905,1,
  	0,0,0,905,907,5,2,0,0,906,908,5,150,0,0,907,906,1,0,0,0,907,908,1,0,0,
  	0,908,909,1,0,0,0,909,911,3,66,33,0,910,912,5,150,0,0,911,910,1,0,0,0,
  	911,912,1,0,0,0,912,913,1,0,0,0,913,914,5,4,0,0,914,952,1,0,0,0,915,917,
  	3,286,143,0,916,918,5,150,0,0,917,916,1,0,0,0,917,918,1,0,0,0,918,919,
  	1,0,0,0,919,921,5,2,0,0,920,922,5,150,0,0,921,920,1,0,0,0,921,922,1,0,
  	0,0,922,923,1,0,0,0,923,925,3,66,33,0,924,926,5,150,0,0,925,924,1,0,0,
  	0,925,926,1,0,0,0,926,927,1,0,0,0,927,928,5,4,0,0,928,952,1,0,0,0,929,
  	931,3,286,143,0,930,932,5,150,0,0,931,930,1,0,0,0,931,932,1,0,0,0,932,
  	933,1,0,0,0,933,935,5,2,0,0,934,936,5,150,0,0,935,934,1,0,0,0,935,936,
  	1,0,0,0,936,937,1,0,0,0,937,939,3,72,36,0,938,940,5,150,0,0,939,938,1,
  	0,0,0,939,940,1,0,0,0,940,941,1,0,0,0,941,943,5,3,0,0,942,944,5,150,0,
  	0,943,942,1,0,0,0,943,944,1,0,0,0,944,945,1,0,0,0,945,947,3,72,36,0,946,
  	948,5,150,0,0,947,946,1,0,0,0,947,948,1,0,0,0,948,949,1,0,0,0,949,950,
  	5,4,0,0,950,952,1,0,0,0,951,899,1,0,0,0,951,901,1,0,0,0,951,915,1,0,0,
  	0,951,929,1,0,0,0,952,957,1,0,0,0,953,954,10,4,0,0,954,956,3,74,37,0,
  	955,953,1,0,0,0,956,959,1,0,0,0,957,955,1,0,0,0,957,958,1,0,0,0,958,73,
  	1,0,0,0,959,957,1,0,0,0,960,964,3,76,38,0,961,963,3,76,38,0,962,961,1,
  	0,0,0,963,966,1,0,0,0,964,962,1,0,0,0,964,965,1,0,0,0,965,75,1,0,0,0,
  	966,964,1,0,0,0,967,969,5,7,0,0,968,970,3,280,140,0,969,968,1,0,0,0,969,
  	970,1,0,0,0,970,971,1,0,0,0,971,972,5,8,0,0,972,77,1,0,0,0,973,976,3,
  	80,40,0,974,976,3,82,41,0,975,973,1,0,0,0,975,974,1,0,0,0,976,79,1,0,
  	0,0,977,978,5,72,0,0,978,81,1,0,0,0,979,980,5,73,0,0,980,83,1,0,0,0,981,
  	982,5,74,0,0,982,983,5,150,0,0,983,996,5,75,0,0,984,985,5,74,0,0,985,
  	986,5,150,0,0,986,987,5,75,0,0,987,988,5,150,0,0,988,989,5,76,0,0,989,
  	990,5,150,0,0,990,996,5,77,0,0,991,996,5,79,0,0,992,996,5,80,0,0,993,
  	996,5,81,0,0,994,996,5,82,0,0,995,981,1,0,0,0,995,984,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,85,1,0,0,
  	0,997,1000,3,88,44,0,998,1000,3,90,45,0,999,997,1,0,0,0,999,998,1,0,0,
  	0,1000,87,1,0,0,0,1001,1002,5,87,0,0,1002,1003,5,150,0,0,1003,1004,5,
  	84,0,0,1004,1007,5,150,0,0,1005,1008,5,136,0,0,1006,1008,3,270,135,0,
  	1007,1005,1,0,0,0,1007,1006,1,0,0,0,1008,89,1,0,0,0,1009,1010,5,83,0,
  	0,1010,1011,5,150,0,0,1011,1012,3,270,135,0,1012,91,1,0,0,0,1013,1014,
  	3,94,47,0,1014,93,1,0,0,0,1015,1022,3,98,49,0,1016,1018,5,150,0,0,1017,
  	1016,1,0,0,0,1017,1018,1,0,0,0,1018,1019,1,0,0,0,1019,1021,3,96,48,0,
  	1020,1017,1,0,0,0,1021,1024,1,0,0,0,1022,1020,1,0,0,0,1022,1023,1,0,0,
  	0,1023,1037,1,0,0,0,1024,1022,1,0,0,0,1025,1027,3,132,66,0,1026,1028,
  	5,150,0,0,1027,1026,1,0,0,0,1027,1028,1,0,0,0,1028,1030,1,0,0,0,1029,
  	1025,1,0,0,0,1030,1031,1,0,0,0,1031,1029,1,0,0,0,1031,1032,1,0,0,0,1032,
  	1033,1,0,0,0,1033,1034,3,98,49,0,1034,1035,6,47,-1,0,1035,1037,1,0,0,
  	0,1036,1015,1,0,0,0,1036,1029,1,0,0,0,1037,95,1,0,0,0,1038,1039,5,85,
  	0,0,1039,1040,5,150,0,0,1040,1042,5,86,0,0,1041,1043,5,150,0,0,1042,1041,
  	1,0,0,0,1042,1043,1,0,0,0,1043,1044,1,0,0,0,1044,1051,3,98,49,0,1045,
  	1047,5,85,0,0,1046,1048,5,150,0,0,1047,1046,1,0,0,0,1047,1048,1,0,0,0,
  	1048,1049,1,0,0,0,1049,1051,3,98,49,0,1050,1038,1,0,0,0,1050,1045,1,0,
  	0,0,1051,97,1,0,0,0,1052,1055,3,100,50,0,1053,1055,3,102,51,0,1054,1052,
  	1,0,0,0,1054,1053,1,0,0,0,1055,99,1,0,0,0,1056,1058,3,108,54,0,1057,1059,
  	5,150,0,0,1058,1057,1,0,0,0,1058,1059,1,0,0,0,1059,1061,1,0,0,0,1060,
  	1056,1,0,0,0,1061,1064,1,0,0,0,1062,1060,1,0,0,0,1062,1063,1,0,0,0,1063,
  	1065,1,0,0,0,1064,1062,1,0,0,0,1065,1102,3,132,66,0,1066,1068,3,108,54,
  	0,1067,1069,5,150,0,0,1068,1067,1,0,0,0,1068,1069,1,0,0,0,1069,1071,1,
  	0,0,0,1070,1066,1,0,0,0,1071,1074,1,0,0,0,1072,1070,1,0,0,0,1072,1073,
  	1,0,0,0,1073,1075,1,0,0,0,1074,1072,1,0,0,0,1075,1082,3,106,53,0,1076,
  	1078,5,150,0,0,1077,1076,1,0,0,0,1077,1078,1,0,0,0,1078,1079,1,0,0,0,
  	1079,1081,3,106,53,0,1080,1077,1,0,0,0,1081,1084,1,0,0,0,1082,1080,1,
  	0,0,0,1082,1083,1,0,0,0,1083,1089,1,0,0,0,1084,1082,1,0,0,0,1085,1087,
  	5,150,0,0,1086,1085,1,0,0,0,1086,1087,1,0,0,0,1087,1088,1,0,0,0,1088,
  	1090,3,132,66,0,1089,1086,1,0,0,0,1089,1090,1,0,0,0,1090,1102,1,0,0,0,
  	1091,1093,3,108,54,0,1092,1094,5,150,0,0,1093,1092,1,0,0,0,1093,1094,
  	1,0,0,0,1094,1096,1,0,0,0,1095,1091,1,0,0,0,1096,1097,1,0,0,0,1097,1095,
  	1,0,0,0,1097,1098,1,0,0,0,1098,1099,1,0,0,0,1099,1100,6,50,-1,0,1100,
  	1102,1,0,0,0,1101,1062,1,0,0,0,1101,1072,1,0,0,0,1101,1095,1,0,0,0,1102,
  	101,1,0,0,0,1103,1105,3,104,52,0,1104,1106,5,150,0,0,1105,1104,1,0,0,
  	0,1105,1106,1,0,0,0,1106,1108,1,0,0,0,1107,1103,1,0,0,0,1108,1109,1,0,
  	0,0,1109,1107,1,0,0,0,1109,1110,1,0,0,0,1110,1111,1,0,0,0,1111,1112,3,
  	100,50,0,1112,103,1,0,0,0,1113,1115,3,108,54,0,1114,1116,5,150,0,0,1115,
  	1114,1,0,0,0,1115,1116,1,0,0,0,1116,1118,1,0,0,0,1117,1113,1,0,0,0,1118,
  	1121,1,0,0,0,1119,1117,1,0,0,0,1119,1120,1,0,0,0,1120,1128,1,0,0,0,1121,
  	1119,1,0,0,0,1122,1124,3,106,53,0,1123,1125,5,150,0,0,1124,1123,1,0,0,
  	0,1124,1125,1,0,0,0,1125,1127,1,0,0,0,1126,1122,1,0,0,0,1127,1130,1,0,
  	0,0,1128,1126,1,0,0,0,1128,1129,1,0,0,0,1129,1131,1,0,0,0,1130,1128,1,
  	0,0,0,1131,1132,3,130,65,0,1132,105,1,0,0,0,1133,1138,3,118,59,0,1134,
  	1138,3,120,60,0,1135,1138,3,124,62,0,1136,1138,3,128,64,0,1137,1133,1,
  	0,0,0,1137,1134,1,0,0,0,1137,1135,1,0,0,0,1137,1136,1,0,0,0,1138,107,
  	1,0,0,0,1139,1144,3,114,57,0,1140,1144,3,116,58,0,1141,1144,3,112,56,
  	0,1142,1144,3,110,55,0,1143,1139,1,0,0,0,1143,1140,1,0,0,0,1143,1141,
  	1,0,0,0,1143,1142,1,0,0,0,1144,109,1,0,0,0,1145,1163,5,87,0,0,1146,1147,
  	5,150,0,0,1147,1148,5,98,0,0,1148,1149,5,150,0,0,1149,1151,5,88,0,0,1150,
  	1152,5,150,0,0,1151,1150,1,0,0,0,1151,1152,1,0,0,0,1152,1153,1,0,0,0,
  	1153,1155,5,2,0,0,1154,1156,5,150,0,0,1155,1154,1,0,0,0,1155,1156,1,0,
  	0,0,1156,1157,1,0,0,0,1157,1159,3,66,33,0,1158,1160,5,150,0,0,1159,1158,
  	1,0,0,0,1159,1160,1,0,0,0,1160,1161,1,0,0,0,1161,1162,5,4,0,0,1162,1164,
  	1,0,0,0,1163,1146,1,0,0,0,1163,1164,1,0,0,0,1164,1165,1,0,0,0,1165,1166,
  	5,150,0,0,1166,1167,5,54,0,0,1167,1168,5,150,0,0,1168,1173,3,10,5,0,1169,
  	1171,5,150,0,0,1170,1169,1,0,0,0,1170,1171,1,0,0,0,1171,1172,1,0,0,0,
  	1172,1174,3,38,19,0,1173,1170,1,0,0,0,1173,1174,1,0,0,0,1174,1179,1,0,
  	0,0,1175,1177,5,150,0,0,1176,1175,1,0,0,0,1176,1177,1,0,0,0,1177,1178,
  	1,0,0,0,1178,1180,3,148,74,0,1179,1176,1,0,0,0,1179,1180,1,0,0,0,1180,
  	111,1,0,0,0,1181,1182,5,49,0,0,1182,1183,5,150,0,0,1183,1188,3,252,126,
  	0,1184,1186,5,150,0,0,1185,1184,1,0,0,0,1185,1186,1,0,0,0,1186,1187,1,
  	0,0,0,1187,1189,3,148,74,0,1188,1185,1,0,0,0,1188,1189,1,0,0,0,1189,113,
  	1,0,0,0,1190,1191,5,89,0,0,1191,1193,5,150,0,0,1192,1190,1,0,0,0,1192,
  	1193,1,0,0,0,1193,1194,1,0,0,0,1194,1196,5,90,0,0,1195,1197,5,150,0,0,
  	1196,1195,1,0,0,0,1196,1197,1,0,0,0,1197,1198,1,0,0,0,1198,1203,3,150,
  	75,0,1199,1201,5,150,0,0,1200,1199,1,0,0,0,1200,1201,1,0,0,0,1201,1202,
  	1,0,0,0,1202,1204,3,148,74,0,1203,1200,1,0,0,0,1203,1204,1,0,0,0,1204,
  	115,1,0,0,0,1205,1207,5,91,0,0,1206,1208,5,150,0,0,1207,1206,1,0,0,0,
  	1207,1208,1,0,0,0,1208,1209,1,0,0,0,1209,1210,3,190,95,0,1210,1211,5,
  	150,0,0,1211,1212,5,102,0,0,1212,1213,5,150,0,0,1213,1214,3,270,135,0,
  	1214,117,1,0,0,0,1215,1217,5,92,0,0,1216,1218,5,150,0,0,1217,1216,1,0,
  	0,0,1217,1218,1,0,0,0,1218,1219,1,0,0,0,1219,1220,3,150,75,0,1220,119,
  	1,0,0,0,1221,1223,5,93,0,0,1222,1224,5,150,0,0,1223,1222,1,0,0,0,1223,
  	1224,1,0,0,0,1224,1225,1,0,0,0,1225,1230,3,150,75,0,1226,1227,5,150,0,
  	0,1227,1229,3,122,61,0,1228,1226,1,0,0,0,1229,1232,1,0,0,0,1230,1228,
  	1,0,0,0,1230,1231,1,0,0,0,1231,121,1,0,0,0,1232,1230,1,0,0,0,1233,1234,
  	5,94,0,0,1234,1235,5,150,0,0,1235,1236,5,90,0,0,1236,1237,5,150,0,0,1237,
  	1244,3,124,62,0,1238,1239,5,94,0,0,1239,1240,5,150,0,0,1240,1241,5,92,
  	0,0,1241,1242,5,150,0,0,1242,1244,3,124,62,0,1243,1233,1,0,0,0,1243,1238,
  	1,0,0,0,1244,123,1,0,0,0,1245,1247,5,95,0,0,1246,1248,5,150,0,0,1247,
  	1246,1,0,0,0,1247,1248,1,0,0,0,1248,1249,1,0,0,0,1249,1260,3,126,63,0,
  	1250,1252,5,150,0,0,1251,1250,1,0,0,0,1251,1252,1,0,0,0,1252,1253,1,0,
  	0,0,1253,1255,5,3,0,0,1254,1256,5,150,0,0,1255,1254,1,0,0,0,1255,1256,
  	1,0,0,0,1256,1257,1,0,0,0,1257,1259,3,126,63,0,1258,1251,1,0,0,0,1259,
  	1262,1,0,0,0,1260,1258,1,0,0,0,1260,1261,1,0,0,0,1261,125,1,0,0,0,1262,
  	1260,1,0,0,0,1263,1265,3,276,138,0,1264,1266,5,150,0,0,1265,1264,1,0,
  	0,0,1265,1266,1,0,0,0,1266,1267,1,0,0,0,1267,1269,5,6,0,0,1268,1270,5,
  	150,0,0,1269,1268,1,0,0,0,1269,1270,1,0,0,0,1270,1271,1,0,0,0,1271,1272,
  	3,190,95,0,1272,127,1,0,0,0,1273,1274,5,96,0,0,1274,1276,5,150,0,0,1275,
  	1273,1,0,0,0,1275,1276,1,0,0,0,1276,1277,1,0,0,0,1277,1279,5,97,0,0,1278,
  	1280,5,150,0,0,1279,1278,1,0,0,0,1279,1280,1,0,0,0,1280,1281,1,0,0,0,
  	1281,1292,3,190,95,0,1282,1284,5,150,0,0,1283,1282,1,0,0,0,1283,1284,
  	1,0,0,0,1284,1285,1,0,0,0,1285,1287,5,3,0,0,1286,1288,5,150,0,0,1287,
  	1286,1,0,0,0,1287,1288,1,0,0,0,1288,1289,1,0,0,0,1289,1291,3,190,95,0,
  	1290,1283,1,0,0,0,1291,1294,1,0,0,0,1292,1290,1,0,0,0,1292,1293,1,0,0,
  	0,1293,129,1,0,0,0,1294,1292,1,0,0,0,1295,1296,5,98,0,0,1296,1301,3,134,
  	67,0,1297,1299,5,150,0,0,1298,1297,1,0,0,0,1298,1299,1,0,0,0,1299,1300,
  	1,0,0,0,1300,1302,3,148,74,0,1301,1298,1,0,0,0,1301,1302,1,0,0,0,1302,
  	131,1,0,0,0,1303,1304,5,99,0,0,1304,1305,3,134,67,0,1305,133,1,0,0,0,
  	1306,1308,5,150,0,0,1307,1306,1,0,0,0,1307,1308,1,0,0,0,1308,1309,1,0,
  	0,0,1309,1311,5,100,0,0,1310,1307,1,0,0,0,1310,1311,1,0,0,0,1311,1312,
  	1,0,0,0,1312,1313,5,150,0,0,1313,1316,3,136,68,0,1314,1315,5,150,0,0,
  	1315,1317,3,140,70,0,1316,1314,1,0,0,0,1316,1317,1,0,0,0,1317,1320,1,
  	0,0,0,1318,1319,5,150,0,0,1319,1321,3,142,71,0,1320,1318,1,0,0,0,1320,
  	1321,1,0,0,0,1321,1324,1,0,0,0,1322,1323,5,150,0,0,1323,1325,3,144,72,
  	0,1324,1322,1,0,0,0,1324,1325,1,0,0,0,1325,135,1,0,0,0,1326,1337,5,101,
  	0,0,1327,1329,5,150,0,0,1328,1327,1,0,0,0,1328,1329,1,0,0,0,1329,1330,
  	1,0,0,0,1330,1332,5,3,0,0,1331,1333,5,150,0,0,1332,1331,1,0,0,0,1332,
  	1333,1,0,0,0,1333,1334,1,0,0,0,1334,1336,3,138,69,0,1335,1328,1,0,0,0,
  	1336,1339,1,0,0,0,1337,1335,1,0,0,0,1337,1338,1,0,0,0,1338,1355,1,0,0,
  	0,1339,1337,1,0,0,0,1340,1351,3,138,69,0,1341,1343,5,150,0,0,1342,1341,
  	1,0,0,0,1342,1343,1,0,0,0,1343,1344,1,0,0,0,1344,1346,5,3,0,0,1345,1347,
  	5,150,0,0,1346,1345,1,0,0,0,1346,1347,1,0,0,0,1347,1348,1,0,0,0,1348,
  	1350,3,138,69,0,1349,1342,1,0,0,0,1350,1353,1,0,0,0,1351,1349,1,0,0,0,
  	1351,1352,1,0,0,0,1352,1355,1,0,0,0,1353,1351,1,0,0,0,1354,1326,1,0,0,
  	0,1354,1340,1,0,0,0,1355,137,1,0,0,0,1356,1357,3,190,95,0,1357,1358,5,
  	150,0,0,1358,1359,5,102,0,0,1359,1360,5,150,0,0,1360,1361,3,270,135,0,
  	1361,1364,1,0,0,0,1362,1364,3,190,95,0,1363,1356,1,0,0,0,1363,1362,1,
  	0,0,0,1364,139,1,0,0,0,1365,1366,5,103,0,0,1366,1367,5,150,0,0,1367,1368,
  	5,104,0,0,1368,1369,5,150,0,0,1369,1377,3,146,73,0,1370,1372,5,3,0,0,
  	1371,1373,5,150,0,0,1372,1371,1,0,0,0,1372,1373,1,0,0,0,1373,1374,1,0,
  	0,0,1374,1376,3,146,73,0,1375,1370,1,0,0,0,1376,1379,1,0,0,0,1377,1375,
  	1,0,0,0,1377,1378,1,0,0,0,1378,141,1,0,0,0,1379,1377,1,0,0,0,1380,1381,
  	5,105,0,0,1381,1382,5,150,0,0,1382,1383,3,190,95,0,1383,143,1,0,0,0,1384,
  	1385,5,106,0,0,1385,1386,5,150,0,0,1386,1387,3,190,95,0,1387,145,1,0,
  	0,0,1388,1393,3,190,95,0,1389,1391,5,150,0,0,1390,1389,1,0,0,0,1390,1391,
  	1,0,0,0,1391,1392,1,0,0,0,1392,1394,7,1,0,0,1393,1390,1,0,0,0,1393,1394,
  	1,0,0,0,1394,147,1,0,0,0,1395,1396,5,111,0,0,1396,1397,5,150,0,0,1397,
  	1398,3,190,95,0,1398,149,1,0,0,0,1399,1410,3,152,76,0,1400,1402,5,150,
  	0,0,1401,1400,1,0,0,0,1401,1402,1,0,0,0,1402,1403,1,0,0,0,1403,1405,5,
  	3,0,0,1404,1406,5,150,0,0,1405,1404,1,0,0,0,1405,1406,1,0,0,0,1406,1407,
  	1,0,0,0,1407,1409,3,152,76,0,1408,1401,1,0,0,0,1409,1412,1,0,0,0,1410,
  	1408,1,0,0,0,1410,1411,1,0,0,0,1411,151,1,0,0,0,1412,1410,1,0,0,0,1413,
  	1415,3,270,135,0,1414,1416,5,150,0,0,1415,1414,1,0,0,0,1415,1416,1,0,
  	0,0,1416,1417,1,0,0,0,1417,1419,5,6,0,0,1418,1420,5,150,0,0,1419,1418,
  	1,0,0,0,1419,1420,1,0,0,0,1420,1421,1,0,0,0,1421,1422,3,154,77,0,1422,
  	1425,1,0,0,0,1423,1425,3,154,77,0,1424,1413,1,0,0,0,1424,1423,1,0,0,0,
  	1425,153,1,0,0,0,1426,1427,3,156,78,0,1427,155,1,0,0,0,1428,1435,3,158,
  	79,0,1429,1431,5,150,0,0,1430,1429,1,0,0,0,1430,1431,1,0,0,0,1431,1432,
  	1,0,0,0,1432,1434,3,160,80,0,1433,1430,1,0,0,0,1434,1437,1,0,0,0,1435,
  	1433,1,0,0,0,1435,1436,1,0,0,0,1436,1443,1,0,0,0,1437,1435,1,0,0,0,1438,
  	1439,5,2,0,0,1439,1440,3,156,78,0,1440,1441,5,4,0,0,1441,1443,1,0,0,0,
  	1442,1428,1,0,0,0,1442,1438,1,0,0,0,1443,157,1,0,0,0,1444,1446,5,2,0,
  	0,1445,1447,5,150,0,0,1446,1445,1,0,0,0,1446,1447,1,0,0,0,1447,1452,1,
  	0,0,0,1448,1450,3,270,135,0,1449,1451,5,150,0,0,1450,1449,1,0,0,0,1450,
  	1451,1,0,0,0,1451,1453,1,0,0,0,1452,1448,1,0,0,0,1452,1453,1,0,0,0,1453,
  	1458,1,0,0,0,1454,1456,3,170,85,0,1455,1457,5,150,0,0,1456,1455,1,0,0,
  	0,1456,1457,1,0,0,0,1457,1459,1,0,0,0,1458,1454,1,0,0,0,1458,1459,1,0,
  	0,0,1459,1464,1,0,0,0,1460,1462,3,166,83,0,1461,1463,5,150,0,0,1462,1461,
  	1,0,0,0,1462,1463,1,0,0,0,1463,1465,1,0,0,0,1464,1460,1,0,0,0,1464,1465,
  	1,0,0,0,1465,1466,1,0,0,0,1466,1467,5,4,0,0,1467,159,1,0,0,0,1468,1470,
  	3,162,81,0,1469,1471,5,150,0,0,1470,1469,1,0,0,0,1470,1471,1,0,0,0,1471,
  	1472,1,0,0,0,1472,1473,3,158,79,0,1473,161,1,0,0,0,1474,1476,3,290,145,
  	0,1475,1477,5,150,0,0,1476,1475,1,0,0,0,1476,1477,1,0,0,0,1477,1478,1,
  	0,0,0,1478,1480,3,294,147,0,1479,1481,5,150,0,0,1480,1479,1,0,0,0,1480,
  	1481,1,0,0,0,1481,1483,1,0,0,0,1482,1484,3,164,82,0,1483,1482,1,0,0,0,
  	1483,1484,1,0,0,0,1484,1486,1,0,0,0,1485,1487,5,150,0,0,1486,1485,1,0,
  	0,0,1486,1487,1,0,0,0,1487,1488,1,0,0,0,1488,1489,3,294,147,0,1489,1519,
  	1,0,0,0,1490,1492,3,294,147,0,1491,1493,5,150,0,0,1492,1491,1,0,0,0,1492,
  	1493,1,0,0,0,1493,1495,1,0,0,0,1494,1496,3,164,82,0,1495,1494,1,0,0,0,
  	1495,1496,1,0,0,0,1496,1498,1,0,0,0,1497,1499,5,150,0,0,1498,1497,1,0,
  	0,0,1498,1499,1,0,0,0,1499,1500,1,0,0,0,1500,1502,3,294,147,0,1501,1503,
  	5,150,0,0,1502,1501,1,0,0,0,1502,1503,1,0,0,0,1503,1504,1,0,0,0,1504,
  	1505,3,292,146,0,1505,1519,1,0,0,0,1506,1508,3,294,147,0,1507,1509,5,
  	150,0,0,1508,1507,1,0,0,0,1508,1509,1,0,0,0,1509,1511,1,0,0,0,1510,1512,
  	3,164,82,0,1511,1510,1,0,0,0,1511,1512,1,0,0,0,1512,1514,1,0,0,0,1513,
  	1515,5,150,0,0,1514,1513,1,0,0,0,1514,1515,1,0,0,0,1515,1516,1,0,0,0,
  	1516,1517,3,294,147,0,1517,1519,1,0,0,0,1518,1474,1,0,0,0,1518,1490,1,
  	0,0,0,1518,1506,1,0,0,0,1519,163,1,0,0,0,1520,1522,5,7,0,0,1521,1523,
  	5,150,0,0,1522,1521,1,0,0,0,1522,1523,1,0,0,0,1523,1528,1,0,0,0,1524,
  	1526,3,270,135,0,1525,1527,5,150,0,0,1526,1525,1,0,0,0,1526,1527,1,0,
  	0,0,1527,1529,1,0,0,0,1528,1524,1,0,0,0,1528,1529,1,0,0,0,1529,1534,1,
  	0,0,0,1530,1532,3,168,84,0,1531,1533,5,150,0,0,1532,1531,1,0,0,0,1532,
  	1533,1,0,0,0,1533,1535,1,0,0,0,1534,1530,1,0,0,0,1534,1535,1,0,0,0,1535,
  	1540,1,0,0,0,1536,1538,3,174,87,0,1537,1539,5,150,0,0,1538,1537,1,0,0,
  	0,1538,1539,1,0,0,0,1539,1541,1,0,0,0,1540,1536,1,0,0,0,1540,1541,1,0,
  	0,0,1541,1546,1,0,0,0,1542,1544,3,166,83,0,1543,1545,5,150,0,0,1544,1543,
  	1,0,0,0,1544,1545,1,0,0,0,1545,1547,1,0,0,0,1546,1542,1,0,0,0,1546,1547,
  	1,0,0,0,1547,1548,1,0,0,0,1548,1549,5,8,0,0,1549,165,1,0,0,0,1550,1552,
  	5,9,0,0,1551,1553,5,150,0,0,1552,1551,1,0,0,0,1552,1553,1,0,0,0,1553,
  	1587,1,0,0,0,1554,1556,3,278,139,0,1555,1557,5,150,0,0,1556,1555,1,0,
  	0,0,1556,1557,1,0,0,0,1557,1558,1,0,0,0,1558,1560,5,120,0,0,1559,1561,
  	5,150,0,0,1560,1559,1,0,0,0,1560,1561,1,0,0,0,1561,1562,1,0,0,0,1562,
  	1564,3,190,95,0,1563,1565,5,150,0,0,1564,1563,1,0,0,0,1564,1565,1,0,0,
  	0,1565,1584,1,0,0,0,1566,1568,5,3,0,0,1567,1569,5,150,0,0,1568,1567,1,
  	0,0,0,1568,1569,1,0,0,0,1569,1570,1,0,0,0,1570,1572,3,278,139,0,1571,
  	1573,5,150,0,0,1572,1571,1,0,0,0,1572,1573,1,0,0,0,1573,1574,1,0,0,0,
  	1574,1576,5,120,0,0,1575,1577,5,150,0,0,1576,1575,1,0,0,0,1576,1577,1,
  	0,0,0,1577,1578,1,0,0,0,1578,1580,3,190,95,0,1579,1581,5,150,0,0,1580,
  	1579,1,0,0,0,1580,1581,1,0,0,0,1581,1583,1,0,0,0,1582,1566,1,0,0,0,1583,
  	1586,1,0,0,0,1584,1582,1,0,0,0,1584,1585,1,0,0,0,1585,1588,1,0,0,0,1586,
  	1584,1,0,0,0,1587,1554,1,0,0,0,1587,1588,1,0,0,0,1588,1589,1,0,0,0,1589,
  	1590,5,10,0,0,1590,167,1,0,0,0,1591,1593,5,120,0,0,1592,1594,5,150,0,
  	0,1593,1592,1,0,0,0,1593,1594,1,0,0,0,1594,1595,1,0,0,0,1595,1609,3,188,
  	94,0,1596,1598,5,150,0,0,1597,1596,1,0,0,0,1597,1598,1,0,0,0,1598,1599,
  	1,0,0,0,1599,1601,5,11,0,0,1600,1602,5,120,0,0,1601,1600,1,0,0,0,1601,
  	1602,1,0,0,0,1602,1604,1,0,0,0,1603,1605,5,150,0,0,1604,1603,1,0,0,0,
  	1604,1605,1,0,0,0,1605,1606,1,0,0,0,1606,1608,3,188,94,0,1607,1597,1,
  	0,0,0,1608,1611,1,0,0,0,1609,1607,1,0,0,0,1609,1610,1,0,0,0,1610,169,
  	1,0,0,0,1611,1609,1,0,0,0,1612,1619,3,172,86,0,1613,1615,5,150,0,0,1614,
  	1613,1,0,0,0,1614,1615,1,0,0,0,1615,1616,1,0,0,0,1616,1618,3,172,86,0,
  	1617,1614,1,0,0,0,1618,1621,1,0,0,0,1619,1617,1,0,0,0,1619,1620,1,0,0,
  	0,1620,171,1,0,0,0,1621,1619,1,0,0,0,1622,1624,5,120,0,0,1623,1625,5,
  	150,0,0,1624,1623,1,0,0,0,1624,1625,1,0,0,0,1625,1626,1,0,0,0,1626,1627,
  	3,186,93,0,1627,173,1,0,0,0,1628,1630,5,101,0,0,1629,1631,5,150,0,0,1630,
  	1629,1,0,0,0,1630,1631,1,0,0,0,1631,1636,1,0,0,0,1632,1637,5,112,0,0,
  	1633,1634,5,86,0,0,1634,1635,5,150,0,0,1635,1637,5,112,0,0,1636,1632,
  	1,0,0,0,1636,1633,1,0,0,0,1636,1637,1,0,0,0,1637,1639,1,0,0,0,1638,1640,
  	5,150,0,0,1639,1638,1,0,0,0,1639,1640,1,0,0,0,1640,1655,1,0,0,0,1641,
  	1643,3,182,91,0,1642,1641,1,0,0,0,1642,1643,1,0,0,0,1643,1645,1,0,0,0,
  	1644,1646,5,150,0,0,1645,1644,1,0,0,0,1645,1646,1,0,0,0,1646,1647,1,0,
  	0,0,1647,1649,5,12,0,0,1648,1650,5,150,0,0,1649,1648,1,0,0,0,1649,1650,
  	1,0,0,0,1650,1652,1,0,0,0,1651,1653,3,184,92,0,1652,1651,1,0,0,0,1652,
  	1653,1,0,0,0,1653,1656,1,0,0,0,1654,1656,3,280,140,0,1655,1642,1,0,0,
  	0,1655,1654,1,0,0,0,1655,1656,1,0,0,0,1656,1661,1,0,0,0,1657,1659,5,150,
  	0,0,1658,1657,1,0,0,0,1658,1659,1,0,0,0,1659,1660,1,0,0,0,1660,1662,3,
  	176,88,0,1661,1658,1,0,0,0,1661,1662,1,0,0,0,1662,175,1,0,0,0,1663,1665,
  	5,2,0,0,1664,1666,5,150,0,0,1665,1664,1,0,0,0,1665,1666,1,0,0,0,1666,
  	1667,1,0,0,0,1667,1669,3,270,135,0,1668,1670,5,150,0,0,1669,1668,1,0,
  	0,0,1669,1670,1,0,0,0,1670,1671,1,0,0,0,1671,1673,5,3,0,0,1672,1674,5,
  	150,0,0,1673,1672,1,0,0,0,1673,1674,1,0,0,0,1674,1675,1,0,0,0,1675,1684,
  	3,270,135,0,1676,1678,5,150,0,0,1677,1676,1,0,0,0,1677,1678,1,0,0,0,1678,
  	1679,1,0,0,0,1679,1681,5,11,0,0,1680,1682,5,150,0,0,1681,1680,1,0,0,0,
  	1681,1682,1,0,0,0,1682,1683,1,0,0,0,1683,1685,3,148,74,0,1684,1677,1,
  	0,0,0,1684,1685,1,0,0,0,1685,1705,1,0,0,0,1686,1688,5,150,0,0,1687,1686,
  	1,0,0,0,1687,1688,1,0,0,0,1688,1689,1,0,0,0,1689,1691,5,11,0,0,1690,1692,
  	5,150,0,0,1691,1690,1,0,0,0,1691,1692,1,0,0,0,1692,1693,1,0,0,0,1693,
  	1695,3,180,90,0,1694,1696,5,150,0,0,1695,1694,1,0,0,0,1695,1696,1,0,0,
  	0,1696,1697,1,0,0,0,1697,1699,5,3,0,0,1698,1700,5,150,0,0,1699,1698,1,
  	0,0,0,1699,1700,1,0,0,0,1700,1701,1,0,0,0,1701,1703,3,178,89,0,1702,1704,
  	5,150,0,0,1703,1702,1,0,0,0,1703,1704,1,0,0,0,1704,1706,1,0,0,0,1705,
  	1687,1,0,0,0,1705,1706,1,0,0,0,1706,1707,1,0,0,0,1707,1708,5,4,0,0,1708,
  	177,1,0,0,0,1709,1711,5,9,0,0,1710,1712,5,150,0,0,1711,1710,1,0,0,0,1711,
  	1712,1,0,0,0,1712,1714,1,0,0,0,1713,1715,3,136,68,0,1714,1713,1,0,0,0,
  	1714,1715,1,0,0,0,1715,1717,1,0,0,0,1716,1718,5,150,0,0,1717,1716,1,0,
  	0,0,1717,1718,1,0,0,0,1718,1719,1,0,0,0,1719,1720,5,10,0,0,1720,179,1,
  	0,0,0,1721,1723,5,9,0,0,1722,1724,5,150,0,0,1723,1722,1,0,0,0,1723,1724,
  	1,0,0,0,1724,1726,1,0,0,0,1725,1727,3,136,68,0,1726,1725,1,0,0,0,1726,
  	1727,1,0,0,0,1727,1729,1,0,0,0,1728,1730,5,150,0,0,1729,1728,1,0,0,0,
  	1729,1730,1,0,0,0,1730,1731,1,0,0,0,1731,1732,5,10,0,0,1732,181,1,0,0,
  	0,1733,1734,5,138,0,0,1734,183,1,0,0,0,1735,1736,5,138,0,0,1736,185,1,
  	0,0,0,1737,1738,3,284,142,0,1738,187,1,0,0,0,1739,1740,3,284,142,0,1740,
  	189,1,0,0,0,1741,1742,3,192,96,0,1742,191,1,0,0,0,1743,1750,3,194,97,
  	0,1744,1745,5,150,0,0,1745,1746,5,113,0,0,1746,1747,5,150,0,0,1747,1749,
  	3,194,97,0,1748,1744,1,0,0,0,1749,1752,1,0,0,0,1750,1748,1,0,0,0,1750,
  	1751,1,0,0,0,1751,193,1,0,0,0,1752,1750,1,0,0,0,1753,1760,3,196,98,0,
  	1754,1755,5,150,0,0,1755,1756,5,114,0,0,1756,1757,5,150,0,0,1757,1759,
  	3,196,98,0,1758,1754,1,0,0,0,1759,1762,1,0,0,0,1760,1758,1,0,0,0,1760,
  	1761,1,0,0,0,1761,195,1,0,0,0,1762,1760,1,0,0,0,1763,1770,3,198,99,0,
  	1764,1765,5,150,0,0,1765,1766,5,115,0,0,1766,1767,5,150,0,0,1767,1769,
  	3,198,99,0,1768,1764,1,0,0,0,1769,1772,1,0,0,0,1770,1768,1,0,0,0,1770,
  	1771,1,0,0,0,1771,197,1,0,0,0,1772,1770,1,0,0,0,1773,1775,5,116,0,0,1774,
  	1776,5,150,0,0,1775,1774,1,0,0,0,1775,1776,1,0,0,0,1776,1778,1,0,0,0,
  	1777,1773,1,0,0,0,1778,1781,1,0,0,0,1779,1777,1,0,0,0,1779,1780,1,0,0,
  	0,1780,1782,1,0,0,0,1781,1779,1,0,0,0,1782,1783,3,200,100,0,1783,199,
  	1,0,0,0,1784,1794,3,204,102,0,1785,1787,5,150,0,0,1786,1785,1,0,0,0,1786,
  	1787,1,0,0,0,1787,1788,1,0,0,0,1788,1790,3,202,101,0,1789,1791,5,150,
  	0,0,1790,1789,1,0,0,0,1790,1791,1,0,0,0,1791,1792,1,0,0,0,1792,1793,3,
  	204,102,0,1793,1795,1,0,0,0,1794,1786,1,0,0,0,1794,1795,1,0,0,0,1795,
  	1833,1,0,0,0,1796,1798,3,204,102,0,1797,1799,5,150,0,0,1798,1797,1,0,
  	0,0,1798,1799,1,0,0,0,1799,1800,1,0,0,0,1800,1802,5,117,0,0,1801,1803,
  	5,150,0,0,1802,1801,1,0,0,0,1802,1803,1,0,0,0,1803,1804,1,0,0,0,1804,
  	1805,3,204,102,0,1805,1806,1,0,0,0,1806,1807,6,100,-1,0,1807,1833,1,0,
  	0,0,1808,1810,3,204,102,0,1809,1811,5,150,0,0,1810,1809,1,0,0,0,1810,
  	1811,1,0,0,0,1811,1812,1,0,0,0,1812,1814,3,202,101,0,1813,1815,5,150,
  	0,0,1814,1813,1,0,0,0,1814,1815,1,0,0,0,1815,1816,1,0,0,0,1816,1826,3,
  	204,102,0,1817,1819,5,150,0,0,1818,1817,1,0,0,0,1818,1819,1,0,0,0,1819,
  	1820,1,0,0,0,1820,1822,3,202,101,0,1821,1823,5,150,0,0,1822,1821,1,0,
  	0,0,1822,1823,1,0,0,0,1823,1824,1,0,0,0,1824,1825,3,204,102,0,1825,1827,
  	1,0,0,0,1826,1818,1,0,0,0,1827,1828,1,0,0,0,1828,1826,1,0,0,0,1828,1829,
  	1,0,0,0,1829,1830,1,0,0,0,1830,1831,6,100,-1,0,1831,1833,1,0,0,0,1832,
  	1784,1,0,0,0,1832,1796,1,0,0,0,1832,1808,1,0,0,0,1833,201,1,0,0,0,1834,
  	1835,7,2,0,0,1835,203,1,0,0,0,1836,1847,3,206,103,0,1837,1839,5,150,0,
  	0,1838,1837,1,0,0,0,1838,1839,1,0,0,0,1839,1840,1,0,0,0,1840,1842,5,11,
  	0,0,1841,1843,5,150,0,0,1842,1841,1,0,0,0,1842,1843,1,0,0,0,1843,1844,
  	1,0,0,0,1844,1846,3,206,103,0,1845,1838,1,0,0,0,1846,1849,1,0,0,0,1847,
  	1845,1,0,0,0,1847,1848,1,0,0,0,1848,205,1,0,0,0,1849,1847,1,0,0,0,1850,
  	1861,3,208,104,0,1851,1853,5,150,0,0,1852,1851,1,0,0,0,1852,1853,1,0,
  	0,0,1853,1854,1,0,0,0,1854,1856,5,18,0,0,1855,1857,5,150,0,0,1856,1855,
  	1,0,0,0,1856,1857,1,0,0,0,1857,1858,1,0,0,0,1858,1860,3,208,104,0,1859,
  	1852,1,0,0,0,1860,1863,1,0,0,0,1861,1859,1,0,0,0,1861,1862,1,0,0,0,1862,
  	207,1,0,0,0,1863,1861,1,0,0,0,1864,1876,3,212,106,0,1865,1867,5,150,0,
  	0,1866,1865,1,0,0,0,1866,1867,1,0,0,0,1867,1868,1,0,0,0,1868,1870,3,210,
  	105,0,1869,1871,5,150,0,0,1870,1869,1,0,0,0,1870,1871,1,0,0,0,1871,1872,
  	1,0,0,0,1872,1873,3,212,106,0,1873,1875,1,0,0,0,1874,1866,1,0,0,0,1875,
  	1878,1,0,0,0,1876,1874,1,0,0,0,1876,1877,1,0,0,0,1877,209,1,0,0,0,1878,
  	1876,1,0,0,0,1879,1880,7,3,0,0,1880,211,1,0,0,0,1881,1893,3,216,108,0,
  	1882,1884,5,150,0,0,1883,1882,1,0,0,0,1883,1884,1,0,0,0,1884,1885,1,0,
  	0,0,1885,1887,3,214,107,0,1886,1888,5,150,0,0,1887,1886,1,0,0,0,1887,
  	1888,1,0,0,0,1888,1889,1,0,0,0,1889,1890,3,216,108,0,1890,1892,1,0,0,
  	0,1891,1883,1,0,0,0,1892,1895,1,0,0,0,1893,1891,1,0,0,0,1893,1894,1,0,
  	0,0,1894,213,1,0,0,0,1895,1893,1,0,0,0,1896,1897,7,4,0,0,1897,215,1,0,
  	0,0,1898,1910,3,220,110,0,1899,1901,5,150,0,0,1900,1899,1,0,0,0,1900,
  	1901,1,0,0,0,1901,1902,1,0,0,0,1902,1904,3,218,109,0,1903,1905,5,150,
  	0,0,1904,1903,1,0,0,0,1904,1905,1,0,0,0,1905,1906,1,0,0,0,1906,1907,3,
  	220,110,0,1907,1909,1,0,0,0,1908,1900,1,0,0,0,1909,1912,1,0,0,0,1910,
  	1908,1,0,0,0,1910,1911,1,0,0,0,1911,217,1,0,0,0,1912,1910,1,0,0,0,1913,
  	1914,7,5,0,0,1914,219,1,0,0,0,1915,1926,3,222,111,0,1916,1918,5,150,0,
  	0,1917,1916,1,0,0,0,1917,1918,1,0,0,0,1918,1919,1,0,0,0,1919,1921,5,24,
  	0,0,1920,1922,5,150,0,0,1921,1920,1,0,0,0,1921,1922,1,0,0,0,1922,1923,
  	1,0,0,0,1923,1925,3,222,111,0,1924,1917,1,0,0,0,1925,1928,1,0,0,0,1926,
  	1924,1,0,0,0,1926,1927,1,0,0,0,1927,221,1,0,0,0,1928,1926,1,0,0,0,1929,
  	1931,5,118,0,0,1930,1932,5,150,0,0,1931,1930,1,0,0,0,1931,1932,1,0,0,
  	0,1932,1934,1,0,0,0,1933,1929,1,0,0,0,1934,1937,1,0,0,0,1935,1933,1,0,
  	0,0,1935,1936,1,0,0,0,1936,1938,1,0,0,0,1937,1935,1,0,0,0,1938,1943,3,
  	224,112,0,1939,1941,5,150,0,0,1940,1939,1,0,0,0,1940,1941,1,0,0,0,1941,
  	1942,1,0,0,0,1942,1944,5,119,0,0,1943,1940,1,0,0,0,1943,1944,1,0,0,0,
  	1944,223,1,0,0,0,1945,1953,3,234,117,0,1946,1954,3,228,114,0,1947,1949,
  	3,226,113,0,1948,1947,1,0,0,0,1949,1950,1,0,0,0,1950,1948,1,0,0,0,1950,
  	1951,1,0,0,0,1951,1954,1,0,0,0,1952,1954,3,232,116,0,1953,1946,1,0,0,
  	0,1953,1948,1,0,0,0,1953,1952,1,0,0,0,1953,1954,1,0,0,0,1954,225,1,0,
  	0,0,1955,1956,5,150,0,0,1956,1958,5,121,0,0,1957,1959,5,150,0,0,1958,
  	1957,1,0,0,0,1958,1959,1,0,0,0,1959,1960,1,0,0,0,1960,1975,3,234,117,
  	0,1961,1962,5,7,0,0,1962,1963,3,190,95,0,1963,1964,5,8,0,0,1964,1975,
  	1,0,0,0,1965,1967,5,7,0,0,1966,1968,3,190,95,0,1967,1966,1,0,0,0,1967,
  	1968,1,0,0,0,1968,1969,1,0,0,0,1969,1971,5,120,0,0,1970,1972,3,190,95,
  	0,1971,1970,1,0,0,0,1971,1972,1,0,0,0,1972,1973,1,0,0,0,1973,1975,5,8,
  	0,0,1974,1955,1,0,0,0,1974,1961,1,0,0,0,1974,1965,1,0,0,0,1975,227,1,
  	0,0,0,1976,1988,3,230,115,0,1977,1978,5,150,0,0,1978,1979,5,122,0,0,1979,
  	1980,5,150,0,0,1980,1988,5,98,0,0,1981,1982,5,150,0,0,1982,1983,5,123,
  	0,0,1983,1984,5,150,0,0,1984,1988,5,98,0,0,1985,1986,5,150,0,0,1986,1988,
  	5,124,0,0,1987,1976,1,0,0,0,1987,1977,1,0,0,0,1987,1981,1,0,0,0,1987,
  	1985,1,0,0,0,1988,1990,1,0,0,0,1989,1991,5,150,0,0,1990,1989,1,0,0,0,
  	1990,1991,1,0,0,0,1991,1992,1,0,0,0,1992,1993,3,234,117,0,1993,229,1,
  	0,0,0,1994,1996,5,150,0,0,1995,1994,1,0,0,0,1995,1996,1,0,0,0,1996,1997,
  	1,0,0,0,1997,1998,5,25,0,0,1998,231,1,0,0,0,1999,2000,5,150,0,0,2000,
  	2001,5,125,0,0,2001,2002,5,150,0,0,2002,2010,5,126,0,0,2003,2004,5,150,
  	0,0,2004,2005,5,125,0,0,2005,2006,5,150,0,0,2006,2007,5,116,0,0,2007,
  	2008,5,150,0,0,2008,2010,5,126,0,0,2009,1999,1,0,0,0,2009,2003,1,0,0,
  	0,2010,233,1,0,0,0,2011,2018,3,236,118,0,2012,2014,5,150,0,0,2013,2012,
  	1,0,0,0,2013,2014,1,0,0,0,2014,2015,1,0,0,0,2015,2017,3,264,132,0,2016,
  	2013,1,0,0,0,2017,2020,1,0,0,0,2018,2016,1,0,0,0,2018,2019,1,0,0,0,2019,
  	235,1,0,0,0,2020,2018,1,0,0,0,2021,2031,3,238,119,0,2022,2031,3,274,137,
  	0,2023,2031,3,266,133,0,2024,2031,3,250,125,0,2025,2031,3,252,126,0,2026,
  	2031,3,258,129,0,2027,2031,3,260,130,0,2028,2031,3,262,131,0,2029,2031,
  	3,270,135,0,2030,2021,1,0,0,0,2030,2022,1,0,0,0,2030,2023,1,0,0,0,2030,
  	2024,1,0,0,0,2030,2025,1,0,0,0,2030,2026,1,0,0,0,2030,2027,1,0,0,0,2030,
  	2028,1,0,0,0,2030,2029,1,0,0,0,2031,237,1,0,0,0,2032,2039,3,272,136,0,
  	2033,2039,5,136,0,0,2034,2039,3,240,120,0,2035,2039,5,126,0,0,2036,2039,
  	3,242,121,0,2037,2039,3,246,123,0,2038,2032,1,0,0,0,2038,2033,1,0,0,0,
  	2038,2034,1,0,0,0,2038,2035,1,0,0,0,2038,2036,1,0,0,0,2038,2037,1,0,0,
  	0,2039,239,1,0,0,0,2040,2041,7,6,0,0,2041,241,1,0,0,0,2042,2044,5,7,0,
  	0,2043,2045,5,150,0,0,2044,2043,1,0,0,0,2044,2045,1,0,0,0,2045,2059,1,
  	0,0,0,2046,2048,3,190,95,0,2047,2049,5,150,0,0,2048,2047,1,0,0,0,2048,
  	2049,1,0,0,0,2049,2056,1,0,0,0,2050,2052,3,244,122,0,2051,2053,5,150,
  	0,0,2052,2051,1,0,0,0,2052,2053,1,0,0,0,2053,2055,1,0,0,0,2054,2050,1,
  	0,0,0,2055,2058,1,0,0,0,2056,2054,1,0,0,0,2056,2057,1,0,0,0,2057,2060,
  	1,0,0,0,2058,2056,1,0,0,0,2059,2046,1,0,0,0,2059,2060,1,0,0,0,2060,2061,
  	1,0,0,0,2061,2062,5,8,0,0,2062,243,1,0,0,0,2063,2065,5,3,0,0,2064,2066,
  	5,150,0,0,2065,2064,1,0,0,0,2065,2066,1,0,0,0,2066,2068,1,0,0,0,2067,
  	2069,3,190,95,0,2068,2067,1,0,0,0,2068,2069,1,0,0,0,2069,245,1,0,0,0,
  	2070,2072,5,9,0,0,2071,2073,5,150,0,0,2072,2071,1,0,0,0,2072,2073,1,0,
  	0,0,2073,2074,1,0,0,0,2074,2076,3,248,124,0,2075,2077,5,150,0,0,2076,
  	2075,1,0,0,0,2076,2077,1,0,0,0,2077,2088,1,0,0,0,2078,2080,5,3,0,0,2079,
  	2081,5,150,0,0,2080,2079,1,0,0,0,2080,2081,1,0,0,0,2081,2082,1,0,0,0,
  	2082,2084,3,248,124,0,2083,2085,5,150,0,0,2084,2083,1,0,0,0,2084,2085,
  	1,0,0,0,2085,2087,1,0,0,0,2086,2078,1,0,0,0,2087,2090,1,0,0,0,2088,2086,
  	1,0,0,0,2088,2089,1,0,0,0,2089,2091,1,0,0,0,2090,2088,1,0,0,0,2091,2092,
  	5,10,0,0,2092,247,1,0,0,0,2093,2096,3,286,143,0,2094,2096,5,136,0,0,2095,
  	2093,1,0,0,0,2095,2094,1,0,0,0,2096,2098,1,0,0,0,2097,2099,5,150,0,0,
  	2098,2097,1,0,0,0,2098,2099,1,0,0,0,2099,2100,1,0,0,0,2100,2102,5,120,
  	0,0,2101,2103,5,150,0,0,2102,2101,1,0,0,0,2102,2103,1,0,0,0,2103,2104,
  	1,0,0,0,2104,2105,3,190,95,0,2105,249,1,0,0,0,2106,2108,5,2,0,0,2107,
  	2109,5,150,0,0,2108,2107,1,0,0,0,2108,2109,1,0,0,0,2109,2110,1,0,0,0,
  	2110,2112,3,190,95,0,2111,2113,5,150,0,0,2112,2111,1,0,0,0,2112,2113,
  	1,0,0,0,2113,2114,1,0,0,0,2114,2115,5,4,0,0,2115,251,1,0,0,0,2116,2118,
  	5,129,0,0,2117,2119,5,150,0,0,2118,2117,1,0,0,0,2118,2119,1,0,0,0,2119,
  	2120,1,0,0,0,2120,2122,5,2,0,0,2121,2123,5,150,0,0,2122,2121,1,0,0,0,
  	2122,2123,1,0,0,0,2123,2124,1,0,0,0,2124,2126,5,101,0,0,2125,2127,5,150,
  	0,0,2126,2125,1,0,0,0,2126,2127,1,0,0,0,2127,2128,1,0,0,0,2128,2165,5,
  	4,0,0,2129,2131,3,254,127,0,2130,2132,5,150,0,0,2131,2130,1,0,0,0,2131,
  	2132,1,0,0,0,2132,2133,1,0,0,0,2133,2135,5,2,0,0,2134,2136,5,150,0,0,
  	2135,2134,1,0,0,0,2135,2136,1,0,0,0,2136,2141,1,0,0,0,2137,2139,5,100,
  	0,0,2138,2140,5,150,0,0,2139,2138,1,0,0,0,2139,2140,1,0,0,0,2140,2142,
  	1,0,0,0,2141,2137,1,0,0,0,2141,2142,1,0,0,0,2142,2160,1,0,0,0,2143,2145,
  	3,256,128,0,2144,2146,5,150,0,0,2145,2144,1,0,0,0,2145,2146,1,0,0,0,2146,
  	2157,1,0,0,0,2147,2149,5,3,0,0,2148,2150,5,150,0,0,2149,2148,1,0,0,0,
  	2149,2150,1,0,0,0,2150,2151,1,0,0,0,2151,2153,3,256,128,0,2152,2154,5,
  	150,0,0,2153,2152,1,0,0,0,2153,2154,1,0,0,0,2154,2156,1,0,0,0,2155,2147,
  	1,0,0,0,2156,2159,1,0,0,0,2157,2155,1,0,0,0,2157,2158,1,0,0,0,2158,2161,
  	1,0,0,0,2159,2157,1,0,0,0,2160,2143,1,0,0,0,2160,2161,1,0,0,0,2161,2162,
  	1,0,0,0,2162,2163,5,4,0,0,2163,2165,1,0,0,0,2164,2116,1,0,0,0,2164,2129,
  	1,0,0,0,2165,253,1,0,0,0,2166,2167,3,286,143,0,2167,255,1,0,0,0,2168,
  	2170,3,286,143,0,2169,2171,5,150,0,0,2170,2169,1,0,0,0,2170,2171,1,0,
  	0,0,2171,2172,1,0,0,0,2172,2173,5,120,0,0,2173,2175,5,6,0,0,2174,2176,
  	5,150,0,0,2175,2174,1,0,0,0,2175,2176,1,0,0,0,2176,2178,1,0,0,0,2177,
  	2168,1,0,0,0,2177,2178,1,0,0,0,2178,2179,1,0,0,0,2179,2180,3,190,95,0,
  	2180,257,1,0,0,0,2181,2186,3,158,79,0,2182,2184,5,150,0,0,2183,2182,1,
  	0,0,0,2183,2184,1,0,0,0,2184,2185,1,0,0,0,2185,2187,3,160,80,0,2186,2183,
  	1,0,0,0,2187,2188,1,0,0,0,2188,2186,1,0,0,0,2188,2189,1,0,0,0,2189,259,
  	1,0,0,0,2190,2192,5,130,0,0,2191,2193,5,150,0,0,2192,2191,1,0,0,0,2192,
  	2193,1,0,0,0,2193,2194,1,0,0,0,2194,2196,5,9,0,0,2195,2197,5,150,0,0,
  	2196,2195,1,0,0,0,2196,2197,1,0,0,0,2197,2198,1,0,0,0,2198,2200,5,90,
  	0,0,2199,2201,5,150,0,0,2200,2199,1,0,0,0,2200,2201,1,0,0,0,2201,2202,
  	1,0,0,0,2202,2207,3,150,75,0,2203,2205,5,150,0,0,2204,2203,1,0,0,0,2204,
  	2205,1,0,0,0,2205,2206,1,0,0,0,2206,2208,3,148,74,0,2207,2204,1,0,0,0,
  	2207,2208,1,0,0,0,2208,2210,1,0,0,0,2209,2211,5,150,0,0,2210,2209,1,0,
  	0,0,2210,2211,1,0,0,0,2211,2212,1,0,0,0,2212,2213,5,10,0,0,2213,261,1,
  	0,0,0,2214,2216,5,129,0,0,2215,2217,5,150,0,0,2216,2215,1,0,0,0,2216,
  	2217,1,0,0,0,2217,2218,1,0,0,0,2218,2220,5,9,0,0,2219,2221,5,150,0,0,
  	2220,2219,1,0,0,0,2220,2221,1,0,0,0,2221,2222,1,0,0,0,2222,2224,5,90,
  	0,0,2223,2225,5,150,0,0,2224,2223,1,0,0,0,2224,2225,1,0,0,0,2225,2226,
  	1,0,0,0,2226,2231,3,150,75,0,2227,2229,5,150,0,0,2228,2227,1,0,0,0,2228,
  	2229,1,0,0,0,2229,2230,1,0,0,0,2230,2232,3,148,74,0,2231,2228,1,0,0,0,
  	2231,2232,1,0,0,0,2232,2234,1,0,0,0,2233,2235,5,150,0,0,2234,2233,1,0,
  	0,0,2234,2235,1,0,0,0,2235,2236,1,0,0,0,2236,2237,5,10,0,0,2237,263,1,
  	0,0,0,2238,2240,5,5,0,0,2239,2241,5,150,0,0,2240,2239,1,0,0,0,2240,2241,
  	1,0,0,0,2241,2244,1,0,0,0,2242,2245,3,278,139,0,2243,2245,5,101,0,0,2244,
  	2242,1,0,0,0,2244,2243,1,0,0,0,2245,265,1,0,0,0,2246,2251,5,131,0,0,2247,
  	2249,5,150,0,0,2248,2247,1,0,0,0,2248,2249,1,0,0,0,2249,2250,1,0,0,0,
  	2250,2252,3,268,134,0,2251,2248,1,0,0,0,2252,2253,1,0,0,0,2253,2251,1,
  	0,0,0,2253,2254,1,0,0,0,2254,2269,1,0,0,0,2255,2257,5,131,0,0,2256,2258,
  	5,150,0,0,2257,2256,1,0,0,0,2257,2258,1,0,0,0,2258,2259,1,0,0,0,2259,
  	2264,3,190,95,0,2260,2262,5,150,0,0,2261,2260,1,0,0,0,2261,2262,1,0,0,
  	0,2262,2263,1,0,0,0,2263,2265,3,268,134,0,2264,2261,1,0,0,0,2265,2266,
  	1,0,0,0,2266,2264,1,0,0,0,2266,2267,1,0,0,0,2267,2269,1,0,0,0,2268,2246,
  	1,0,0,0,2268,2255,1,0,0,0,2269,2278,1,0,0,0,2270,2272,5,150,0,0,2271,
  	2270,1,0,0,0,2271,2272,1,0,0,0,2272,2273,1,0,0,0,2273,2275,5,132,0,0,
  	2274,2276,5,150,0,0,2275,2274,1,0,0,0,2275,2276,1,0,0,0,2276,2277,1,0,
  	0,0,2277,2279,3,190,95,0,2278,2271,1,0,0,0,2278,2279,1,0,0,0,2279,2281,
  	1,0,0,0,2280,2282,5,150,0,0,2281,2280,1,0,0,0,2281,2282,1,0,0,0,2282,
  	2283,1,0,0,0,2283,2284,5,133,0,0,2284,267,1,0,0,0,2285,2287,5,134,0,0,
  	2286,2288,5,150,0,0,2287,2286,1,0,0,0,2287,2288,1,0,0,0,2288,2289,1,0,
  	0,0,2289,2291,3,190,95,0,2290,2292,5,150,0,0,2291,2290,1,0,0,0,2291,2292,
  	1,0,0,0,2292,2293,1,0,0,0,2293,2295,5,135,0,0,2294,2296,5,150,0,0,2295,
  	2294,1,0,0,0,2295,2296,1,0,0,0,2296,2297,1,0,0,0,2297,2298,3,190,95,0,
  	2298,269,1,0,0,0,2299,2300,3,286,143,0,2300,271,1,0,0,0,2301,2304,3,282,
  	141,0,2302,2304,3,280,140,0,2303,2301,1,0,0,0,2303,2302,1,0,0,0,2304,
  	273,1,0,0,0,2305,2308,5,26,0,0,2306,2309,3,286,143,0,2307,2309,5,138,
  	0,0,2308,2306,1,0,0,0,2308,2307,1,0,0,0,2309,275,1,0,0,0,2310,2312,3,
  	236,118,0,2311,2313,5,150,0,0,2312,2311,1,0,0,0,2312,2313,1,0,0,0,2313,
  	2314,1,0,0,0,2314,2315,3,264,132,0,2315,277,1,0,0,0,2316,2317,3,284,142,
  	0,2317,279,1,0,0,0,2318,2319,5,138,0,0,2319,281,1,0,0,0,2320,2321,5,145,
  	0,0,2321,283,1,0,0,0,2322,2323,3,286,143,0,2323,285,1,0,0,0,2324,2330,
  	5,146,0,0,2325,2326,5,149,0,0,2326,2330,6,143,-1,0,2327,2330,5,139,0,
  	0,2328,2330,3,288,144,0,2329,2324,1,0,0,0,2329,2325,1,0,0,0,2329,2327,
  	1,0,0,0,2329,2328,1,0,0,0,2330,287,1,0,0,0,2331,2332,7,7,0,0,2332,289,
  	1,0,0,0,2333,2334,7,8,0,0,2334,291,1,0,0,0,2335,2336,7,9,0,0,2336,293,
  	1,0,0,0,2337,2338,7,10,0,0,2338,295,1,0,0,0,401,298,302,307,311,316,319,
  	323,326,348,354,358,361,367,370,374,378,382,387,391,398,402,410,414,424,
  	428,432,437,450,454,462,465,473,476,493,496,500,506,509,523,527,549,553,
  	556,559,562,565,569,574,578,588,592,597,602,607,613,617,621,626,633,637,
  	641,644,648,652,656,661,665,671,675,687,691,695,699,704,716,720,724,728,
  	732,734,738,742,744,758,762,766,770,775,778,782,786,788,792,796,798,834,
  	845,867,871,876,887,891,895,903,907,911,917,921,925,931,935,939,943,947,
  	951,957,964,969,975,995,999,1007,1017,1022,1027,1031,1036,1042,1047,1050,
  	1054,1058,1062,1068,1072,1077,1082,1086,1089,1093,1097,1101,1105,1109,
  	1115,1119,1124,1128,1137,1143,1151,1155,1159,1163,1170,1173,1176,1179,
  	1185,1188,1192,1196,1200,1203,1207,1217,1223,1230,1243,1247,1251,1255,
  	1260,1265,1269,1275,1279,1283,1287,1292,1298,1301,1307,1310,1316,1320,
  	1324,1328,1332,1337,1342,1346,1351,1354,1363,1372,1377,1390,1393,1401,
  	1405,1410,1415,1419,1424,1430,1435,1442,1446,1450,1452,1456,1458,1462,
  	1464,1470,1476,1480,1483,1486,1492,1495,1498,1502,1508,1511,1514,1518,
  	1522,1526,1528,1532,1534,1538,1540,1544,1546,1552,1556,1560,1564,1568,
  	1572,1576,1580,1584,1587,1593,1597,1601,1604,1609,1614,1619,1624,1630,
  	1636,1639,1642,1645,1649,1652,1655,1658,1661,1665,1669,1673,1677,1681,
  	1684,1687,1691,1695,1699,1703,1705,1711,1714,1717,1723,1726,1729,1750,
  	1760,1770,1775,1779,1786,1790,1794,1798,1802,1810,1814,1818,1822,1828,
  	1832,1838,1842,1847,1852,1856,1861,1866,1870,1876,1883,1887,1893,1900,
  	1904,1910,1917,1921,1926,1931,1935,1940,1943,1950,1953,1958,1967,1971,
  	1974,1987,1990,1995,2009,2013,2018,2030,2038,2044,2048,2052,2056,2059,
  	2065,2068,2072,2076,2080,2084,2088,2095,2098,2102,2108,2112,2118,2122,
  	2126,2131,2135,2139,2141,2145,2149,2153,2157,2160,2164,2170,2175,2177,
  	2183,2188,2192,2196,2200,2204,2207,2210,2216,2220,2224,2228,2231,2234,
  	2240,2244,2248,2253,2257,2261,2266,2268,2271,2275,2278,2281,2287,2291,
  	2295,2303,2308,2312,2329
  };
  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;
}


//----------------- Ku_StatementsContext ------------------------------------------------------------------

CypherParser::Ku_StatementsContext::Ku_StatementsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_CypherContext *> CypherParser::Ku_StatementsContext::oC_Cypher() {
  return getRuleContexts<CypherParser::OC_CypherContext>();
}

CypherParser::OC_CypherContext* CypherParser::Ku_StatementsContext::oC_Cypher(size_t i) {
  return getRuleContext<CypherParser::OC_CypherContext>(i);
}

tree::TerminalNode* CypherParser::Ku_StatementsContext::EOF() {
  return getToken(CypherParser::EOF, 0);
}

std::vector<tree::TerminalNode *> CypherParser::Ku_StatementsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::Ku_StatementsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::Ku_StatementsContext::getRuleIndex() const {
  return CypherParser::RuleKu_Statements;
}


CypherParser::Ku_StatementsContext* CypherParser::ku_Statements() {
  Ku_StatementsContext *_localctx = _tracker.createInstance<Ku_StatementsContext>(_ctx, getState());
  enterRule(_localctx, 0, CypherParser::RuleKu_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(296);
    oC_Cypher();
    setState(307);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(298);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(297);
          match(CypherParser::SP);
        }
        setState(300);
        match(CypherParser::T__0);
        setState(302);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
        case 1: {
          setState(301);
          match(CypherParser::SP);
          break;
        }

        default:
          break;
        }
        setState(304);
        oC_Cypher(); 
      }
      setState(309);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
    }
    setState(311);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(310);
      match(CypherParser::SP);
    }
    setState(313);
    match(CypherParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_CypherContext ------------------------------------------------------------------

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(316);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::EXPLAIN

    || _la == CypherParser::PROFILE) {
      setState(315);
      oC_AnyCypherOption();
    }
    setState(319);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(318);
      match(CypherParser::SP);
    }

    setState(321);
    oC_Statement();
    setState(326);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
    case 1: {
      setState(323);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(322);
        match(CypherParser::SP);
      }
      setState(325);
      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;
}

//----------------- OC_StatementContext ------------------------------------------------------------------

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::KU_CreateNodeTableContext* CypherParser::OC_StatementContext::kU_CreateNodeTable() {
  return getRuleContext<CypherParser::KU_CreateNodeTableContext>(0);
}

CypherParser::KU_CreateRelTableContext* CypherParser::OC_StatementContext::kU_CreateRelTable() {
  return getRuleContext<CypherParser::KU_CreateRelTableContext>(0);
}

CypherParser::KU_CreateRelTableGroupContext* CypherParser::OC_StatementContext::kU_CreateRelTableGroup() {
  return getRuleContext<CypherParser::KU_CreateRelTableGroupContext>(0);
}

CypherParser::KU_CreateRdfGraphContext* CypherParser::OC_StatementContext::kU_CreateRdfGraph() {
  return getRuleContext<CypherParser::KU_CreateRdfGraphContext>(0);
}

CypherParser::KU_DropTableContext* CypherParser::OC_StatementContext::kU_DropTable() {
  return getRuleContext<CypherParser::KU_DropTableContext>(0);
}

CypherParser::KU_AlterTableContext* CypherParser::OC_StatementContext::kU_AlterTable() {
  return getRuleContext<CypherParser::KU_AlterTableContext>(0);
}

CypherParser::KU_CopyFromContext* CypherParser::OC_StatementContext::kU_CopyFrom() {
  return getRuleContext<CypherParser::KU_CopyFromContext>(0);
}

CypherParser::KU_CopyFromByColumnContext* CypherParser::OC_StatementContext::kU_CopyFromByColumn() {
  return getRuleContext<CypherParser::KU_CopyFromByColumnContext>(0);
}

CypherParser::KU_CopyTOContext* CypherParser::OC_StatementContext::kU_CopyTO() {
  return getRuleContext<CypherParser::KU_CopyTOContext>(0);
}

CypherParser::KU_StandaloneCallContext* CypherParser::OC_StatementContext::kU_StandaloneCall() {
  return getRuleContext<CypherParser::KU_StandaloneCallContext>(0);
}

CypherParser::KU_CreateMacroContext* CypherParser::OC_StatementContext::kU_CreateMacro() {
  return getRuleContext<CypherParser::KU_CreateMacroContext>(0);
}

CypherParser::KU_CommentOnContext* CypherParser::OC_StatementContext::kU_CommentOn() {
  return getRuleContext<CypherParser::KU_CommentOnContext>(0);
}

CypherParser::KU_TransactionContext* CypherParser::OC_StatementContext::kU_Transaction() {
  return getRuleContext<CypherParser::KU_TransactionContext>(0);
}

CypherParser::KU_ExtensionContext* CypherParser::OC_StatementContext::kU_Extension() {
  return getRuleContext<CypherParser::KU_ExtensionContext>(0);
}

CypherParser::KU_ExportDatabaseContext* CypherParser::OC_StatementContext::kU_ExportDatabase() {
  return getRuleContext<CypherParser::KU_ExportDatabaseContext>(0);
}

CypherParser::KU_ImportDatabaseContext* CypherParser::OC_StatementContext::kU_ImportDatabase() {
  return getRuleContext<CypherParser::KU_ImportDatabaseContext>(0);
}

CypherParser::KU_AttachDatabaseContext* CypherParser::OC_StatementContext::kU_AttachDatabase() {
  return getRuleContext<CypherParser::KU_AttachDatabaseContext>(0);
}

CypherParser::KU_DetachDatabaseContext* CypherParser::OC_StatementContext::kU_DetachDatabase() {
  return getRuleContext<CypherParser::KU_DetachDatabaseContext>(0);
}

CypherParser::KU_UseDatabaseContext* CypherParser::OC_StatementContext::kU_UseDatabase() {
  return getRuleContext<CypherParser::KU_UseDatabaseContext>(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(348);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(328);
      oC_Query();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(329);
      kU_CreateNodeTable();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(330);
      kU_CreateRelTable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(331);
      kU_CreateRelTableGroup();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(332);
      kU_CreateRdfGraph();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(333);
      kU_DropTable();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(334);
      kU_AlterTable();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(335);
      kU_CopyFrom();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(336);
      kU_CopyFromByColumn();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(337);
      kU_CopyTO();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(338);
      kU_StandaloneCall();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(339);
      kU_CreateMacro();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(340);
      kU_CommentOn();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(341);
      kU_Transaction();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(342);
      kU_Extension();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(343);
      kU_ExportDatabase();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(344);
      kU_ImportDatabase();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(345);
      kU_AttachDatabase();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(346);
      kU_DetachDatabase();
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(347);
      kU_UseDatabase();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CopyFromContext ------------------------------------------------------------------

CypherParser::KU_CopyFromContext::KU_CopyFromContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CopyFromContext::COPY() {
  return getToken(CypherParser::COPY, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CopyFromContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CopyFromContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CopyFromContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_CopyFromContext::FROM() {
  return getToken(CypherParser::FROM, 0);
}

CypherParser::KU_ScanSourceContext* CypherParser::KU_CopyFromContext::kU_ScanSource() {
  return getRuleContext<CypherParser::KU_ScanSourceContext>(0);
}

CypherParser::KU_ParsingOptionsContext* CypherParser::KU_CopyFromContext::kU_ParsingOptions() {
  return getRuleContext<CypherParser::KU_ParsingOptionsContext>(0);
}

CypherParser::KU_ColumnNamesContext* CypherParser::KU_CopyFromContext::kU_ColumnNames() {
  return getRuleContext<CypherParser::KU_ColumnNamesContext>(0);
}


size_t CypherParser::KU_CopyFromContext::getRuleIndex() const {
  return CypherParser::RuleKU_CopyFrom;
}


CypherParser::KU_CopyFromContext* CypherParser::kU_CopyFrom() {
  KU_CopyFromContext *_localctx = _tracker.createInstance<KU_CopyFromContext>(_ctx, getState());
  enterRule(_localctx, 6, CypherParser::RuleKU_CopyFrom);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(350);
    match(CypherParser::COPY);
    setState(351);
    match(CypherParser::SP);
    setState(352);
    oC_SchemaName();
    setState(361);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {
    case 1: {
      setState(354);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(353);
        match(CypherParser::SP);
      }
      setState(356);
      kU_ColumnNames();
      setState(358);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(357);
        match(CypherParser::SP);
      }
      break;
    }

    case 2: {
      setState(360);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(363);
    match(CypherParser::FROM);
    setState(364);
    match(CypherParser::SP);
    setState(365);
    kU_ScanSource();
    setState(370);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx)) {
    case 1: {
      setState(367);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(366);
        match(CypherParser::SP);
      }
      setState(369);
      kU_ParsingOptions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ColumnNamesContext ------------------------------------------------------------------

CypherParser::KU_ColumnNamesContext::KU_ColumnNamesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_SchemaNameContext *> CypherParser::KU_ColumnNamesContext::oC_SchemaName() {
  return getRuleContexts<CypherParser::OC_SchemaNameContext>();
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_ColumnNamesContext::oC_SchemaName(size_t i) {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_ColumnNamesContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_ColumnNamesContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_ColumnNamesContext::getRuleIndex() const {
  return CypherParser::RuleKU_ColumnNames;
}


CypherParser::KU_ColumnNamesContext* CypherParser::kU_ColumnNames() {
  KU_ColumnNamesContext *_localctx = _tracker.createInstance<KU_ColumnNamesContext>(_ctx, getState());
  enterRule(_localctx, 8, CypherParser::RuleKU_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(372);
    match(CypherParser::T__1);
    setState(374);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(373);
      match(CypherParser::SP);
    }
    setState(376);
    oC_SchemaName();
    setState(387);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(378);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(377);
          match(CypherParser::SP);
        }
        setState(380);
        match(CypherParser::T__2);
        setState(382);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(381);
          match(CypherParser::SP);
        }
        setState(384);
        oC_SchemaName(); 
      }
      setState(389);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx);
    }
    setState(391);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(390);
      match(CypherParser::SP);
    }
    setState(393);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ScanSourceContext ------------------------------------------------------------------

CypherParser::KU_ScanSourceContext::KU_ScanSourceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::KU_FilePathsContext* CypherParser::KU_ScanSourceContext::kU_FilePaths() {
  return getRuleContext<CypherParser::KU_FilePathsContext>(0);
}

CypherParser::OC_QueryContext* CypherParser::KU_ScanSourceContext::oC_Query() {
  return getRuleContext<CypherParser::OC_QueryContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_ScanSourceContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_ScanSourceContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_VariableContext* CypherParser::KU_ScanSourceContext::oC_Variable() {
  return getRuleContext<CypherParser::OC_VariableContext>(0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_ScanSourceContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}


size_t CypherParser::KU_ScanSourceContext::getRuleIndex() const {
  return CypherParser::RuleKU_ScanSource;
}


CypherParser::KU_ScanSourceContext* CypherParser::kU_ScanSource() {
  KU_ScanSourceContext *_localctx = _tracker.createInstance<KU_ScanSourceContext>(_ctx, getState());
  enterRule(_localctx, 10, CypherParser::RuleKU_ScanSource);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(414);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(395);
      kU_FilePaths();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(396);
      match(CypherParser::T__1);
      setState(398);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(397);
        match(CypherParser::SP);
      }
      setState(400);
      oC_Query();
      setState(402);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(401);
        match(CypherParser::SP);
      }
      setState(404);
      match(CypherParser::T__3);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(406);
      oC_Variable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(407);
      oC_Variable();
      setState(408);
      match(CypherParser::T__4);
      setState(410);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(409);
        match(CypherParser::SP);
      }
      setState(412);
      oC_SchemaName();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CopyFromByColumnContext ------------------------------------------------------------------

CypherParser::KU_CopyFromByColumnContext::KU_CopyFromByColumnContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CopyFromByColumnContext::COPY() {
  return getToken(CypherParser::COPY, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CopyFromByColumnContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CopyFromByColumnContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CopyFromByColumnContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_CopyFromByColumnContext::FROM() {
  return getToken(CypherParser::FROM, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CopyFromByColumnContext::StringLiteral() {
  return getTokens(CypherParser::StringLiteral);
}

tree::TerminalNode* CypherParser::KU_CopyFromByColumnContext::StringLiteral(size_t i) {
  return getToken(CypherParser::StringLiteral, i);
}

tree::TerminalNode* CypherParser::KU_CopyFromByColumnContext::BY() {
  return getToken(CypherParser::BY, 0);
}

tree::TerminalNode* CypherParser::KU_CopyFromByColumnContext::COLUMN() {
  return getToken(CypherParser::COLUMN, 0);
}


size_t CypherParser::KU_CopyFromByColumnContext::getRuleIndex() const {
  return CypherParser::RuleKU_CopyFromByColumn;
}


CypherParser::KU_CopyFromByColumnContext* CypherParser::kU_CopyFromByColumn() {
  KU_CopyFromByColumnContext *_localctx = _tracker.createInstance<KU_CopyFromByColumnContext>(_ctx, getState());
  enterRule(_localctx, 12, CypherParser::RuleKU_CopyFromByColumn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(416);
    match(CypherParser::COPY);
    setState(417);
    match(CypherParser::SP);
    setState(418);
    oC_SchemaName();
    setState(419);
    match(CypherParser::SP);
    setState(420);
    match(CypherParser::FROM);
    setState(421);
    match(CypherParser::SP);
    setState(422);
    match(CypherParser::T__1);
    setState(424);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(423);
      match(CypherParser::SP);
    }
    setState(426);
    match(CypherParser::StringLiteral);
    setState(437);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__2 || _la == CypherParser::SP) {
      setState(428);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(427);
        match(CypherParser::SP);
      }
      setState(430);
      match(CypherParser::T__2);
      setState(432);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(431);
        match(CypherParser::SP);
      }
      setState(434);
      match(CypherParser::StringLiteral);
      setState(439);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(440);
    match(CypherParser::T__3);
    setState(441);
    match(CypherParser::SP);
    setState(442);
    match(CypherParser::BY);
    setState(443);
    match(CypherParser::SP);
    setState(444);
    match(CypherParser::COLUMN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CopyTOContext ------------------------------------------------------------------

CypherParser::KU_CopyTOContext::KU_CopyTOContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CopyTOContext::COPY() {
  return getToken(CypherParser::COPY, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CopyTOContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CopyTOContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_QueryContext* CypherParser::KU_CopyTOContext::oC_Query() {
  return getRuleContext<CypherParser::OC_QueryContext>(0);
}

tree::TerminalNode* CypherParser::KU_CopyTOContext::TO() {
  return getToken(CypherParser::TO, 0);
}

tree::TerminalNode* CypherParser::KU_CopyTOContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}

CypherParser::KU_ParsingOptionsContext* CypherParser::KU_CopyTOContext::kU_ParsingOptions() {
  return getRuleContext<CypherParser::KU_ParsingOptionsContext>(0);
}


size_t CypherParser::KU_CopyTOContext::getRuleIndex() const {
  return CypherParser::RuleKU_CopyTO;
}


CypherParser::KU_CopyTOContext* CypherParser::kU_CopyTO() {
  KU_CopyTOContext *_localctx = _tracker.createInstance<KU_CopyTOContext>(_ctx, getState());
  enterRule(_localctx, 14, CypherParser::RuleKU_CopyTO);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(446);
    match(CypherParser::COPY);
    setState(447);
    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(452);
    oC_Query();
    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(457);
    match(CypherParser::SP);
    setState(458);
    match(CypherParser::TO);
    setState(459);
    match(CypherParser::SP);
    setState(460);
    match(CypherParser::StringLiteral);
    setState(465);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
    case 1: {
      setState(462);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(461);
        match(CypherParser::SP);
      }
      setState(464);
      kU_ParsingOptions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ExportDatabaseContext ------------------------------------------------------------------

CypherParser::KU_ExportDatabaseContext::KU_ExportDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_ExportDatabaseContext::EXPORT() {
  return getToken(CypherParser::EXPORT, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_ExportDatabaseContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_ExportDatabaseContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_ExportDatabaseContext::DATABASE() {
  return getToken(CypherParser::DATABASE, 0);
}

tree::TerminalNode* CypherParser::KU_ExportDatabaseContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}

CypherParser::KU_ParsingOptionsContext* CypherParser::KU_ExportDatabaseContext::kU_ParsingOptions() {
  return getRuleContext<CypherParser::KU_ParsingOptionsContext>(0);
}


size_t CypherParser::KU_ExportDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleKU_ExportDatabase;
}


CypherParser::KU_ExportDatabaseContext* CypherParser::kU_ExportDatabase() {
  KU_ExportDatabaseContext *_localctx = _tracker.createInstance<KU_ExportDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 16, CypherParser::RuleKU_ExportDatabase);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(467);
    match(CypherParser::EXPORT);
    setState(468);
    match(CypherParser::SP);
    setState(469);
    match(CypherParser::DATABASE);
    setState(470);
    match(CypherParser::SP);
    setState(471);
    match(CypherParser::StringLiteral);
    setState(476);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
    case 1: {
      setState(473);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(472);
        match(CypherParser::SP);
      }
      setState(475);
      kU_ParsingOptions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ImportDatabaseContext ------------------------------------------------------------------

CypherParser::KU_ImportDatabaseContext::KU_ImportDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_ImportDatabaseContext::IMPORT() {
  return getToken(CypherParser::IMPORT, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_ImportDatabaseContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_ImportDatabaseContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_ImportDatabaseContext::DATABASE() {
  return getToken(CypherParser::DATABASE, 0);
}

tree::TerminalNode* CypherParser::KU_ImportDatabaseContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}


size_t CypherParser::KU_ImportDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleKU_ImportDatabase;
}


CypherParser::KU_ImportDatabaseContext* CypherParser::kU_ImportDatabase() {
  KU_ImportDatabaseContext *_localctx = _tracker.createInstance<KU_ImportDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 18, CypherParser::RuleKU_ImportDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(478);
    match(CypherParser::IMPORT);
    setState(479);
    match(CypherParser::SP);
    setState(480);
    match(CypherParser::DATABASE);
    setState(481);
    match(CypherParser::SP);
    setState(482);
    match(CypherParser::StringLiteral);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_AttachDatabaseContext ------------------------------------------------------------------

CypherParser::KU_AttachDatabaseContext::KU_AttachDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_AttachDatabaseContext::ATTACH() {
  return getToken(CypherParser::ATTACH, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_AttachDatabaseContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_AttachDatabaseContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_AttachDatabaseContext::StringLiteral() {
  return getTokens(CypherParser::StringLiteral);
}

tree::TerminalNode* CypherParser::KU_AttachDatabaseContext::StringLiteral(size_t i) {
  return getToken(CypherParser::StringLiteral, i);
}

tree::TerminalNode* CypherParser::KU_AttachDatabaseContext::AS() {
  return getToken(CypherParser::AS, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_AttachDatabaseContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_AttachDatabaseContext::DBTYPE() {
  return getToken(CypherParser::DBTYPE, 0);
}


size_t CypherParser::KU_AttachDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleKU_AttachDatabase;
}


CypherParser::KU_AttachDatabaseContext* CypherParser::kU_AttachDatabase() {
  KU_AttachDatabaseContext *_localctx = _tracker.createInstance<KU_AttachDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 20, CypherParser::RuleKU_AttachDatabase);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(484);
    match(CypherParser::ATTACH);
    setState(485);
    match(CypherParser::SP);
    setState(486);
    match(CypherParser::StringLiteral);
    setState(493);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx)) {
    case 1: {
      setState(487);
      match(CypherParser::SP);
      setState(488);
      match(CypherParser::AS);
      setState(489);
      match(CypherParser::SP);
      setState(490);
      oC_SchemaName();
      setState(491);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(509);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx)) {
    case 1: {
      setState(496);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(495);
        match(CypherParser::SP);
      }
      setState(498);
      match(CypherParser::T__1);
      setState(500);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(499);
        match(CypherParser::SP);
      }
      setState(502);
      match(CypherParser::DBTYPE);
      setState(503);
      match(CypherParser::SP);
      setState(504);
      match(CypherParser::StringLiteral);
      setState(506);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(505);
        match(CypherParser::SP);
      }
      setState(508);
      match(CypherParser::T__3);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_DetachDatabaseContext ------------------------------------------------------------------

CypherParser::KU_DetachDatabaseContext::KU_DetachDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_DetachDatabaseContext::DETACH() {
  return getToken(CypherParser::DETACH, 0);
}

tree::TerminalNode* CypherParser::KU_DetachDatabaseContext::SP() {
  return getToken(CypherParser::SP, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_DetachDatabaseContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}


size_t CypherParser::KU_DetachDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleKU_DetachDatabase;
}


CypherParser::KU_DetachDatabaseContext* CypherParser::kU_DetachDatabase() {
  KU_DetachDatabaseContext *_localctx = _tracker.createInstance<KU_DetachDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 22, CypherParser::RuleKU_DetachDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(511);
    match(CypherParser::DETACH);
    setState(512);
    match(CypherParser::SP);
    setState(513);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_UseDatabaseContext ------------------------------------------------------------------

CypherParser::KU_UseDatabaseContext::KU_UseDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_UseDatabaseContext::USE() {
  return getToken(CypherParser::USE, 0);
}

tree::TerminalNode* CypherParser::KU_UseDatabaseContext::SP() {
  return getToken(CypherParser::SP, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_UseDatabaseContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}


size_t CypherParser::KU_UseDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleKU_UseDatabase;
}


CypherParser::KU_UseDatabaseContext* CypherParser::kU_UseDatabase() {
  KU_UseDatabaseContext *_localctx = _tracker.createInstance<KU_UseDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 24, CypherParser::RuleKU_UseDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(515);
    match(CypherParser::USE);
    setState(516);
    match(CypherParser::SP);
    setState(517);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_StandaloneCallContext ------------------------------------------------------------------

CypherParser::KU_StandaloneCallContext::KU_StandaloneCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_StandaloneCallContext::CALL() {
  return getToken(CypherParser::CALL, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_StandaloneCallContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_StandaloneCallContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_StandaloneCallContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

CypherParser::OC_ExpressionContext* CypherParser::KU_StandaloneCallContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}


size_t CypherParser::KU_StandaloneCallContext::getRuleIndex() const {
  return CypherParser::RuleKU_StandaloneCall;
}


CypherParser::KU_StandaloneCallContext* CypherParser::kU_StandaloneCall() {
  KU_StandaloneCallContext *_localctx = _tracker.createInstance<KU_StandaloneCallContext>(_ctx, getState());
  enterRule(_localctx, 26, CypherParser::RuleKU_StandaloneCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(519);
    match(CypherParser::CALL);
    setState(520);
    match(CypherParser::SP);
    setState(521);
    oC_SymbolicName();
    setState(523);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(522);
      match(CypherParser::SP);
    }
    setState(525);
    match(CypherParser::T__5);
    setState(527);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(526);
      match(CypherParser::SP);
    }
    setState(529);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CommentOnContext ------------------------------------------------------------------

CypherParser::KU_CommentOnContext::KU_CommentOnContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CommentOnContext::COMMENT_() {
  return getToken(CypherParser::COMMENT_, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CommentOnContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CommentOnContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CommentOnContext::ON() {
  return getToken(CypherParser::ON, 0);
}

tree::TerminalNode* CypherParser::KU_CommentOnContext::TABLE() {
  return getToken(CypherParser::TABLE, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CommentOnContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_CommentOnContext::IS() {
  return getToken(CypherParser::IS, 0);
}

tree::TerminalNode* CypherParser::KU_CommentOnContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}


size_t CypherParser::KU_CommentOnContext::getRuleIndex() const {
  return CypherParser::RuleKU_CommentOn;
}


CypherParser::KU_CommentOnContext* CypherParser::kU_CommentOn() {
  KU_CommentOnContext *_localctx = _tracker.createInstance<KU_CommentOnContext>(_ctx, getState());
  enterRule(_localctx, 28, CypherParser::RuleKU_CommentOn);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(531);
    match(CypherParser::COMMENT_);
    setState(532);
    match(CypherParser::SP);
    setState(533);
    match(CypherParser::ON);
    setState(534);
    match(CypherParser::SP);
    setState(535);
    match(CypherParser::TABLE);
    setState(536);
    match(CypherParser::SP);
    setState(537);
    oC_SchemaName();
    setState(538);
    match(CypherParser::SP);
    setState(539);
    match(CypherParser::IS);
    setState(540);
    match(CypherParser::SP);
    setState(541);
    match(CypherParser::StringLiteral);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateMacroContext ------------------------------------------------------------------

CypherParser::KU_CreateMacroContext::KU_CreateMacroContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CreateMacroContext::CREATE() {
  return getToken(CypherParser::CREATE, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CreateMacroContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CreateMacroContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CreateMacroContext::MACRO() {
  return getToken(CypherParser::MACRO, 0);
}

CypherParser::OC_FunctionNameContext* CypherParser::KU_CreateMacroContext::oC_FunctionName() {
  return getRuleContext<CypherParser::OC_FunctionNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_CreateMacroContext::AS() {
  return getToken(CypherParser::AS, 0);
}

CypherParser::OC_ExpressionContext* CypherParser::KU_CreateMacroContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}

CypherParser::KU_PositionalArgsContext* CypherParser::KU_CreateMacroContext::kU_PositionalArgs() {
  return getRuleContext<CypherParser::KU_PositionalArgsContext>(0);
}

std::vector<CypherParser::KU_DefaultArgContext *> CypherParser::KU_CreateMacroContext::kU_DefaultArg() {
  return getRuleContexts<CypherParser::KU_DefaultArgContext>();
}

CypherParser::KU_DefaultArgContext* CypherParser::KU_CreateMacroContext::kU_DefaultArg(size_t i) {
  return getRuleContext<CypherParser::KU_DefaultArgContext>(i);
}


size_t CypherParser::KU_CreateMacroContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateMacro;
}


CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() {
  KU_CreateMacroContext *_localctx = _tracker.createInstance<KU_CreateMacroContext>(_ctx, getState());
  enterRule(_localctx, 30, CypherParser::RuleKU_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(543);
    match(CypherParser::CREATE);
    setState(544);
    match(CypherParser::SP);
    setState(545);
    match(CypherParser::MACRO);
    setState(546);
    match(CypherParser::SP);
    setState(547);
    oC_FunctionName();
    setState(549);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(548);
      match(CypherParser::SP);
    }
    setState(551);
    match(CypherParser::T__1);
    setState(553);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
    case 1: {
      setState(552);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(556);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 42, _ctx)) {
    case 1: {
      setState(555);
      kU_PositionalArgs();
      break;
    }

    default:
      break;
    }
    setState(559);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
    case 1: {
      setState(558);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(562);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 48) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 48)) & 71307013) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 121)) & 302256385) != 0)) {
      setState(561);
      kU_DefaultArg();
    }
    setState(574);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(565);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(564);
          match(CypherParser::SP);
        }
        setState(567);
        match(CypherParser::T__2);
        setState(569);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(568);
          match(CypherParser::SP);
        }
        setState(571);
        kU_DefaultArg(); 
      }
      setState(576);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx);
    }
    setState(578);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(577);
      match(CypherParser::SP);
    }
    setState(580);
    match(CypherParser::T__3);
    setState(581);
    match(CypherParser::SP);
    setState(582);
    match(CypherParser::AS);
    setState(583);
    match(CypherParser::SP);
    setState(584);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_PositionalArgsContext ------------------------------------------------------------------

CypherParser::KU_PositionalArgsContext::KU_PositionalArgsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_SymbolicNameContext *> CypherParser::KU_PositionalArgsContext::oC_SymbolicName() {
  return getRuleContexts<CypherParser::OC_SymbolicNameContext>();
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_PositionalArgsContext::oC_SymbolicName(size_t i) {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_PositionalArgsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_PositionalArgsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_PositionalArgsContext::getRuleIndex() const {
  return CypherParser::RuleKU_PositionalArgs;
}


CypherParser::KU_PositionalArgsContext* CypherParser::kU_PositionalArgs() {
  KU_PositionalArgsContext *_localctx = _tracker.createInstance<KU_PositionalArgsContext>(_ctx, getState());
  enterRule(_localctx, 32, CypherParser::RuleKU_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(586);
    oC_SymbolicName();
    setState(597);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(588);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(587);
          match(CypherParser::SP);
        }
        setState(590);
        match(CypherParser::T__2);
        setState(592);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(591);
          match(CypherParser::SP);
        }
        setState(594);
        oC_SymbolicName(); 
      }
      setState(599);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_DefaultArgContext ------------------------------------------------------------------

CypherParser::KU_DefaultArgContext::KU_DefaultArgContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_DefaultArgContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_DefaultArgContext::COLON() {
  return getToken(CypherParser::COLON, 0);
}

CypherParser::OC_LiteralContext* CypherParser::KU_DefaultArgContext::oC_Literal() {
  return getRuleContext<CypherParser::OC_LiteralContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_DefaultArgContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_DefaultArgContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_DefaultArgContext::getRuleIndex() const {
  return CypherParser::RuleKU_DefaultArg;
}


CypherParser::KU_DefaultArgContext* CypherParser::kU_DefaultArg() {
  KU_DefaultArgContext *_localctx = _tracker.createInstance<KU_DefaultArgContext>(_ctx, getState());
  enterRule(_localctx, 34, CypherParser::RuleKU_DefaultArg);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(600);
    oC_SymbolicName();
    setState(602);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(601);
      match(CypherParser::SP);
    }
    setState(604);
    match(CypherParser::COLON);
    setState(605);
    match(CypherParser::T__5);
    setState(607);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(606);
      match(CypherParser::SP);
    }
    setState(609);
    oC_Literal();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_FilePathsContext ------------------------------------------------------------------

CypherParser::KU_FilePathsContext::KU_FilePathsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CypherParser::KU_FilePathsContext::StringLiteral() {
  return getTokens(CypherParser::StringLiteral);
}

tree::TerminalNode* CypherParser::KU_FilePathsContext::StringLiteral(size_t i) {
  return getToken(CypherParser::StringLiteral, i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_FilePathsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_FilePathsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_FilePathsContext::GLOB() {
  return getToken(CypherParser::GLOB, 0);
}


size_t CypherParser::KU_FilePathsContext::getRuleIndex() const {
  return CypherParser::RuleKU_FilePaths;
}


CypherParser::KU_FilePathsContext* CypherParser::kU_FilePaths() {
  KU_FilePathsContext *_localctx = _tracker.createInstance<KU_FilePathsContext>(_ctx, getState());
  enterRule(_localctx, 36, CypherParser::RuleKU_FilePaths);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(644);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::T__6: {
        enterOuterAlt(_localctx, 1);
        setState(611);
        match(CypherParser::T__6);
        setState(613);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(612);
          match(CypherParser::SP);
        }
        setState(615);
        match(CypherParser::StringLiteral);
        setState(626);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__2 || _la == CypherParser::SP) {
          setState(617);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(616);
            match(CypherParser::SP);
          }
          setState(619);
          match(CypherParser::T__2);
          setState(621);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(620);
            match(CypherParser::SP);
          }
          setState(623);
          match(CypherParser::StringLiteral);
          setState(628);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(629);
        match(CypherParser::T__7);
        break;
      }

      case CypherParser::StringLiteral: {
        enterOuterAlt(_localctx, 2);
        setState(630);
        match(CypherParser::StringLiteral);
        break;
      }

      case CypherParser::GLOB: {
        enterOuterAlt(_localctx, 3);
        setState(631);
        match(CypherParser::GLOB);
        setState(633);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(632);
          match(CypherParser::SP);
        }
        setState(635);
        match(CypherParser::T__1);
        setState(637);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(636);
          match(CypherParser::SP);
        }
        setState(639);
        match(CypherParser::StringLiteral);
        setState(641);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(640);
          match(CypherParser::SP);
        }
        setState(643);
        match(CypherParser::T__3);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ParsingOptionsContext ------------------------------------------------------------------

CypherParser::KU_ParsingOptionsContext::KU_ParsingOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_ParsingOptionContext *> CypherParser::KU_ParsingOptionsContext::kU_ParsingOption() {
  return getRuleContexts<CypherParser::KU_ParsingOptionContext>();
}

CypherParser::KU_ParsingOptionContext* CypherParser::KU_ParsingOptionsContext::kU_ParsingOption(size_t i) {
  return getRuleContext<CypherParser::KU_ParsingOptionContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_ParsingOptionsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_ParsingOptionsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_ParsingOptionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_ParsingOptions;
}


CypherParser::KU_ParsingOptionsContext* CypherParser::kU_ParsingOptions() {
  KU_ParsingOptionsContext *_localctx = _tracker.createInstance<KU_ParsingOptionsContext>(_ctx, getState());
  enterRule(_localctx, 38, CypherParser::RuleKU_ParsingOptions);
  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(646);
    match(CypherParser::T__1);
    setState(648);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(647);
      match(CypherParser::SP);
    }
    setState(650);
    kU_ParsingOption();
    setState(661);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(652);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(651);
          match(CypherParser::SP);
        }
        setState(654);
        match(CypherParser::T__2);
        setState(656);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(655);
          match(CypherParser::SP);
        }
        setState(658);
        kU_ParsingOption(); 
      }
      setState(663);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx);
    }
    setState(665);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(664);
      match(CypherParser::SP);
    }
    setState(667);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ParsingOptionContext ------------------------------------------------------------------

CypherParser::KU_ParsingOptionContext::KU_ParsingOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_ParsingOptionContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

CypherParser::OC_LiteralContext* CypherParser::KU_ParsingOptionContext::oC_Literal() {
  return getRuleContext<CypherParser::OC_LiteralContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_ParsingOptionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_ParsingOptionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_ParsingOptionContext::getRuleIndex() const {
  return CypherParser::RuleKU_ParsingOption;
}


CypherParser::KU_ParsingOptionContext* CypherParser::kU_ParsingOption() {
  KU_ParsingOptionContext *_localctx = _tracker.createInstance<KU_ParsingOptionContext>(_ctx, getState());
  enterRule(_localctx, 40, CypherParser::RuleKU_ParsingOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(669);
    oC_SymbolicName();
    setState(671);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(670);
      match(CypherParser::SP);
    }
    setState(673);
    match(CypherParser::T__5);
    setState(675);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(674);
      match(CypherParser::SP);
    }
    setState(677);
    oC_Literal();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateNodeTableContext ------------------------------------------------------------------

CypherParser::KU_CreateNodeTableContext::KU_CreateNodeTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CreateNodeTableContext::CREATE() {
  return getToken(CypherParser::CREATE, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CreateNodeTableContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CreateNodeTableContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CreateNodeTableContext::NODE() {
  return getToken(CypherParser::NODE, 0);
}

tree::TerminalNode* CypherParser::KU_CreateNodeTableContext::TABLE() {
  return getToken(CypherParser::TABLE, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CreateNodeTableContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

CypherParser::KU_PropertyDefinitionsContext* CypherParser::KU_CreateNodeTableContext::kU_PropertyDefinitions() {
  return getRuleContext<CypherParser::KU_PropertyDefinitionsContext>(0);
}

CypherParser::KU_CreateNodeConstraintContext* CypherParser::KU_CreateNodeTableContext::kU_CreateNodeConstraint() {
  return getRuleContext<CypherParser::KU_CreateNodeConstraintContext>(0);
}


size_t CypherParser::KU_CreateNodeTableContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateNodeTable;
}


CypherParser::KU_CreateNodeTableContext* CypherParser::kU_CreateNodeTable() {
  KU_CreateNodeTableContext *_localctx = _tracker.createInstance<KU_CreateNodeTableContext>(_ctx, getState());
  enterRule(_localctx, 42, CypherParser::RuleKU_CreateNodeTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(679);
    match(CypherParser::CREATE);
    setState(680);
    match(CypherParser::SP);
    setState(681);
    match(CypherParser::NODE);
    setState(682);
    match(CypherParser::SP);
    setState(683);
    match(CypherParser::TABLE);
    setState(684);
    match(CypherParser::SP);
    setState(685);
    oC_SchemaName();
    setState(687);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(686);
      match(CypherParser::SP);
    }
    setState(689);
    match(CypherParser::T__1);
    setState(691);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(690);
      match(CypherParser::SP);
    }
    setState(693);
    kU_PropertyDefinitions();
    setState(695);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(694);
      match(CypherParser::SP);
    }

    setState(697);
    match(CypherParser::T__2);
    setState(699);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(698);
      match(CypherParser::SP);
    }
    setState(701);
    kU_CreateNodeConstraint();
    setState(704);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(703);
      match(CypherParser::SP);
    }
    setState(706);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateRelTableContext ------------------------------------------------------------------

CypherParser::KU_CreateRelTableContext::KU_CreateRelTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CreateRelTableContext::CREATE() {
  return getToken(CypherParser::CREATE, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CreateRelTableContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableContext::REL() {
  return getToken(CypherParser::REL, 0);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableContext::TABLE() {
  return getToken(CypherParser::TABLE, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CreateRelTableContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

CypherParser::KU_RelTableConnectionContext* CypherParser::KU_CreateRelTableContext::kU_RelTableConnection() {
  return getRuleContext<CypherParser::KU_RelTableConnectionContext>(0);
}

CypherParser::KU_PropertyDefinitionsContext* CypherParser::KU_CreateRelTableContext::kU_PropertyDefinitions() {
  return getRuleContext<CypherParser::KU_PropertyDefinitionsContext>(0);
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_CreateRelTableContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}


size_t CypherParser::KU_CreateRelTableContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateRelTable;
}


CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() {
  KU_CreateRelTableContext *_localctx = _tracker.createInstance<KU_CreateRelTableContext>(_ctx, getState());
  enterRule(_localctx, 44, CypherParser::RuleKU_CreateRelTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(708);
    match(CypherParser::CREATE);
    setState(709);
    match(CypherParser::SP);
    setState(710);
    match(CypherParser::REL);
    setState(711);
    match(CypherParser::SP);
    setState(712);
    match(CypherParser::TABLE);
    setState(713);
    match(CypherParser::SP);
    setState(714);
    oC_SchemaName();
    setState(716);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(715);
      match(CypherParser::SP);
    }
    setState(718);
    match(CypherParser::T__1);
    setState(720);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(719);
      match(CypherParser::SP);
    }
    setState(722);
    kU_RelTableConnection();
    setState(724);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(723);
      match(CypherParser::SP);
    }
    setState(734);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
    case 1: {
      setState(726);
      match(CypherParser::T__2);
      setState(728);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(727);
        match(CypherParser::SP);
      }
      setState(730);
      kU_PropertyDefinitions();
      setState(732);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(731);
        match(CypherParser::SP);
      }
      break;
    }

    default:
      break;
    }
    setState(744);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::T__2) {
      setState(736);
      match(CypherParser::T__2);
      setState(738);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(737);
        match(CypherParser::SP);
      }
      setState(740);
      oC_SymbolicName();
      setState(742);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(741);
        match(CypherParser::SP);
      }
    }
    setState(746);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateRelTableGroupContext ------------------------------------------------------------------

CypherParser::KU_CreateRelTableGroupContext::KU_CreateRelTableGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CreateRelTableGroupContext::CREATE() {
  return getToken(CypherParser::CREATE, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CreateRelTableGroupContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableGroupContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableGroupContext::REL() {
  return getToken(CypherParser::REL, 0);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableGroupContext::TABLE() {
  return getToken(CypherParser::TABLE, 0);
}

tree::TerminalNode* CypherParser::KU_CreateRelTableGroupContext::GROUP() {
  return getToken(CypherParser::GROUP, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CreateRelTableGroupContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

std::vector<CypherParser::KU_RelTableConnectionContext *> CypherParser::KU_CreateRelTableGroupContext::kU_RelTableConnection() {
  return getRuleContexts<CypherParser::KU_RelTableConnectionContext>();
}

CypherParser::KU_RelTableConnectionContext* CypherParser::KU_CreateRelTableGroupContext::kU_RelTableConnection(size_t i) {
  return getRuleContext<CypherParser::KU_RelTableConnectionContext>(i);
}

CypherParser::KU_PropertyDefinitionsContext* CypherParser::KU_CreateRelTableGroupContext::kU_PropertyDefinitions() {
  return getRuleContext<CypherParser::KU_PropertyDefinitionsContext>(0);
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_CreateRelTableGroupContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}


size_t CypherParser::KU_CreateRelTableGroupContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateRelTableGroup;
}


CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGroup() {
  KU_CreateRelTableGroupContext *_localctx = _tracker.createInstance<KU_CreateRelTableGroupContext>(_ctx, getState());
  enterRule(_localctx, 46, CypherParser::RuleKU_CreateRelTableGroup);
  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(748);
    match(CypherParser::CREATE);
    setState(749);
    match(CypherParser::SP);
    setState(750);
    match(CypherParser::REL);
    setState(751);
    match(CypherParser::SP);
    setState(752);
    match(CypherParser::TABLE);
    setState(753);
    match(CypherParser::SP);
    setState(754);
    match(CypherParser::GROUP);
    setState(755);
    match(CypherParser::SP);
    setState(756);
    oC_SchemaName();
    setState(758);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(757);
      match(CypherParser::SP);
    }
    setState(760);
    match(CypherParser::T__1);
    setState(762);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(761);
      match(CypherParser::SP);
    }
    setState(764);
    kU_RelTableConnection();
    setState(766);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(765);
      match(CypherParser::SP);
    }
    setState(773); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(768);
              match(CypherParser::T__2);
              setState(770);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == CypherParser::SP) {
                setState(769);
                match(CypherParser::SP);
              }
              setState(772);
              kU_RelTableConnection();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(775); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(778);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(777);
      match(CypherParser::SP);
    }
    setState(788);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
    case 1: {
      setState(780);
      match(CypherParser::T__2);
      setState(782);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(781);
        match(CypherParser::SP);
      }
      setState(784);
      kU_PropertyDefinitions();
      setState(786);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(785);
        match(CypherParser::SP);
      }
      break;
    }

    default:
      break;
    }
    setState(798);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::T__2) {
      setState(790);
      match(CypherParser::T__2);
      setState(792);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(791);
        match(CypherParser::SP);
      }
      setState(794);
      oC_SymbolicName();
      setState(796);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(795);
        match(CypherParser::SP);
      }
    }
    setState(800);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_RelTableConnectionContext ------------------------------------------------------------------

CypherParser::KU_RelTableConnectionContext::KU_RelTableConnectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_RelTableConnectionContext::FROM() {
  return getToken(CypherParser::FROM, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_RelTableConnectionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_RelTableConnectionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

std::vector<CypherParser::OC_SchemaNameContext *> CypherParser::KU_RelTableConnectionContext::oC_SchemaName() {
  return getRuleContexts<CypherParser::OC_SchemaNameContext>();
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_RelTableConnectionContext::oC_SchemaName(size_t i) {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(i);
}

tree::TerminalNode* CypherParser::KU_RelTableConnectionContext::TO() {
  return getToken(CypherParser::TO, 0);
}


size_t CypherParser::KU_RelTableConnectionContext::getRuleIndex() const {
  return CypherParser::RuleKU_RelTableConnection;
}


CypherParser::KU_RelTableConnectionContext* CypherParser::kU_RelTableConnection() {
  KU_RelTableConnectionContext *_localctx = _tracker.createInstance<KU_RelTableConnectionContext>(_ctx, getState());
  enterRule(_localctx, 48, CypherParser::RuleKU_RelTableConnection);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(802);
    match(CypherParser::FROM);
    setState(803);
    match(CypherParser::SP);
    setState(804);
    oC_SchemaName();
    setState(805);
    match(CypherParser::SP);
    setState(806);
    match(CypherParser::TO);
    setState(807);
    match(CypherParser::SP);
    setState(808);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateRdfGraphContext ------------------------------------------------------------------

CypherParser::KU_CreateRdfGraphContext::KU_CreateRdfGraphContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CreateRdfGraphContext::CREATE() {
  return getToken(CypherParser::CREATE, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CreateRdfGraphContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CreateRdfGraphContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CreateRdfGraphContext::RDFGRAPH() {
  return getToken(CypherParser::RDFGRAPH, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_CreateRdfGraphContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}


size_t CypherParser::KU_CreateRdfGraphContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateRdfGraph;
}


CypherParser::KU_CreateRdfGraphContext* CypherParser::kU_CreateRdfGraph() {
  KU_CreateRdfGraphContext *_localctx = _tracker.createInstance<KU_CreateRdfGraphContext>(_ctx, getState());
  enterRule(_localctx, 50, CypherParser::RuleKU_CreateRdfGraph);

#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::RDFGRAPH);
    setState(813);
    match(CypherParser::SP);
    setState(814);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_DropTableContext ------------------------------------------------------------------

CypherParser::KU_DropTableContext::KU_DropTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_DropTableContext::DROP() {
  return getToken(CypherParser::DROP, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_DropTableContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_DropTableContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_DropTableContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_DropTableContext::TABLE() {
  return getToken(CypherParser::TABLE, 0);
}

tree::TerminalNode* CypherParser::KU_DropTableContext::RDFGRAPH() {
  return getToken(CypherParser::RDFGRAPH, 0);
}


size_t CypherParser::KU_DropTableContext::getRuleIndex() const {
  return CypherParser::RuleKU_DropTable;
}


CypherParser::KU_DropTableContext* CypherParser::kU_DropTable() {
  KU_DropTableContext *_localctx = _tracker.createInstance<KU_DropTableContext>(_ctx, getState());
  enterRule(_localctx, 52, CypherParser::RuleKU_DropTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(816);
    match(CypherParser::DROP);
    setState(817);
    match(CypherParser::SP);
    setState(818);
    _la = _input->LA(1);
    if (!(_la == CypherParser::TABLE

    || _la == CypherParser::RDFGRAPH)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(819);
    match(CypherParser::SP);
    setState(820);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_AlterTableContext ------------------------------------------------------------------

CypherParser::KU_AlterTableContext::KU_AlterTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_AlterTableContext::ALTER() {
  return getToken(CypherParser::ALTER, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_AlterTableContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_AlterTableContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_AlterTableContext::TABLE() {
  return getToken(CypherParser::TABLE, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_AlterTableContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}

CypherParser::KU_AlterOptionsContext* CypherParser::KU_AlterTableContext::kU_AlterOptions() {
  return getRuleContext<CypherParser::KU_AlterOptionsContext>(0);
}


size_t CypherParser::KU_AlterTableContext::getRuleIndex() const {
  return CypherParser::RuleKU_AlterTable;
}


CypherParser::KU_AlterTableContext* CypherParser::kU_AlterTable() {
  KU_AlterTableContext *_localctx = _tracker.createInstance<KU_AlterTableContext>(_ctx, getState());
  enterRule(_localctx, 54, CypherParser::RuleKU_AlterTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(822);
    match(CypherParser::ALTER);
    setState(823);
    match(CypherParser::SP);
    setState(824);
    match(CypherParser::TABLE);
    setState(825);
    match(CypherParser::SP);
    setState(826);
    oC_SchemaName();
    setState(827);
    match(CypherParser::SP);
    setState(828);
    kU_AlterOptions();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_AlterOptionsContext ------------------------------------------------------------------

CypherParser::KU_AlterOptionsContext::KU_AlterOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::KU_AddPropertyContext* CypherParser::KU_AlterOptionsContext::kU_AddProperty() {
  return getRuleContext<CypherParser::KU_AddPropertyContext>(0);
}

CypherParser::KU_DropPropertyContext* CypherParser::KU_AlterOptionsContext::kU_DropProperty() {
  return getRuleContext<CypherParser::KU_DropPropertyContext>(0);
}

CypherParser::KU_RenameTableContext* CypherParser::KU_AlterOptionsContext::kU_RenameTable() {
  return getRuleContext<CypherParser::KU_RenameTableContext>(0);
}

CypherParser::KU_RenamePropertyContext* CypherParser::KU_AlterOptionsContext::kU_RenameProperty() {
  return getRuleContext<CypherParser::KU_RenamePropertyContext>(0);
}


size_t CypherParser::KU_AlterOptionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_AlterOptions;
}


CypherParser::KU_AlterOptionsContext* CypherParser::kU_AlterOptions() {
  KU_AlterOptionsContext *_localctx = _tracker.createInstance<KU_AlterOptionsContext>(_ctx, getState());
  enterRule(_localctx, 56, CypherParser::RuleKU_AlterOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(834);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 95, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(830);
      kU_AddProperty();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(831);
      kU_DropProperty();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(832);
      kU_RenameTable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(833);
      kU_RenameProperty();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_AddPropertyContext ------------------------------------------------------------------

CypherParser::KU_AddPropertyContext::KU_AddPropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_AddPropertyContext::ADD() {
  return getToken(CypherParser::ADD, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_AddPropertyContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_AddPropertyContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_AddPropertyContext::oC_PropertyKeyName() {
  return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}

CypherParser::KU_DataTypeContext* CypherParser::KU_AddPropertyContext::kU_DataType() {
  return getRuleContext<CypherParser::KU_DataTypeContext>(0);
}

tree::TerminalNode* CypherParser::KU_AddPropertyContext::DEFAULT() {
  return getToken(CypherParser::DEFAULT, 0);
}

CypherParser::OC_ExpressionContext* CypherParser::KU_AddPropertyContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}


size_t CypherParser::KU_AddPropertyContext::getRuleIndex() const {
  return CypherParser::RuleKU_AddProperty;
}


CypherParser::KU_AddPropertyContext* CypherParser::kU_AddProperty() {
  KU_AddPropertyContext *_localctx = _tracker.createInstance<KU_AddPropertyContext>(_ctx, getState());
  enterRule(_localctx, 58, CypherParser::RuleKU_AddProperty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(836);
    match(CypherParser::ADD);
    setState(837);
    match(CypherParser::SP);
    setState(838);
    oC_PropertyKeyName();
    setState(839);
    match(CypherParser::SP);
    setState(840);
    kU_DataType(0);
    setState(845);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx)) {
    case 1: {
      setState(841);
      match(CypherParser::SP);
      setState(842);
      match(CypherParser::DEFAULT);
      setState(843);
      match(CypherParser::SP);
      setState(844);
      oC_Expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_DropPropertyContext ------------------------------------------------------------------

CypherParser::KU_DropPropertyContext::KU_DropPropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_DropPropertyContext::DROP() {
  return getToken(CypherParser::DROP, 0);
}

tree::TerminalNode* CypherParser::KU_DropPropertyContext::SP() {
  return getToken(CypherParser::SP, 0);
}

CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_DropPropertyContext::oC_PropertyKeyName() {
  return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}


size_t CypherParser::KU_DropPropertyContext::getRuleIndex() const {
  return CypherParser::RuleKU_DropProperty;
}


CypherParser::KU_DropPropertyContext* CypherParser::kU_DropProperty() {
  KU_DropPropertyContext *_localctx = _tracker.createInstance<KU_DropPropertyContext>(_ctx, getState());
  enterRule(_localctx, 60, CypherParser::RuleKU_DropProperty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(847);
    match(CypherParser::DROP);
    setState(848);
    match(CypherParser::SP);
    setState(849);
    oC_PropertyKeyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_RenameTableContext ------------------------------------------------------------------

CypherParser::KU_RenameTableContext::KU_RenameTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_RenameTableContext::RENAME() {
  return getToken(CypherParser::RENAME, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_RenameTableContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_RenameTableContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_RenameTableContext::TO() {
  return getToken(CypherParser::TO, 0);
}

CypherParser::OC_SchemaNameContext* CypherParser::KU_RenameTableContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}


size_t CypherParser::KU_RenameTableContext::getRuleIndex() const {
  return CypherParser::RuleKU_RenameTable;
}


CypherParser::KU_RenameTableContext* CypherParser::kU_RenameTable() {
  KU_RenameTableContext *_localctx = _tracker.createInstance<KU_RenameTableContext>(_ctx, getState());
  enterRule(_localctx, 62, CypherParser::RuleKU_RenameTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(851);
    match(CypherParser::RENAME);
    setState(852);
    match(CypherParser::SP);
    setState(853);
    match(CypherParser::TO);
    setState(854);
    match(CypherParser::SP);
    setState(855);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_RenamePropertyContext ------------------------------------------------------------------

CypherParser::KU_RenamePropertyContext::KU_RenamePropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_RenamePropertyContext::RENAME() {
  return getToken(CypherParser::RENAME, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_RenamePropertyContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_RenamePropertyContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

std::vector<CypherParser::OC_PropertyKeyNameContext *> CypherParser::KU_RenamePropertyContext::oC_PropertyKeyName() {
  return getRuleContexts<CypherParser::OC_PropertyKeyNameContext>();
}

CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_RenamePropertyContext::oC_PropertyKeyName(size_t i) {
  return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(i);
}

tree::TerminalNode* CypherParser::KU_RenamePropertyContext::TO() {
  return getToken(CypherParser::TO, 0);
}


size_t CypherParser::KU_RenamePropertyContext::getRuleIndex() const {
  return CypherParser::RuleKU_RenameProperty;
}


CypherParser::KU_RenamePropertyContext* CypherParser::kU_RenameProperty() {
  KU_RenamePropertyContext *_localctx = _tracker.createInstance<KU_RenamePropertyContext>(_ctx, getState());
  enterRule(_localctx, 64, CypherParser::RuleKU_RenameProperty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(857);
    match(CypherParser::RENAME);
    setState(858);
    match(CypherParser::SP);
    setState(859);
    oC_PropertyKeyName();
    setState(860);
    match(CypherParser::SP);
    setState(861);
    match(CypherParser::TO);
    setState(862);
    match(CypherParser::SP);
    setState(863);
    oC_PropertyKeyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_PropertyDefinitionsContext ------------------------------------------------------------------

CypherParser::KU_PropertyDefinitionsContext::KU_PropertyDefinitionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_PropertyDefinitionContext *> CypherParser::KU_PropertyDefinitionsContext::kU_PropertyDefinition() {
  return getRuleContexts<CypherParser::KU_PropertyDefinitionContext>();
}

CypherParser::KU_PropertyDefinitionContext* CypherParser::KU_PropertyDefinitionsContext::kU_PropertyDefinition(size_t i) {
  return getRuleContext<CypherParser::KU_PropertyDefinitionContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_PropertyDefinitionsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_PropertyDefinitionsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_PropertyDefinitionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_PropertyDefinitions;
}


CypherParser::KU_PropertyDefinitionsContext* CypherParser::kU_PropertyDefinitions() {
  KU_PropertyDefinitionsContext *_localctx = _tracker.createInstance<KU_PropertyDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 66, CypherParser::RuleKU_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(865);
    kU_PropertyDefinition();
    setState(876);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(867);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(866);
          match(CypherParser::SP);
        }
        setState(869);
        match(CypherParser::T__2);
        setState(871);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(870);
          match(CypherParser::SP);
        }
        setState(873);
        kU_PropertyDefinition(); 
      }
      setState(878);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_PropertyDefinitionContext ------------------------------------------------------------------

CypherParser::KU_PropertyDefinitionContext::KU_PropertyDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_PropertyDefinitionContext::oC_PropertyKeyName() {
  return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_PropertyDefinitionContext::SP() {
  return getToken(CypherParser::SP, 0);
}

CypherParser::KU_DataTypeContext* CypherParser::KU_PropertyDefinitionContext::kU_DataType() {
  return getRuleContext<CypherParser::KU_DataTypeContext>(0);
}


size_t CypherParser::KU_PropertyDefinitionContext::getRuleIndex() const {
  return CypherParser::RuleKU_PropertyDefinition;
}


CypherParser::KU_PropertyDefinitionContext* CypherParser::kU_PropertyDefinition() {
  KU_PropertyDefinitionContext *_localctx = _tracker.createInstance<KU_PropertyDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 68, CypherParser::RuleKU_PropertyDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(879);
    oC_PropertyKeyName();
    setState(880);
    match(CypherParser::SP);
    setState(881);
    kU_DataType(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateNodeConstraintContext ------------------------------------------------------------------

CypherParser::KU_CreateNodeConstraintContext::KU_CreateNodeConstraintContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CreateNodeConstraintContext::PRIMARY() {
  return getToken(CypherParser::PRIMARY, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CreateNodeConstraintContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CreateNodeConstraintContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_CreateNodeConstraintContext::KEY() {
  return getToken(CypherParser::KEY, 0);
}

CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_CreateNodeConstraintContext::oC_PropertyKeyName() {
  return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(0);
}


size_t CypherParser::KU_CreateNodeConstraintContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateNodeConstraint;
}


CypherParser::KU_CreateNodeConstraintContext* CypherParser::kU_CreateNodeConstraint() {
  KU_CreateNodeConstraintContext *_localctx = _tracker.createInstance<KU_CreateNodeConstraintContext>(_ctx, getState());
  enterRule(_localctx, 70, CypherParser::RuleKU_CreateNodeConstraint);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(883);
    match(CypherParser::PRIMARY);
    setState(884);
    match(CypherParser::SP);
    setState(885);
    match(CypherParser::KEY);
    setState(887);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(886);
      match(CypherParser::SP);
    }
    setState(889);
    match(CypherParser::T__1);
    setState(891);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(890);
      match(CypherParser::SP);
    }
    setState(893);
    oC_PropertyKeyName();
    setState(895);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(894);
      match(CypherParser::SP);
    }
    setState(897);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_DataTypeContext ------------------------------------------------------------------

CypherParser::KU_DataTypeContext::KU_DataTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_DataTypeContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_DataTypeContext::UNION() {
  return getToken(CypherParser::UNION, 0);
}

CypherParser::KU_PropertyDefinitionsContext* CypherParser::KU_DataTypeContext::kU_PropertyDefinitions() {
  return getRuleContext<CypherParser::KU_PropertyDefinitionsContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_DataTypeContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_DataTypeContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

std::vector<CypherParser::KU_DataTypeContext *> CypherParser::KU_DataTypeContext::kU_DataType() {
  return getRuleContexts<CypherParser::KU_DataTypeContext>();
}

CypherParser::KU_DataTypeContext* CypherParser::KU_DataTypeContext::kU_DataType(size_t i) {
  return getRuleContext<CypherParser::KU_DataTypeContext>(i);
}

CypherParser::KU_ListIdentifiersContext* CypherParser::KU_DataTypeContext::kU_ListIdentifiers() {
  return getRuleContext<CypherParser::KU_ListIdentifiersContext>(0);
}


size_t CypherParser::KU_DataTypeContext::getRuleIndex() const {
  return CypherParser::RuleKU_DataType;
}



CypherParser::KU_DataTypeContext* CypherParser::kU_DataType() {
   return kU_DataType(0);
}

CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CypherParser::KU_DataTypeContext *_localctx = _tracker.createInstance<KU_DataTypeContext>(_ctx, parentState);
  CypherParser::KU_DataTypeContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 72;
  enterRecursionRule(_localctx, 72, CypherParser::RuleKU_DataType, 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(951);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
    case 1: {
      setState(900);
      oC_SymbolicName();
      break;
    }

    case 2: {
      setState(901);
      match(CypherParser::UNION);
      setState(903);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(902);
        match(CypherParser::SP);
      }
      setState(905);
      match(CypherParser::T__1);
      setState(907);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(906);
        match(CypherParser::SP);
      }
      setState(909);
      kU_PropertyDefinitions();
      setState(911);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(910);
        match(CypherParser::SP);
      }
      setState(913);
      match(CypherParser::T__3);
      break;
    }

    case 3: {
      setState(915);
      oC_SymbolicName();
      setState(917);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(916);
        match(CypherParser::SP);
      }
      setState(919);
      match(CypherParser::T__1);
      setState(921);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(920);
        match(CypherParser::SP);
      }
      setState(923);
      kU_PropertyDefinitions();
      setState(925);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(924);
        match(CypherParser::SP);
      }
      setState(927);
      match(CypherParser::T__3);
      break;
    }

    case 4: {
      setState(929);
      oC_SymbolicName();
      setState(931);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(930);
        match(CypherParser::SP);
      }
      setState(933);
      match(CypherParser::T__1);
      setState(935);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(934);
        match(CypherParser::SP);
      }
      setState(937);
      kU_DataType(0);
      setState(939);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(938);
        match(CypherParser::SP);
      }
      setState(941);
      match(CypherParser::T__2);
      setState(943);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(942);
        match(CypherParser::SP);
      }
      setState(945);
      kU_DataType(0);
      setState(947);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(946);
        match(CypherParser::SP);
      }
      setState(949);
      match(CypherParser::T__3);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(957);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<KU_DataTypeContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleKU_DataType);
        setState(953);

        if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
        setState(954);
        kU_ListIdentifiers(); 
      }
      setState(959);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- KU_ListIdentifiersContext ------------------------------------------------------------------

CypherParser::KU_ListIdentifiersContext::KU_ListIdentifiersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_ListIdentifierContext *> CypherParser::KU_ListIdentifiersContext::kU_ListIdentifier() {
  return getRuleContexts<CypherParser::KU_ListIdentifierContext>();
}

CypherParser::KU_ListIdentifierContext* CypherParser::KU_ListIdentifiersContext::kU_ListIdentifier(size_t i) {
  return getRuleContext<CypherParser::KU_ListIdentifierContext>(i);
}


size_t CypherParser::KU_ListIdentifiersContext::getRuleIndex() const {
  return CypherParser::RuleKU_ListIdentifiers;
}


CypherParser::KU_ListIdentifiersContext* CypherParser::kU_ListIdentifiers() {
  KU_ListIdentifiersContext *_localctx = _tracker.createInstance<KU_ListIdentifiersContext>(_ctx, getState());
  enterRule(_localctx, 74, CypherParser::RuleKU_ListIdentifiers);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(960);
    kU_ListIdentifier();
    setState(964);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(961);
        kU_ListIdentifier(); 
      }
      setState(966);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ListIdentifierContext ------------------------------------------------------------------

CypherParser::KU_ListIdentifierContext::KU_ListIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_IntegerLiteralContext* CypherParser::KU_ListIdentifierContext::oC_IntegerLiteral() {
  return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}


size_t CypherParser::KU_ListIdentifierContext::getRuleIndex() const {
  return CypherParser::RuleKU_ListIdentifier;
}


CypherParser::KU_ListIdentifierContext* CypherParser::kU_ListIdentifier() {
  KU_ListIdentifierContext *_localctx = _tracker.createInstance<KU_ListIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 76, CypherParser::RuleKU_ListIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(967);
    match(CypherParser::T__6);
    setState(969);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::DecimalInteger) {
      setState(968);
      oC_IntegerLiteral();
    }
    setState(971);
    match(CypherParser::T__7);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AnyCypherOptionContext ------------------------------------------------------------------

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, 78, CypherParser::RuleOC_AnyCypherOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(975);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::EXPLAIN: {
        enterOuterAlt(_localctx, 1);
        setState(973);
        oC_Explain();
        break;
      }

      case CypherParser::PROFILE: {
        enterOuterAlt(_localctx, 2);
        setState(974);
        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;
}

//----------------- OC_ExplainContext ------------------------------------------------------------------

CypherParser::OC_ExplainContext::OC_ExplainContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::OC_ExplainContext::EXPLAIN() {
  return getToken(CypherParser::EXPLAIN, 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, 80, CypherParser::RuleOC_Explain);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(977);
    match(CypherParser::EXPLAIN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ProfileContext ------------------------------------------------------------------

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, 82, CypherParser::RuleOC_Profile);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(979);
    match(CypherParser::PROFILE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_TransactionContext ------------------------------------------------------------------

CypherParser::KU_TransactionContext::KU_TransactionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_TransactionContext::BEGIN() {
  return getToken(CypherParser::BEGIN, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_TransactionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::TRANSACTION() {
  return getToken(CypherParser::TRANSACTION, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::READ() {
  return getToken(CypherParser::READ, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::ONLY() {
  return getToken(CypherParser::ONLY, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::COMMIT() {
  return getToken(CypherParser::COMMIT, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::COMMIT_SKIP_CHECKPOINT() {
  return getToken(CypherParser::COMMIT_SKIP_CHECKPOINT, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::ROLLBACK() {
  return getToken(CypherParser::ROLLBACK, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::ROLLBACK_SKIP_CHECKPOINT() {
  return getToken(CypherParser::ROLLBACK_SKIP_CHECKPOINT, 0);
}


size_t CypherParser::KU_TransactionContext::getRuleIndex() const {
  return CypherParser::RuleKU_Transaction;
}


CypherParser::KU_TransactionContext* CypherParser::kU_Transaction() {
  KU_TransactionContext *_localctx = _tracker.createInstance<KU_TransactionContext>(_ctx, getState());
  enterRule(_localctx, 84, CypherParser::RuleKU_Transaction);

#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, 119, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(981);
      match(CypherParser::BEGIN);
      setState(982);
      match(CypherParser::SP);
      setState(983);
      match(CypherParser::TRANSACTION);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(984);
      match(CypherParser::BEGIN);
      setState(985);
      match(CypherParser::SP);
      setState(986);
      match(CypherParser::TRANSACTION);
      setState(987);
      match(CypherParser::SP);
      setState(988);
      match(CypherParser::READ);
      setState(989);
      match(CypherParser::SP);
      setState(990);
      match(CypherParser::ONLY);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(991);
      match(CypherParser::COMMIT);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(992);
      match(CypherParser::COMMIT_SKIP_CHECKPOINT);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(993);
      match(CypherParser::ROLLBACK);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(994);
      match(CypherParser::ROLLBACK_SKIP_CHECKPOINT);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ExtensionContext ------------------------------------------------------------------

CypherParser::KU_ExtensionContext::KU_ExtensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::KU_LoadExtensionContext* CypherParser::KU_ExtensionContext::kU_LoadExtension() {
  return getRuleContext<CypherParser::KU_LoadExtensionContext>(0);
}

CypherParser::KU_InstallExtensionContext* CypherParser::KU_ExtensionContext::kU_InstallExtension() {
  return getRuleContext<CypherParser::KU_InstallExtensionContext>(0);
}


size_t CypherParser::KU_ExtensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_Extension;
}


CypherParser::KU_ExtensionContext* CypherParser::kU_Extension() {
  KU_ExtensionContext *_localctx = _tracker.createInstance<KU_ExtensionContext>(_ctx, getState());
  enterRule(_localctx, 86, CypherParser::RuleKU_Extension);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(999);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::LOAD: {
        enterOuterAlt(_localctx, 1);
        setState(997);
        kU_LoadExtension();
        break;
      }

      case CypherParser::INSTALL: {
        enterOuterAlt(_localctx, 2);
        setState(998);
        kU_InstallExtension();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_LoadExtensionContext ------------------------------------------------------------------

CypherParser::KU_LoadExtensionContext::KU_LoadExtensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_LoadExtensionContext::LOAD() {
  return getToken(CypherParser::LOAD, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_LoadExtensionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_LoadExtensionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_LoadExtensionContext::EXTENSION() {
  return getToken(CypherParser::EXTENSION, 0);
}

tree::TerminalNode* CypherParser::KU_LoadExtensionContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}

CypherParser::OC_VariableContext* CypherParser::KU_LoadExtensionContext::oC_Variable() {
  return getRuleContext<CypherParser::OC_VariableContext>(0);
}


size_t CypherParser::KU_LoadExtensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_LoadExtension;
}


CypherParser::KU_LoadExtensionContext* CypherParser::kU_LoadExtension() {
  KU_LoadExtensionContext *_localctx = _tracker.createInstance<KU_LoadExtensionContext>(_ctx, getState());
  enterRule(_localctx, 88, CypherParser::RuleKU_LoadExtension);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1001);
    match(CypherParser::LOAD);
    setState(1002);
    match(CypherParser::SP);
    setState(1003);
    match(CypherParser::EXTENSION);
    setState(1004);
    match(CypherParser::SP);
    setState(1007);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::StringLiteral: {
        setState(1005);
        match(CypherParser::StringLiteral);
        break;
      }

      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::IN:
      case CypherParser::COUNT:
      case CypherParser::END:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(1006);
        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;
}

//----------------- KU_InstallExtensionContext ------------------------------------------------------------------

CypherParser::KU_InstallExtensionContext::KU_InstallExtensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_InstallExtensionContext::INSTALL() {
  return getToken(CypherParser::INSTALL, 0);
}

tree::TerminalNode* CypherParser::KU_InstallExtensionContext::SP() {
  return getToken(CypherParser::SP, 0);
}

CypherParser::OC_VariableContext* CypherParser::KU_InstallExtensionContext::oC_Variable() {
  return getRuleContext<CypherParser::OC_VariableContext>(0);
}


size_t CypherParser::KU_InstallExtensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_InstallExtension;
}


CypherParser::KU_InstallExtensionContext* CypherParser::kU_InstallExtension() {
  KU_InstallExtensionContext *_localctx = _tracker.createInstance<KU_InstallExtensionContext>(_ctx, getState());
  enterRule(_localctx, 90, CypherParser::RuleKU_InstallExtension);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1009);
    match(CypherParser::INSTALL);
    setState(1010);
    match(CypherParser::SP);
    setState(1011);
    oC_Variable();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_QueryContext ------------------------------------------------------------------

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, 92, CypherParser::RuleOC_Query);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1013);
    oC_RegularQuery();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RegularQueryContext ------------------------------------------------------------------

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, 94, 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(1036);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 126, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1015);
      oC_SingleQuery();
      setState(1022);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1017);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1016);
            match(CypherParser::SP);
          }
          setState(1019);
          oC_Union(); 
        }
        setState(1024);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 123, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1029); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1025);
                oC_Return();
                setState(1027);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(1026);
                  match(CypherParser::SP);
                }
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1031); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(1033);
      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;
}

//----------------- OC_UnionContext ------------------------------------------------------------------

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, 96, CypherParser::RuleOC_Union);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1050);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1038);
      match(CypherParser::UNION);
      setState(1039);
      match(CypherParser::SP);
      setState(1040);
      match(CypherParser::ALL);
      setState(1042);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1041);
        match(CypherParser::SP);
      }
      setState(1044);
      oC_SingleQuery();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1045);
      match(CypherParser::UNION);
      setState(1047);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1046);
        match(CypherParser::SP);
      }
      setState(1049);
      oC_SingleQuery();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SingleQueryContext ------------------------------------------------------------------

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, 98, CypherParser::RuleOC_SingleQuery);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1054);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 130, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1052);
      oC_SinglePartQuery();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1053);
      oC_MultiPartQuery();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SinglePartQueryContext ------------------------------------------------------------------

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, 100, 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(1101);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1062);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (((((_la - 49) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 49)) & 7971459301377) != 0)) {
        setState(1056);
        oC_ReadingClause();
        setState(1058);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1057);
          match(CypherParser::SP);
        }
        setState(1064);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1065);
      oC_Return();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1072);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (((((_la - 49) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 49)) & 7971459301377) != 0)) {
        setState(1066);
        oC_ReadingClause();
        setState(1068);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1067);
          match(CypherParser::SP);
        }
        setState(1074);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1075);
      oC_UpdatingClause();
      setState(1082);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 136, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1077);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1076);
            match(CypherParser::SP);
          }
          setState(1079);
          oC_UpdatingClause(); 
        }
        setState(1084);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 136, _ctx);
      }
      setState(1089);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx)) {
      case 1: {
        setState(1086);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1085);
          match(CypherParser::SP);
        }
        setState(1088);
        oC_Return();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1095); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1091);
        oC_ReadingClause();
        setState(1093);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx)) {
        case 1: {
          setState(1092);
          match(CypherParser::SP);
          break;
        }

        default:
          break;
        }
        setState(1097); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (((((_la - 49) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 49)) & 7971459301377) != 0));
       notifyQueryNotConcludeWithReturn(_localctx->start); 
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MultiPartQueryContext ------------------------------------------------------------------

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::KU_QueryPartContext *> CypherParser::OC_MultiPartQueryContext::kU_QueryPart() {
  return getRuleContexts<CypherParser::KU_QueryPartContext>();
}

CypherParser::KU_QueryPartContext* CypherParser::OC_MultiPartQueryContext::kU_QueryPart(size_t i) {
  return getRuleContext<CypherParser::KU_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, 102, 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(1107); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1103);
              kU_QueryPart();
              setState(1105);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == CypherParser::SP) {
                setState(1104);
                match(CypherParser::SP);
              }
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(1109); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(1111);
    oC_SinglePartQuery();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_QueryPartContext ------------------------------------------------------------------

CypherParser::KU_QueryPartContext::KU_QueryPartContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_WithContext* CypherParser::KU_QueryPartContext::oC_With() {
  return getRuleContext<CypherParser::OC_WithContext>(0);
}

std::vector<CypherParser::OC_ReadingClauseContext *> CypherParser::KU_QueryPartContext::oC_ReadingClause() {
  return getRuleContexts<CypherParser::OC_ReadingClauseContext>();
}

CypherParser::OC_ReadingClauseContext* CypherParser::KU_QueryPartContext::oC_ReadingClause(size_t i) {
  return getRuleContext<CypherParser::OC_ReadingClauseContext>(i);
}

std::vector<CypherParser::OC_UpdatingClauseContext *> CypherParser::KU_QueryPartContext::oC_UpdatingClause() {
  return getRuleContexts<CypherParser::OC_UpdatingClauseContext>();
}

CypherParser::OC_UpdatingClauseContext* CypherParser::KU_QueryPartContext::oC_UpdatingClause(size_t i) {
  return getRuleContext<CypherParser::OC_UpdatingClauseContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_QueryPartContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_QueryPartContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_QueryPartContext::getRuleIndex() const {
  return CypherParser::RuleKU_QueryPart;
}


CypherParser::KU_QueryPartContext* CypherParser::kU_QueryPart() {
  KU_QueryPartContext *_localctx = _tracker.createInstance<KU_QueryPartContext>(_ctx, getState());
  enterRule(_localctx, 104, CypherParser::RuleKU_QueryPart);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1119);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 49) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 49)) & 7971459301377) != 0)) {
      setState(1113);
      oC_ReadingClause();
      setState(1115);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1114);
        match(CypherParser::SP);
      }
      setState(1121);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1128);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 92) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 92)) & 59) != 0)) {
      setState(1122);
      oC_UpdatingClause();
      setState(1124);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1123);
        match(CypherParser::SP);
      }
      setState(1130);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1131);
    oC_With();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UpdatingClauseContext ------------------------------------------------------------------

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, 106, CypherParser::RuleOC_UpdatingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1137);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::CREATE: {
        enterOuterAlt(_localctx, 1);
        setState(1133);
        oC_Create();
        break;
      }

      case CypherParser::MERGE: {
        enterOuterAlt(_localctx, 2);
        setState(1134);
        oC_Merge();
        break;
      }

      case CypherParser::SET: {
        enterOuterAlt(_localctx, 3);
        setState(1135);
        oC_Set();
        break;
      }

      case CypherParser::DETACH:
      case CypherParser::DELETE: {
        enterOuterAlt(_localctx, 4);
        setState(1136);
        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;
}

//----------------- OC_ReadingClauseContext ------------------------------------------------------------------

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::KU_InQueryCallContext* CypherParser::OC_ReadingClauseContext::kU_InQueryCall() {
  return getRuleContext<CypherParser::KU_InQueryCallContext>(0);
}

CypherParser::KU_LoadFromContext* CypherParser::OC_ReadingClauseContext::kU_LoadFrom() {
  return getRuleContext<CypherParser::KU_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, 108, CypherParser::RuleOC_ReadingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1143);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::OPTIONAL:
      case CypherParser::MATCH: {
        enterOuterAlt(_localctx, 1);
        setState(1139);
        oC_Match();
        break;
      }

      case CypherParser::UNWIND: {
        enterOuterAlt(_localctx, 2);
        setState(1140);
        oC_Unwind();
        break;
      }

      case CypherParser::CALL: {
        enterOuterAlt(_localctx, 3);
        setState(1141);
        kU_InQueryCall();
        break;
      }

      case CypherParser::LOAD: {
        enterOuterAlt(_localctx, 4);
        setState(1142);
        kU_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;
}

//----------------- KU_LoadFromContext ------------------------------------------------------------------

CypherParser::KU_LoadFromContext::KU_LoadFromContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_LoadFromContext::LOAD() {
  return getToken(CypherParser::LOAD, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_LoadFromContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_LoadFromContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

tree::TerminalNode* CypherParser::KU_LoadFromContext::FROM() {
  return getToken(CypherParser::FROM, 0);
}

CypherParser::KU_ScanSourceContext* CypherParser::KU_LoadFromContext::kU_ScanSource() {
  return getRuleContext<CypherParser::KU_ScanSourceContext>(0);
}

tree::TerminalNode* CypherParser::KU_LoadFromContext::WITH() {
  return getToken(CypherParser::WITH, 0);
}

tree::TerminalNode* CypherParser::KU_LoadFromContext::HEADERS() {
  return getToken(CypherParser::HEADERS, 0);
}

CypherParser::KU_PropertyDefinitionsContext* CypherParser::KU_LoadFromContext::kU_PropertyDefinitions() {
  return getRuleContext<CypherParser::KU_PropertyDefinitionsContext>(0);
}

CypherParser::KU_ParsingOptionsContext* CypherParser::KU_LoadFromContext::kU_ParsingOptions() {
  return getRuleContext<CypherParser::KU_ParsingOptionsContext>(0);
}

CypherParser::OC_WhereContext* CypherParser::KU_LoadFromContext::oC_Where() {
  return getRuleContext<CypherParser::OC_WhereContext>(0);
}


size_t CypherParser::KU_LoadFromContext::getRuleIndex() const {
  return CypherParser::RuleKU_LoadFrom;
}


CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() {
  KU_LoadFromContext *_localctx = _tracker.createInstance<KU_LoadFromContext>(_ctx, getState());
  enterRule(_localctx, 110, CypherParser::RuleKU_LoadFrom);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1145);
    match(CypherParser::LOAD);
    setState(1163);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx)) {
    case 1: {
      setState(1146);
      match(CypherParser::SP);
      setState(1147);
      match(CypherParser::WITH);
      setState(1148);
      match(CypherParser::SP);
      setState(1149);
      match(CypherParser::HEADERS);
      setState(1151);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1150);
        match(CypherParser::SP);
      }
      setState(1153);
      match(CypherParser::T__1);
      setState(1155);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1154);
        match(CypherParser::SP);
      }
      setState(1157);
      kU_PropertyDefinitions();
      setState(1159);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1158);
        match(CypherParser::SP);
      }
      setState(1161);
      match(CypherParser::T__3);
      break;
    }

    default:
      break;
    }
    setState(1165);
    match(CypherParser::SP);
    setState(1166);
    match(CypherParser::FROM);
    setState(1167);
    match(CypherParser::SP);
    setState(1168);
    kU_ScanSource();
    setState(1173);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 155, _ctx)) {
    case 1: {
      setState(1170);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1169);
        match(CypherParser::SP);
      }
      setState(1172);
      kU_ParsingOptions();
      break;
    }

    default:
      break;
    }
    setState(1179);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 157, _ctx)) {
    case 1: {
      setState(1176);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1175);
        match(CypherParser::SP);
      }
      setState(1178);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_InQueryCallContext ------------------------------------------------------------------

CypherParser::KU_InQueryCallContext::KU_InQueryCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_InQueryCallContext::CALL() {
  return getToken(CypherParser::CALL, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_InQueryCallContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_InQueryCallContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_FunctionInvocationContext* CypherParser::KU_InQueryCallContext::oC_FunctionInvocation() {
  return getRuleContext<CypherParser::OC_FunctionInvocationContext>(0);
}

CypherParser::OC_WhereContext* CypherParser::KU_InQueryCallContext::oC_Where() {
  return getRuleContext<CypherParser::OC_WhereContext>(0);
}


size_t CypherParser::KU_InQueryCallContext::getRuleIndex() const {
  return CypherParser::RuleKU_InQueryCall;
}


CypherParser::KU_InQueryCallContext* CypherParser::kU_InQueryCall() {
  KU_InQueryCallContext *_localctx = _tracker.createInstance<KU_InQueryCallContext>(_ctx, getState());
  enterRule(_localctx, 112, CypherParser::RuleKU_InQueryCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1181);
    match(CypherParser::CALL);
    setState(1182);
    match(CypherParser::SP);
    setState(1183);
    oC_FunctionInvocation();
    setState(1188);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 159, _ctx)) {
    case 1: {
      setState(1185);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1184);
        match(CypherParser::SP);
      }
      setState(1187);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MatchContext ------------------------------------------------------------------

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);
}


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, 114, 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(1192);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::OPTIONAL) {
      setState(1190);
      match(CypherParser::OPTIONAL);
      setState(1191);
      match(CypherParser::SP);
    }
    setState(1194);
    match(CypherParser::MATCH);
    setState(1196);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1195);
      match(CypherParser::SP);
    }
    setState(1198);
    oC_Pattern();
    setState(1203);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 163, _ctx)) {
    case 1: {
      setState(1200);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1199);
        match(CypherParser::SP);
      }
      setState(1202);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UnwindContext ------------------------------------------------------------------

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, 116, 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(1205);
    match(CypherParser::UNWIND);
    setState(1207);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1206);
      match(CypherParser::SP);
    }
    setState(1209);
    oC_Expression();
    setState(1210);
    match(CypherParser::SP);
    setState(1211);
    match(CypherParser::AS);
    setState(1212);
    match(CypherParser::SP);
    setState(1213);
    oC_Variable();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_CreateContext ------------------------------------------------------------------

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, 118, 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(1215);
    match(CypherParser::CREATE);
    setState(1217);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1216);
      match(CypherParser::SP);
    }
    setState(1219);
    oC_Pattern();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MergeContext ------------------------------------------------------------------

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, 120, 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(1221);
    match(CypherParser::MERGE);
    setState(1223);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1222);
      match(CypherParser::SP);
    }
    setState(1225);
    oC_Pattern();
    setState(1230);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 167, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1226);
        match(CypherParser::SP);
        setState(1227);
        oC_MergeAction(); 
      }
      setState(1232);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 167, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_MergeActionContext ------------------------------------------------------------------

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, 122, CypherParser::RuleOC_MergeAction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1243);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 168, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1233);
      match(CypherParser::ON);
      setState(1234);
      match(CypherParser::SP);
      setState(1235);
      match(CypherParser::MATCH);
      setState(1236);
      match(CypherParser::SP);
      setState(1237);
      oC_Set();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1238);
      match(CypherParser::ON);
      setState(1239);
      match(CypherParser::SP);
      setState(1240);
      match(CypherParser::CREATE);
      setState(1241);
      match(CypherParser::SP);
      setState(1242);
      oC_Set();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SetContext ------------------------------------------------------------------

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);
}


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, 124, CypherParser::RuleOC_Set);
  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(1245);
    match(CypherParser::SET);
    setState(1247);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1246);
      match(CypherParser::SP);
    }
    setState(1249);
    oC_SetItem();
    setState(1260);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1251);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1250);
          match(CypherParser::SP);
        }
        setState(1253);
        match(CypherParser::T__2);
        setState(1255);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1254);
          match(CypherParser::SP);
        }
        setState(1257);
        oC_SetItem(); 
      }
      setState(1262);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SetItemContext ------------------------------------------------------------------

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, 126, 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(1263);
    oC_PropertyExpression();
    setState(1265);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1264);
      match(CypherParser::SP);
    }
    setState(1267);
    match(CypherParser::T__5);
    setState(1269);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1268);
      match(CypherParser::SP);
    }
    setState(1271);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_DeleteContext ------------------------------------------------------------------

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, 128, 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(1275);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::DETACH) {
      setState(1273);
      match(CypherParser::DETACH);
      setState(1274);
      match(CypherParser::SP);
    }
    setState(1277);
    match(CypherParser::DELETE);
    setState(1279);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1278);
      match(CypherParser::SP);
    }
    setState(1281);
    oC_Expression();
    setState(1292);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 179, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1283);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1282);
          match(CypherParser::SP);
        }
        setState(1285);
        match(CypherParser::T__2);
        setState(1287);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1286);
          match(CypherParser::SP);
        }
        setState(1289);
        oC_Expression(); 
      }
      setState(1294);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 179, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_WithContext ------------------------------------------------------------------

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, 130, 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(1295);
    match(CypherParser::WITH);
    setState(1296);
    oC_ProjectionBody();
    setState(1301);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx)) {
    case 1: {
      setState(1298);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1297);
        match(CypherParser::SP);
      }
      setState(1300);
      oC_Where();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ReturnContext ------------------------------------------------------------------

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, 132, CypherParser::RuleOC_Return);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1303);
    match(CypherParser::RETURN);
    setState(1304);
    oC_ProjectionBody();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ProjectionBodyContext ------------------------------------------------------------------

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, 134, 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(1310);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 183, _ctx)) {
    case 1: {
      setState(1307);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1306);
        match(CypherParser::SP);
      }
      setState(1309);
      match(CypherParser::DISTINCT);
      break;
    }

    default:
      break;
    }
    setState(1312);
    match(CypherParser::SP);
    setState(1313);
    oC_ProjectionItems();
    setState(1316);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 184, _ctx)) {
    case 1: {
      setState(1314);
      match(CypherParser::SP);
      setState(1315);
      oC_Order();
      break;
    }

    default:
      break;
    }
    setState(1320);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 185, _ctx)) {
    case 1: {
      setState(1318);
      match(CypherParser::SP);
      setState(1319);
      oC_Skip();
      break;
    }

    default:
      break;
    }
    setState(1324);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 186, _ctx)) {
    case 1: {
      setState(1322);
      match(CypherParser::SP);
      setState(1323);
      oC_Limit();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ProjectionItemsContext ------------------------------------------------------------------

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, 136, 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(1354);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::STAR: {
        enterOuterAlt(_localctx, 1);
        setState(1326);
        match(CypherParser::STAR);
        setState(1337);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 189, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(1328);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1327);
              match(CypherParser::SP);
            }
            setState(1330);
            match(CypherParser::T__2);
            setState(1332);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1331);
              match(CypherParser::SP);
            }
            setState(1334);
            oC_ProjectionItem(); 
          }
          setState(1339);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 189, _ctx);
        }
        break;
      }

      case CypherParser::T__1:
      case CypherParser::T__6:
      case CypherParser::T__8:
      case CypherParser::T__25:
      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::NOT:
      case CypherParser::MINUS:
      case CypherParser::IN:
      case CypherParser::NULL_:
      case CypherParser::TRUE:
      case CypherParser::FALSE:
      case CypherParser::COUNT:
      case CypherParser::EXISTS:
      case CypherParser::CASE:
      case CypherParser::END:
      case CypherParser::StringLiteral:
      case CypherParser::DecimalInteger:
      case CypherParser::HexLetter:
      case CypherParser::RegularDecimalReal:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 2);
        setState(1340);
        oC_ProjectionItem();
        setState(1351);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(1342);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1341);
              match(CypherParser::SP);
            }
            setState(1344);
            match(CypherParser::T__2);
            setState(1346);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1345);
              match(CypherParser::SP);
            }
            setState(1348);
            oC_ProjectionItem(); 
          }
          setState(1353);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _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;
}

//----------------- OC_ProjectionItemContext ------------------------------------------------------------------

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, 138, CypherParser::RuleOC_ProjectionItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1363);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 194, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1356);
      oC_Expression();
      setState(1357);
      match(CypherParser::SP);
      setState(1358);
      match(CypherParser::AS);
      setState(1359);
      match(CypherParser::SP);
      setState(1360);
      oC_Variable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1362);
      oC_Expression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_OrderContext ------------------------------------------------------------------

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, 140, 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(1365);
    match(CypherParser::ORDER);
    setState(1366);
    match(CypherParser::SP);
    setState(1367);
    match(CypherParser::BY);
    setState(1368);
    match(CypherParser::SP);
    setState(1369);
    oC_SortItem();
    setState(1377);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__2) {
      setState(1370);
      match(CypherParser::T__2);
      setState(1372);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1371);
        match(CypherParser::SP);
      }
      setState(1374);
      oC_SortItem();
      setState(1379);
      _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;
}

//----------------- OC_SkipContext ------------------------------------------------------------------

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, 142, CypherParser::RuleOC_Skip);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1380);
    match(CypherParser::L_SKIP);
    setState(1381);
    match(CypherParser::SP);
    setState(1382);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LimitContext ------------------------------------------------------------------

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, 144, CypherParser::RuleOC_Limit);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1384);
    match(CypherParser::LIMIT);
    setState(1385);
    match(CypherParser::SP);
    setState(1386);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SortItemContext ------------------------------------------------------------------

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, 146, 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(1388);
    oC_Expression();
    setState(1393);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 198, _ctx)) {
    case 1: {
      setState(1390);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1389);
        match(CypherParser::SP);
      }
      setState(1392);
      _la = _input->LA(1);
      if (!(((((_la - 107) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 107)) & 15) != 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;
}

//----------------- OC_WhereContext ------------------------------------------------------------------

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, 148, CypherParser::RuleOC_Where);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1395);
    match(CypherParser::WHERE);
    setState(1396);
    match(CypherParser::SP);
    setState(1397);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternContext ------------------------------------------------------------------

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, 150, 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(1399);
    oC_PatternPart();
    setState(1410);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1401);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1400);
          match(CypherParser::SP);
        }
        setState(1403);
        match(CypherParser::T__2);
        setState(1405);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1404);
          match(CypherParser::SP);
        }
        setState(1407);
        oC_PatternPart(); 
      }
      setState(1412);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternPartContext ------------------------------------------------------------------

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, 152, CypherParser::RuleOC_PatternPart);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1424);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::IN:
      case CypherParser::COUNT:
      case CypherParser::END:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(1413);
        oC_Variable();
        setState(1415);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1414);
          match(CypherParser::SP);
        }
        setState(1417);
        match(CypherParser::T__5);
        setState(1419);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1418);
          match(CypherParser::SP);
        }
        setState(1421);
        oC_AnonymousPatternPart();
        break;
      }

      case CypherParser::T__1: {
        enterOuterAlt(_localctx, 2);
        setState(1423);
        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;
}

//----------------- OC_AnonymousPatternPartContext ------------------------------------------------------------------

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, 154, CypherParser::RuleOC_AnonymousPatternPart);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1426);
    oC_PatternElement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternElementContext ------------------------------------------------------------------

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, 156, 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(1442);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1428);
      oC_NodePattern();
      setState(1435);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 206, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1430);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1429);
            match(CypherParser::SP);
          }
          setState(1432);
          oC_PatternElementChain(); 
        }
        setState(1437);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 206, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1438);
      match(CypherParser::T__1);
      setState(1439);
      oC_PatternElement();
      setState(1440);
      match(CypherParser::T__3);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NodePatternContext ------------------------------------------------------------------

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::KU_PropertiesContext* CypherParser::OC_NodePatternContext::kU_Properties() {
  return getRuleContext<CypherParser::KU_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, 158, 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(1444);
    match(CypherParser::T__1);
    setState(1446);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1445);
      match(CypherParser::SP);
    }
    setState(1452);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 48) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 48)) & 71307013) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 121)) & 302256385) != 0)) {
      setState(1448);
      oC_Variable();
      setState(1450);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1449);
        match(CypherParser::SP);
      }
    }
    setState(1458);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::COLON) {
      setState(1454);
      oC_NodeLabels();
      setState(1456);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1455);
        match(CypherParser::SP);
      }
    }
    setState(1464);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::T__8) {
      setState(1460);
      kU_Properties();
      setState(1462);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1461);
        match(CypherParser::SP);
      }
    }
    setState(1466);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PatternElementChainContext ------------------------------------------------------------------

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, 160, 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(1468);
    oC_RelationshipPattern();
    setState(1470);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1469);
      match(CypherParser::SP);
    }
    setState(1472);
    oC_NodePattern();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipPatternContext ------------------------------------------------------------------

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, 162, CypherParser::RuleOC_RelationshipPattern);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1518);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 227, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1474);
      oC_LeftArrowHead();
      setState(1476);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1475);
        match(CypherParser::SP);
      }
      setState(1478);
      oC_Dash();
      setState(1480);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 217, _ctx)) {
      case 1: {
        setState(1479);
        match(CypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(1483);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::T__6) {
        setState(1482);
        oC_RelationshipDetail();
      }
      setState(1486);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1485);
        match(CypherParser::SP);
      }
      setState(1488);
      oC_Dash();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1490);
      oC_Dash();
      setState(1492);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 220, _ctx)) {
      case 1: {
        setState(1491);
        match(CypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(1495);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::T__6) {
        setState(1494);
        oC_RelationshipDetail();
      }
      setState(1498);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1497);
        match(CypherParser::SP);
      }
      setState(1500);
      oC_Dash();
      setState(1502);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1501);
        match(CypherParser::SP);
      }
      setState(1504);
      oC_RightArrowHead();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1506);
      oC_Dash();
      setState(1508);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 224, _ctx)) {
      case 1: {
        setState(1507);
        match(CypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(1511);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::T__6) {
        setState(1510);
        oC_RelationshipDetail();
      }
      setState(1514);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1513);
        match(CypherParser::SP);
      }
      setState(1516);
      oC_Dash();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipDetailContext ------------------------------------------------------------------

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::OC_RangeLiteralContext* CypherParser::OC_RelationshipDetailContext::oC_RangeLiteral() {
  return getRuleContext<CypherParser::OC_RangeLiteralContext>(0);
}

CypherParser::KU_PropertiesContext* CypherParser::OC_RelationshipDetailContext::kU_Properties() {
  return getRuleContext<CypherParser::KU_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, 164, 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(1520);
    match(CypherParser::T__6);
    setState(1522);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1521);
      match(CypherParser::SP);
    }
    setState(1528);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 48) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 48)) & 71307013) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 121)) & 302256385) != 0)) {
      setState(1524);
      oC_Variable();
      setState(1526);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1525);
        match(CypherParser::SP);
      }
    }
    setState(1534);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::COLON) {
      setState(1530);
      oC_RelationshipTypes();
      setState(1532);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1531);
        match(CypherParser::SP);
      }
    }
    setState(1540);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::STAR) {
      setState(1536);
      oC_RangeLiteral();
      setState(1538);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1537);
        match(CypherParser::SP);
      }
    }
    setState(1546);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::T__8) {
      setState(1542);
      kU_Properties();
      setState(1544);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1543);
        match(CypherParser::SP);
      }
    }
    setState(1548);
    match(CypherParser::T__7);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_PropertiesContext ------------------------------------------------------------------

CypherParser::KU_PropertiesContext::KU_PropertiesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CypherParser::KU_PropertiesContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_PropertiesContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

std::vector<CypherParser::OC_PropertyKeyNameContext *> CypherParser::KU_PropertiesContext::oC_PropertyKeyName() {
  return getRuleContexts<CypherParser::OC_PropertyKeyNameContext>();
}

CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_PropertiesContext::oC_PropertyKeyName(size_t i) {
  return getRuleContext<CypherParser::OC_PropertyKeyNameContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_PropertiesContext::COLON() {
  return getTokens(CypherParser::COLON);
}

tree::TerminalNode* CypherParser::KU_PropertiesContext::COLON(size_t i) {
  return getToken(CypherParser::COLON, i);
}

std::vector<CypherParser::OC_ExpressionContext *> CypherParser::KU_PropertiesContext::oC_Expression() {
  return getRuleContexts<CypherParser::OC_ExpressionContext>();
}

CypherParser::OC_ExpressionContext* CypherParser::KU_PropertiesContext::oC_Expression(size_t i) {
  return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}


size_t CypherParser::KU_PropertiesContext::getRuleIndex() const {
  return CypherParser::RuleKU_Properties;
}


CypherParser::KU_PropertiesContext* CypherParser::kU_Properties() {
  KU_PropertiesContext *_localctx = _tracker.createInstance<KU_PropertiesContext>(_ctx, getState());
  enterRule(_localctx, 166, CypherParser::RuleKU_Properties);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1550);
    match(CypherParser::T__8);
    setState(1552);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1551);
      match(CypherParser::SP);
    }
    setState(1587);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((((_la - 48) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 48)) & 71307013) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 121)) & 302256385) != 0)) {
      setState(1554);
      oC_PropertyKeyName();
      setState(1556);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1555);
        match(CypherParser::SP);
      }
      setState(1558);
      match(CypherParser::COLON);
      setState(1560);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1559);
        match(CypherParser::SP);
      }
      setState(1562);
      oC_Expression();
      setState(1564);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1563);
        match(CypherParser::SP);
      }
      setState(1584);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::T__2) {
        setState(1566);
        match(CypherParser::T__2);
        setState(1568);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1567);
          match(CypherParser::SP);
        }
        setState(1570);
        oC_PropertyKeyName();
        setState(1572);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1571);
          match(CypherParser::SP);
        }
        setState(1574);
        match(CypherParser::COLON);
        setState(1576);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1575);
          match(CypherParser::SP);
        }
        setState(1578);
        oC_Expression();
        setState(1580);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1579);
          match(CypherParser::SP);
        }
        setState(1586);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(1589);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelationshipTypesContext ------------------------------------------------------------------

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, 168, 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(1591);
    match(CypherParser::COLON);
    setState(1593);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1592);
      match(CypherParser::SP);
    }
    setState(1595);
    oC_RelTypeName();
    setState(1609);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1597);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1596);
          match(CypherParser::SP);
        }
        setState(1599);
        match(CypherParser::T__10);
        setState(1601);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::COLON) {
          setState(1600);
          match(CypherParser::COLON);
        }
        setState(1604);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1603);
          match(CypherParser::SP);
        }
        setState(1606);
        oC_RelTypeName(); 
      }
      setState(1611);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NodeLabelsContext ------------------------------------------------------------------

CypherParser::OC_NodeLabelsContext::OC_NodeLabelsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_NodeLabelContext *> CypherParser::OC_NodeLabelsContext::oC_NodeLabel() {
  return getRuleContexts<CypherParser::OC_NodeLabelContext>();
}

CypherParser::OC_NodeLabelContext* CypherParser::OC_NodeLabelsContext::oC_NodeLabel(size_t i) {
  return getRuleContext<CypherParser::OC_NodeLabelContext>(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, 170, 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(1612);
    oC_NodeLabel();
    setState(1619);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1614);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1613);
          match(CypherParser::SP);
        }
        setState(1616);
        oC_NodeLabel(); 
      }
      setState(1621);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NodeLabelContext ------------------------------------------------------------------

CypherParser::OC_NodeLabelContext::OC_NodeLabelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::OC_NodeLabelContext::COLON() {
  return getToken(CypherParser::COLON, 0);
}

CypherParser::OC_LabelNameContext* CypherParser::OC_NodeLabelContext::oC_LabelName() {
  return getRuleContext<CypherParser::OC_LabelNameContext>(0);
}

tree::TerminalNode* CypherParser::OC_NodeLabelContext::SP() {
  return getToken(CypherParser::SP, 0);
}


size_t CypherParser::OC_NodeLabelContext::getRuleIndex() const {
  return CypherParser::RuleOC_NodeLabel;
}


CypherParser::OC_NodeLabelContext* CypherParser::oC_NodeLabel() {
  OC_NodeLabelContext *_localctx = _tracker.createInstance<OC_NodeLabelContext>(_ctx, getState());
  enterRule(_localctx, 172, CypherParser::RuleOC_NodeLabel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1622);
    match(CypherParser::COLON);
    setState(1624);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1623);
      match(CypherParser::SP);
    }
    setState(1626);
    oC_LabelName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RangeLiteralContext ------------------------------------------------------------------

CypherParser::OC_RangeLiteralContext::OC_RangeLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::OC_RangeLiteralContext::STAR() {
  return getToken(CypherParser::STAR, 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);
}

tree::TerminalNode* CypherParser::OC_RangeLiteralContext::SHORTEST() {
  return getToken(CypherParser::SHORTEST, 0);
}

tree::TerminalNode* CypherParser::OC_RangeLiteralContext::ALL() {
  return getToken(CypherParser::ALL, 0);
}

CypherParser::OC_IntegerLiteralContext* CypherParser::OC_RangeLiteralContext::oC_IntegerLiteral() {
  return getRuleContext<CypherParser::OC_IntegerLiteralContext>(0);
}

CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::OC_RangeLiteralContext::kU_RecursiveRelationshipComprehension() {
  return getRuleContext<CypherParser::KU_RecursiveRelationshipComprehensionContext>(0);
}

CypherParser::OC_LowerBoundContext* CypherParser::OC_RangeLiteralContext::oC_LowerBound() {
  return getRuleContext<CypherParser::OC_LowerBoundContext>(0);
}

CypherParser::OC_UpperBoundContext* CypherParser::OC_RangeLiteralContext::oC_UpperBound() {
  return getRuleContext<CypherParser::OC_UpperBoundContext>(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, 174, CypherParser::RuleOC_RangeLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1628);
    match(CypherParser::STAR);
    setState(1630);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 255, _ctx)) {
    case 1: {
      setState(1629);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(1636);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::SHORTEST: {
        setState(1632);
        match(CypherParser::SHORTEST);
        break;
      }

      case CypherParser::ALL: {
        setState(1633);
        match(CypherParser::ALL);
        setState(1634);
        match(CypherParser::SP);
        setState(1635);
        match(CypherParser::SHORTEST);
        break;
      }

      case CypherParser::T__1:
      case CypherParser::T__7:
      case CypherParser::T__8:
      case CypherParser::T__11:
      case CypherParser::DecimalInteger:
      case CypherParser::SP: {
        break;
      }

    default:
      break;
    }
    setState(1639);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 257, _ctx)) {
    case 1: {
      setState(1638);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(1655);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 262, _ctx)) {
    case 1: {
      setState(1642);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::DecimalInteger) {
        setState(1641);
        oC_LowerBound();
      }
      setState(1645);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1644);
        match(CypherParser::SP);
      }
      setState(1647);
      match(CypherParser::T__11);
      setState(1649);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 260, _ctx)) {
      case 1: {
        setState(1648);
        match(CypherParser::SP);
        break;
      }

      default:
        break;
      }
      setState(1652);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::DecimalInteger) {
        setState(1651);
        oC_UpperBound();
      }
      break;
    }

    case 2: {
      setState(1654);
      oC_IntegerLiteral();
      break;
    }

    default:
      break;
    }
    setState(1661);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 264, _ctx)) {
    case 1: {
      setState(1658);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1657);
        match(CypherParser::SP);
      }
      setState(1660);
      kU_RecursiveRelationshipComprehension();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_RecursiveRelationshipComprehensionContext ------------------------------------------------------------------

CypherParser::KU_RecursiveRelationshipComprehensionContext::KU_RecursiveRelationshipComprehensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_VariableContext *> CypherParser::KU_RecursiveRelationshipComprehensionContext::oC_Variable() {
  return getRuleContexts<CypherParser::OC_VariableContext>();
}

CypherParser::OC_VariableContext* CypherParser::KU_RecursiveRelationshipComprehensionContext::oC_Variable(size_t i) {
  return getRuleContext<CypherParser::OC_VariableContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_RecursiveRelationshipComprehensionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_RecursiveRelationshipComprehensionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_WhereContext* CypherParser::KU_RecursiveRelationshipComprehensionContext::oC_Where() {
  return getRuleContext<CypherParser::OC_WhereContext>(0);
}

CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::KU_RecursiveRelationshipComprehensionContext::kU_IntermediateRelProjectionItems() {
  return getRuleContext<CypherParser::KU_IntermediateRelProjectionItemsContext>(0);
}

CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::KU_RecursiveRelationshipComprehensionContext::kU_IntermediateNodeProjectionItems() {
  return getRuleContext<CypherParser::KU_IntermediateNodeProjectionItemsContext>(0);
}


size_t CypherParser::KU_RecursiveRelationshipComprehensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_RecursiveRelationshipComprehension;
}


CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_RecursiveRelationshipComprehension() {
  KU_RecursiveRelationshipComprehensionContext *_localctx = _tracker.createInstance<KU_RecursiveRelationshipComprehensionContext>(_ctx, getState());
  enterRule(_localctx, 176, CypherParser::RuleKU_RecursiveRelationshipComprehension);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1663);
    match(CypherParser::T__1);
    setState(1665);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1664);
      match(CypherParser::SP);
    }
    setState(1667);
    oC_Variable();
    setState(1669);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1668);
      match(CypherParser::SP);
    }
    setState(1671);
    match(CypherParser::T__2);
    setState(1673);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1672);
      match(CypherParser::SP);
    }
    setState(1675);
    oC_Variable();
    setState(1684);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 270, _ctx)) {
    case 1: {
      setState(1677);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1676);
        match(CypherParser::SP);
      }
      setState(1679);
      match(CypherParser::T__10);
      setState(1681);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1680);
        match(CypherParser::SP);
      }
      setState(1683);
      oC_Where();
      break;
    }

    default:
      break;
    }
    setState(1705);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::T__10 || _la == CypherParser::SP) {
      setState(1687);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1686);
        match(CypherParser::SP);
      }
      setState(1689);
      match(CypherParser::T__10);
      setState(1691);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1690);
        match(CypherParser::SP);
      }
      setState(1693);
      kU_IntermediateRelProjectionItems();
      setState(1695);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1694);
        match(CypherParser::SP);
      }
      setState(1697);
      match(CypherParser::T__2);
      setState(1699);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1698);
        match(CypherParser::SP);
      }
      setState(1701);
      kU_IntermediateNodeProjectionItems();
      setState(1703);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1702);
        match(CypherParser::SP);
      }
    }
    setState(1707);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_IntermediateNodeProjectionItemsContext ------------------------------------------------------------------

CypherParser::KU_IntermediateNodeProjectionItemsContext::KU_IntermediateNodeProjectionItemsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CypherParser::KU_IntermediateNodeProjectionItemsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_IntermediateNodeProjectionItemsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_ProjectionItemsContext* CypherParser::KU_IntermediateNodeProjectionItemsContext::oC_ProjectionItems() {
  return getRuleContext<CypherParser::OC_ProjectionItemsContext>(0);
}


size_t CypherParser::KU_IntermediateNodeProjectionItemsContext::getRuleIndex() const {
  return CypherParser::RuleKU_IntermediateNodeProjectionItems;
}


CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_IntermediateNodeProjectionItems() {
  KU_IntermediateNodeProjectionItemsContext *_localctx = _tracker.createInstance<KU_IntermediateNodeProjectionItemsContext>(_ctx, getState());
  enterRule(_localctx, 178, CypherParser::RuleKU_IntermediateNodeProjectionItems);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1709);
    match(CypherParser::T__8);
    setState(1711);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 277, _ctx)) {
    case 1: {
      setState(1710);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(1714);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 70)) & -4681139966783258607) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 136)) & 9741) != 0)) {
      setState(1713);
      oC_ProjectionItems();
    }
    setState(1717);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1716);
      match(CypherParser::SP);
    }
    setState(1719);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_IntermediateRelProjectionItemsContext ------------------------------------------------------------------

CypherParser::KU_IntermediateRelProjectionItemsContext::KU_IntermediateRelProjectionItemsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> CypherParser::KU_IntermediateRelProjectionItemsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_IntermediateRelProjectionItemsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_ProjectionItemsContext* CypherParser::KU_IntermediateRelProjectionItemsContext::oC_ProjectionItems() {
  return getRuleContext<CypherParser::OC_ProjectionItemsContext>(0);
}


size_t CypherParser::KU_IntermediateRelProjectionItemsContext::getRuleIndex() const {
  return CypherParser::RuleKU_IntermediateRelProjectionItems;
}


CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_IntermediateRelProjectionItems() {
  KU_IntermediateRelProjectionItemsContext *_localctx = _tracker.createInstance<KU_IntermediateRelProjectionItemsContext>(_ctx, getState());
  enterRule(_localctx, 180, CypherParser::RuleKU_IntermediateRelProjectionItems);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1721);
    match(CypherParser::T__8);
    setState(1723);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 280, _ctx)) {
    case 1: {
      setState(1722);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(1726);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 70)) & -4681139966783258607) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 136)) & 9741) != 0)) {
      setState(1725);
      oC_ProjectionItems();
    }
    setState(1729);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1728);
      match(CypherParser::SP);
    }
    setState(1731);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LowerBoundContext ------------------------------------------------------------------

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, 182, CypherParser::RuleOC_LowerBound);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1733);
    match(CypherParser::DecimalInteger);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UpperBoundContext ------------------------------------------------------------------

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, 184, CypherParser::RuleOC_UpperBound);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1735);
    match(CypherParser::DecimalInteger);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LabelNameContext ------------------------------------------------------------------

CypherParser::OC_LabelNameContext::OC_LabelNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_SchemaNameContext* CypherParser::OC_LabelNameContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(0);
}


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, 186, CypherParser::RuleOC_LabelName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1737);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RelTypeNameContext ------------------------------------------------------------------

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, 188, CypherParser::RuleOC_RelTypeName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1739);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ExpressionContext ------------------------------------------------------------------

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, 190, CypherParser::RuleOC_Expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1741);
    oC_OrExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_OrExpressionContext ------------------------------------------------------------------

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, 192, CypherParser::RuleOC_OrExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1743);
    oC_XorExpression();
    setState(1750);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 283, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1744);
        match(CypherParser::SP);
        setState(1745);
        match(CypherParser::OR);
        setState(1746);
        match(CypherParser::SP);
        setState(1747);
        oC_XorExpression(); 
      }
      setState(1752);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 283, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_XorExpressionContext ------------------------------------------------------------------

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, 194, CypherParser::RuleOC_XorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1753);
    oC_AndExpression();
    setState(1760);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 284, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1754);
        match(CypherParser::SP);
        setState(1755);
        match(CypherParser::XOR);
        setState(1756);
        match(CypherParser::SP);
        setState(1757);
        oC_AndExpression(); 
      }
      setState(1762);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 284, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AndExpressionContext ------------------------------------------------------------------

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, 196, CypherParser::RuleOC_AndExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1763);
    oC_NotExpression();
    setState(1770);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 285, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1764);
        match(CypherParser::SP);
        setState(1765);
        match(CypherParser::AND);
        setState(1766);
        match(CypherParser::SP);
        setState(1767);
        oC_NotExpression(); 
      }
      setState(1772);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 285, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NotExpressionContext ------------------------------------------------------------------

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, 198, 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(1779);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::NOT) {
      setState(1773);
      match(CypherParser::NOT);
      setState(1775);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1774);
        match(CypherParser::SP);
      }
      setState(1781);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1782);
    oC_ComparisonExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ComparisonExpressionContext ------------------------------------------------------------------

CypherParser::OC_ComparisonExpressionContext::OC_ComparisonExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_BitwiseOrOperatorExpressionContext *> CypherParser::OC_ComparisonExpressionContext::kU_BitwiseOrOperatorExpression() {
  return getRuleContexts<CypherParser::KU_BitwiseOrOperatorExpressionContext>();
}

CypherParser::KU_BitwiseOrOperatorExpressionContext* CypherParser::OC_ComparisonExpressionContext::kU_BitwiseOrOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::KU_BitwiseOrOperatorExpressionContext>(i);
}

std::vector<CypherParser::KU_ComparisonOperatorContext *> CypherParser::OC_ComparisonExpressionContext::kU_ComparisonOperator() {
  return getRuleContexts<CypherParser::KU_ComparisonOperatorContext>();
}

CypherParser::KU_ComparisonOperatorContext* CypherParser::OC_ComparisonExpressionContext::kU_ComparisonOperator(size_t i) {
  return getRuleContext<CypherParser::KU_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, 200, 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(1832);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1784);
      kU_BitwiseOrOperatorExpression();
      setState(1794);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 290, _ctx)) {
      case 1: {
        setState(1786);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1785);
          match(CypherParser::SP);
        }
        setState(1788);
        kU_ComparisonOperator();
        setState(1790);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1789);
          match(CypherParser::SP);
        }
        setState(1792);
        kU_BitwiseOrOperatorExpression();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1796);
      kU_BitwiseOrOperatorExpression();

      setState(1798);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1797);
        match(CypherParser::SP);
      }
      setState(1800);
      antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken = match(CypherParser::INVALID_NOT_EQUAL);
      setState(1802);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1801);
        match(CypherParser::SP);
      }
      setState(1804);
      kU_BitwiseOrOperatorExpression();
       notifyInvalidNotEqualOperator(antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken); 
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1808);
      kU_BitwiseOrOperatorExpression();
      setState(1810);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1809);
        match(CypherParser::SP);
      }
      setState(1812);
      kU_ComparisonOperator();
      setState(1814);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1813);
        match(CypherParser::SP);
      }
      setState(1816);
      kU_BitwiseOrOperatorExpression();
      setState(1826); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1818);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(1817);
                  match(CypherParser::SP);
                }
                setState(1820);
                kU_ComparisonOperator();
                setState(1822);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(1821);
                  match(CypherParser::SP);
                }
                setState(1824);
                kU_BitwiseOrOperatorExpression();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1828); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 297, _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;
}

//----------------- KU_ComparisonOperatorContext ------------------------------------------------------------------

CypherParser::KU_ComparisonOperatorContext::KU_ComparisonOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t CypherParser::KU_ComparisonOperatorContext::getRuleIndex() const {
  return CypherParser::RuleKU_ComparisonOperator;
}


CypherParser::KU_ComparisonOperatorContext* CypherParser::kU_ComparisonOperator() {
  KU_ComparisonOperatorContext *_localctx = _tracker.createInstance<KU_ComparisonOperatorContext>(_ctx, getState());
  enterRule(_localctx, 202, CypherParser::RuleKU_ComparisonOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1834);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 254016) != 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;
}

//----------------- KU_BitwiseOrOperatorExpressionContext ------------------------------------------------------------------

CypherParser::KU_BitwiseOrOperatorExpressionContext::KU_BitwiseOrOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_BitwiseAndOperatorExpressionContext *> CypherParser::KU_BitwiseOrOperatorExpressionContext::kU_BitwiseAndOperatorExpression() {
  return getRuleContexts<CypherParser::KU_BitwiseAndOperatorExpressionContext>();
}

CypherParser::KU_BitwiseAndOperatorExpressionContext* CypherParser::KU_BitwiseOrOperatorExpressionContext::kU_BitwiseAndOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::KU_BitwiseAndOperatorExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_BitwiseOrOperatorExpressionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_BitwiseOrOperatorExpressionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_BitwiseOrOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleKU_BitwiseOrOperatorExpression;
}


CypherParser::KU_BitwiseOrOperatorExpressionContext* CypherParser::kU_BitwiseOrOperatorExpression() {
  KU_BitwiseOrOperatorExpressionContext *_localctx = _tracker.createInstance<KU_BitwiseOrOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 204, CypherParser::RuleKU_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(1836);
    kU_BitwiseAndOperatorExpression();
    setState(1847);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1838);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1837);
          match(CypherParser::SP);
        }
        setState(1840);
        match(CypherParser::T__10);
        setState(1842);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1841);
          match(CypherParser::SP);
        }
        setState(1844);
        kU_BitwiseAndOperatorExpression(); 
      }
      setState(1849);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_BitwiseAndOperatorExpressionContext ------------------------------------------------------------------

CypherParser::KU_BitwiseAndOperatorExpressionContext::KU_BitwiseAndOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_BitShiftOperatorExpressionContext *> CypherParser::KU_BitwiseAndOperatorExpressionContext::kU_BitShiftOperatorExpression() {
  return getRuleContexts<CypherParser::KU_BitShiftOperatorExpressionContext>();
}

CypherParser::KU_BitShiftOperatorExpressionContext* CypherParser::KU_BitwiseAndOperatorExpressionContext::kU_BitShiftOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::KU_BitShiftOperatorExpressionContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_BitwiseAndOperatorExpressionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_BitwiseAndOperatorExpressionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_BitwiseAndOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleKU_BitwiseAndOperatorExpression;
}


CypherParser::KU_BitwiseAndOperatorExpressionContext* CypherParser::kU_BitwiseAndOperatorExpression() {
  KU_BitwiseAndOperatorExpressionContext *_localctx = _tracker.createInstance<KU_BitwiseAndOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 206, CypherParser::RuleKU_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(1850);
    kU_BitShiftOperatorExpression();
    setState(1861);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 304, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1852);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1851);
          match(CypherParser::SP);
        }
        setState(1854);
        match(CypherParser::T__17);
        setState(1856);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1855);
          match(CypherParser::SP);
        }
        setState(1858);
        kU_BitShiftOperatorExpression(); 
      }
      setState(1863);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 304, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_BitShiftOperatorExpressionContext ------------------------------------------------------------------

CypherParser::KU_BitShiftOperatorExpressionContext::KU_BitShiftOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_AddOrSubtractExpressionContext *> CypherParser::KU_BitShiftOperatorExpressionContext::oC_AddOrSubtractExpression() {
  return getRuleContexts<CypherParser::OC_AddOrSubtractExpressionContext>();
}

CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::KU_BitShiftOperatorExpressionContext::oC_AddOrSubtractExpression(size_t i) {
  return getRuleContext<CypherParser::OC_AddOrSubtractExpressionContext>(i);
}

std::vector<CypherParser::KU_BitShiftOperatorContext *> CypherParser::KU_BitShiftOperatorExpressionContext::kU_BitShiftOperator() {
  return getRuleContexts<CypherParser::KU_BitShiftOperatorContext>();
}

CypherParser::KU_BitShiftOperatorContext* CypherParser::KU_BitShiftOperatorExpressionContext::kU_BitShiftOperator(size_t i) {
  return getRuleContext<CypherParser::KU_BitShiftOperatorContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_BitShiftOperatorExpressionContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_BitShiftOperatorExpressionContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_BitShiftOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleKU_BitShiftOperatorExpression;
}


CypherParser::KU_BitShiftOperatorExpressionContext* CypherParser::kU_BitShiftOperatorExpression() {
  KU_BitShiftOperatorExpressionContext *_localctx = _tracker.createInstance<KU_BitShiftOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 208, CypherParser::RuleKU_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(1864);
    oC_AddOrSubtractExpression();
    setState(1876);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1866);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1865);
          match(CypherParser::SP);
        }
        setState(1868);
        kU_BitShiftOperator();
        setState(1870);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1869);
          match(CypherParser::SP);
        }
        setState(1872);
        oC_AddOrSubtractExpression(); 
      }
      setState(1878);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_BitShiftOperatorContext ------------------------------------------------------------------

CypherParser::KU_BitShiftOperatorContext::KU_BitShiftOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t CypherParser::KU_BitShiftOperatorContext::getRuleIndex() const {
  return CypherParser::RuleKU_BitShiftOperator;
}


CypherParser::KU_BitShiftOperatorContext* CypherParser::kU_BitShiftOperator() {
  KU_BitShiftOperatorContext *_localctx = _tracker.createInstance<KU_BitShiftOperatorContext>(_ctx, getState());
  enterRule(_localctx, 210, CypherParser::RuleKU_BitShiftOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1879);
    _la = _input->LA(1);
    if (!(_la == CypherParser::T__18

    || _la == CypherParser::T__19)) {
    _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;
}

//----------------- OC_AddOrSubtractExpressionContext ------------------------------------------------------------------

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::KU_AddOrSubtractOperatorContext *> CypherParser::OC_AddOrSubtractExpressionContext::kU_AddOrSubtractOperator() {
  return getRuleContexts<CypherParser::KU_AddOrSubtractOperatorContext>();
}

CypherParser::KU_AddOrSubtractOperatorContext* CypherParser::OC_AddOrSubtractExpressionContext::kU_AddOrSubtractOperator(size_t i) {
  return getRuleContext<CypherParser::KU_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, 212, 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(1881);
    oC_MultiplyDivideModuloExpression();
    setState(1893);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 310, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1883);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1882);
          match(CypherParser::SP);
        }
        setState(1885);
        kU_AddOrSubtractOperator();
        setState(1887);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1886);
          match(CypherParser::SP);
        }
        setState(1889);
        oC_MultiplyDivideModuloExpression(); 
      }
      setState(1895);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 310, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_AddOrSubtractOperatorContext ------------------------------------------------------------------

CypherParser::KU_AddOrSubtractOperatorContext::KU_AddOrSubtractOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_AddOrSubtractOperatorContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}


size_t CypherParser::KU_AddOrSubtractOperatorContext::getRuleIndex() const {
  return CypherParser::RuleKU_AddOrSubtractOperator;
}


CypherParser::KU_AddOrSubtractOperatorContext* CypherParser::kU_AddOrSubtractOperator() {
  KU_AddOrSubtractOperatorContext *_localctx = _tracker.createInstance<KU_AddOrSubtractOperatorContext>(_ctx, getState());
  enterRule(_localctx, 214, CypherParser::RuleKU_AddOrSubtractOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1896);
    _la = _input->LA(1);
    if (!(_la == CypherParser::T__20 || _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;
}

//----------------- OC_MultiplyDivideModuloExpressionContext ------------------------------------------------------------------

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::KU_MultiplyDivideModuloOperatorContext *> CypherParser::OC_MultiplyDivideModuloExpressionContext::kU_MultiplyDivideModuloOperator() {
  return getRuleContexts<CypherParser::KU_MultiplyDivideModuloOperatorContext>();
}

CypherParser::KU_MultiplyDivideModuloOperatorContext* CypherParser::OC_MultiplyDivideModuloExpressionContext::kU_MultiplyDivideModuloOperator(size_t i) {
  return getRuleContext<CypherParser::KU_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, 216, 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(1898);
    oC_PowerOfExpression();
    setState(1910);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1900);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1899);
          match(CypherParser::SP);
        }
        setState(1902);
        kU_MultiplyDivideModuloOperator();
        setState(1904);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1903);
          match(CypherParser::SP);
        }
        setState(1906);
        oC_PowerOfExpression(); 
      }
      setState(1912);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_MultiplyDivideModuloOperatorContext ------------------------------------------------------------------

CypherParser::KU_MultiplyDivideModuloOperatorContext::KU_MultiplyDivideModuloOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_MultiplyDivideModuloOperatorContext::STAR() {
  return getToken(CypherParser::STAR, 0);
}


size_t CypherParser::KU_MultiplyDivideModuloOperatorContext::getRuleIndex() const {
  return CypherParser::RuleKU_MultiplyDivideModuloOperator;
}


CypherParser::KU_MultiplyDivideModuloOperatorContext* CypherParser::kU_MultiplyDivideModuloOperator() {
  KU_MultiplyDivideModuloOperatorContext *_localctx = _tracker.createInstance<KU_MultiplyDivideModuloOperatorContext>(_ctx, getState());
  enterRule(_localctx, 218, CypherParser::RuleKU_MultiplyDivideModuloOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1913);
    _la = _input->LA(1);
    if (!(_la == CypherParser::T__21

    || _la == CypherParser::T__22 || _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;
}

//----------------- OC_PowerOfExpressionContext ------------------------------------------------------------------

CypherParser::OC_PowerOfExpressionContext::OC_PowerOfExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext *> CypherParser::OC_PowerOfExpressionContext::oC_UnaryAddSubtractOrFactorialExpression() {
  return getRuleContexts<CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext>();
}

CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::OC_PowerOfExpressionContext::oC_UnaryAddSubtractOrFactorialExpression(size_t i) {
  return getRuleContext<CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext>(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, 220, 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(1915);
    oC_UnaryAddSubtractOrFactorialExpression();
    setState(1926);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1917);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1916);
          match(CypherParser::SP);
        }
        setState(1919);
        match(CypherParser::T__23);
        setState(1921);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1920);
          match(CypherParser::SP);
        }
        setState(1923);
        oC_UnaryAddSubtractOrFactorialExpression(); 
      }
      setState(1928);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_UnaryAddSubtractOrFactorialExpressionContext ------------------------------------------------------------------

CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::OC_UnaryAddSubtractOrFactorialExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::oC_StringListNullOperatorExpression() {
  return getRuleContext<CypherParser::OC_StringListNullOperatorExpressionContext>(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, 222, 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(1935);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::MINUS) {
      setState(1929);
      match(CypherParser::MINUS);
      setState(1931);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1930);
        match(CypherParser::SP);
      }
      setState(1937);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1938);
    oC_StringListNullOperatorExpression();
    setState(1943);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 320, _ctx)) {
    case 1: {
      setState(1940);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1939);
        match(CypherParser::SP);
      }
      setState(1942);
      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;
}

//----------------- OC_StringListNullOperatorExpressionContext ------------------------------------------------------------------

CypherParser::OC_StringListNullOperatorExpressionContext::OC_StringListNullOperatorExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_PropertyOrLabelsExpression() {
  return getRuleContext<CypherParser::OC_PropertyOrLabelsExpressionContext>(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, 224, CypherParser::RuleOC_StringListNullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1945);
    oC_PropertyOrLabelsExpression();
    setState(1953);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 322, _ctx)) {
    case 1: {
      setState(1946);
      oC_StringOperatorExpression();
      break;
    }

    case 2: {
      setState(1948); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1947);
                oC_ListOperatorExpression();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1950); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 321, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 3: {
      setState(1952);
      oC_NullOperatorExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ListOperatorExpressionContext ------------------------------------------------------------------

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);
}


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, 226, CypherParser::RuleOC_ListOperatorExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1974);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 326, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1955);
      match(CypherParser::SP);
      setState(1956);
      match(CypherParser::IN);
      setState(1958);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1957);
        match(CypherParser::SP);
      }
      setState(1960);
      oC_PropertyOrLabelsExpression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1961);
      match(CypherParser::T__6);
      setState(1962);
      oC_Expression();
      setState(1963);
      match(CypherParser::T__7);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1965);
      match(CypherParser::T__6);
      setState(1967);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 70)) & -4681139968930742255) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 136)) & 9741) != 0)) {
        setState(1966);
        oC_Expression();
      }
      setState(1969);
      match(CypherParser::COLON);
      setState(1971);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 70)) & -4681139968930742255) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 136)) & 9741) != 0)) {
        setState(1970);
        oC_Expression();
      }
      setState(1973);
      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;
}

//----------------- OC_StringOperatorExpressionContext ------------------------------------------------------------------

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, 228, 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(1987);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx)) {
    case 1: {
      setState(1976);
      oC_RegularExpression();
      break;
    }

    case 2: {
      setState(1977);
      match(CypherParser::SP);
      setState(1978);
      match(CypherParser::STARTS);
      setState(1979);
      match(CypherParser::SP);
      setState(1980);
      match(CypherParser::WITH);
      break;
    }

    case 3: {
      setState(1981);
      match(CypherParser::SP);
      setState(1982);
      match(CypherParser::ENDS);
      setState(1983);
      match(CypherParser::SP);
      setState(1984);
      match(CypherParser::WITH);
      break;
    }

    case 4: {
      setState(1985);
      match(CypherParser::SP);
      setState(1986);
      match(CypherParser::CONTAINS);
      break;
    }

    default:
      break;
    }
    setState(1990);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1989);
      match(CypherParser::SP);
    }
    setState(1992);
    oC_PropertyOrLabelsExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_RegularExpressionContext ------------------------------------------------------------------

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, 230, 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(1995);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1994);
      match(CypherParser::SP);
    }
    setState(1997);
    match(CypherParser::T__24);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NullOperatorExpressionContext ------------------------------------------------------------------

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, 232, CypherParser::RuleOC_NullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2009);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 330, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1999);
      match(CypherParser::SP);
      setState(2000);
      match(CypherParser::IS);
      setState(2001);
      match(CypherParser::SP);
      setState(2002);
      match(CypherParser::NULL_);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2003);
      match(CypherParser::SP);
      setState(2004);
      match(CypherParser::IS);
      setState(2005);
      match(CypherParser::SP);
      setState(2006);
      match(CypherParser::NOT);
      setState(2007);
      match(CypherParser::SP);
      setState(2008);
      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;
}

//----------------- OC_PropertyOrLabelsExpressionContext ------------------------------------------------------------------

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, 234, 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(2011);
    oC_Atom();
    setState(2018);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 332, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2013);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2012);
          match(CypherParser::SP);
        }
        setState(2015);
        oC_PropertyLookup(); 
      }
      setState(2020);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 332, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_AtomContext ------------------------------------------------------------------

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_ExistSubqueryContext* CypherParser::OC_AtomContext::oC_ExistSubquery() {
  return getRuleContext<CypherParser::OC_ExistSubqueryContext>(0);
}

CypherParser::KU_CountSubqueryContext* CypherParser::OC_AtomContext::kU_CountSubquery() {
  return getRuleContext<CypherParser::KU_CountSubqueryContext>(0);
}

CypherParser::OC_VariableContext* CypherParser::OC_AtomContext::oC_Variable() {
  return getRuleContext<CypherParser::OC_VariableContext>(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, 236, CypherParser::RuleOC_Atom);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2030);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 333, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2021);
      oC_Literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2022);
      oC_Parameter();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2023);
      oC_CaseExpression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2024);
      oC_ParenthesizedExpression();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2025);
      oC_FunctionInvocation();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2026);
      oC_PathPatterns();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2027);
      oC_ExistSubquery();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2028);
      kU_CountSubquery();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2029);
      oC_Variable();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_LiteralContext ------------------------------------------------------------------

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::KU_StructLiteralContext* CypherParser::OC_LiteralContext::kU_StructLiteral() {
  return getRuleContext<CypherParser::KU_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, 238, CypherParser::RuleOC_Literal);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2038);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::DecimalInteger:
      case CypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(2032);
        oC_NumberLiteral();
        break;
      }

      case CypherParser::StringLiteral: {
        enterOuterAlt(_localctx, 2);
        setState(2033);
        match(CypherParser::StringLiteral);
        break;
      }

      case CypherParser::TRUE:
      case CypherParser::FALSE: {
        enterOuterAlt(_localctx, 3);
        setState(2034);
        oC_BooleanLiteral();
        break;
      }

      case CypherParser::NULL_: {
        enterOuterAlt(_localctx, 4);
        setState(2035);
        match(CypherParser::NULL_);
        break;
      }

      case CypherParser::T__6: {
        enterOuterAlt(_localctx, 5);
        setState(2036);
        oC_ListLiteral();
        break;
      }

      case CypherParser::T__8: {
        enterOuterAlt(_localctx, 6);
        setState(2037);
        kU_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;
}

//----------------- OC_BooleanLiteralContext ------------------------------------------------------------------

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, 240, 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(2040);
    _la = _input->LA(1);
    if (!(_la == CypherParser::TRUE

    || _la == CypherParser::FALSE)) {
    _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;
}

//----------------- OC_ListLiteralContext ------------------------------------------------------------------

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::KU_ListEntryContext *> CypherParser::OC_ListLiteralContext::kU_ListEntry() {
  return getRuleContexts<CypherParser::KU_ListEntryContext>();
}

CypherParser::KU_ListEntryContext* CypherParser::OC_ListLiteralContext::kU_ListEntry(size_t i) {
  return getRuleContext<CypherParser::KU_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, 242, 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(2042);
    match(CypherParser::T__6);
    setState(2044);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2043);
      match(CypherParser::SP);
    }
    setState(2059);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 70)) & -4681139968930742255) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 136)) & 9741) != 0)) {
      setState(2046);
      oC_Expression();
      setState(2048);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2047);
        match(CypherParser::SP);
      }
      setState(2056);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::T__2) {
        setState(2050);
        kU_ListEntry();
        setState(2052);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2051);
          match(CypherParser::SP);
        }
        setState(2058);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(2061);
    match(CypherParser::T__7);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ListEntryContext ------------------------------------------------------------------

CypherParser::KU_ListEntryContext::KU_ListEntryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_ListEntryContext::SP() {
  return getToken(CypherParser::SP, 0);
}

CypherParser::OC_ExpressionContext* CypherParser::KU_ListEntryContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}


size_t CypherParser::KU_ListEntryContext::getRuleIndex() const {
  return CypherParser::RuleKU_ListEntry;
}


CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() {
  KU_ListEntryContext *_localctx = _tracker.createInstance<KU_ListEntryContext>(_ctx, getState());
  enterRule(_localctx, 244, CypherParser::RuleKU_ListEntry);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2063);
    match(CypherParser::T__2);
    setState(2065);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 340, _ctx)) {
    case 1: {
      setState(2064);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(2068);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 70)) & -4681139968930742255) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 136)) & 9741) != 0)) {
      setState(2067);
      oC_Expression();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_StructLiteralContext ------------------------------------------------------------------

CypherParser::KU_StructLiteralContext::KU_StructLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::KU_StructFieldContext *> CypherParser::KU_StructLiteralContext::kU_StructField() {
  return getRuleContexts<CypherParser::KU_StructFieldContext>();
}

CypherParser::KU_StructFieldContext* CypherParser::KU_StructLiteralContext::kU_StructField(size_t i) {
  return getRuleContext<CypherParser::KU_StructFieldContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::KU_StructLiteralContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_StructLiteralContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_StructLiteralContext::getRuleIndex() const {
  return CypherParser::RuleKU_StructLiteral;
}


CypherParser::KU_StructLiteralContext* CypherParser::kU_StructLiteral() {
  KU_StructLiteralContext *_localctx = _tracker.createInstance<KU_StructLiteralContext>(_ctx, getState());
  enterRule(_localctx, 246, CypherParser::RuleKU_StructLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2070);
    match(CypherParser::T__8);
    setState(2072);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2071);
      match(CypherParser::SP);
    }
    setState(2074);
    kU_StructField();
    setState(2076);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2075);
      match(CypherParser::SP);
    }
    setState(2088);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__2) {
      setState(2078);
      match(CypherParser::T__2);
      setState(2080);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2079);
        match(CypherParser::SP);
      }
      setState(2082);
      kU_StructField();
      setState(2084);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2083);
        match(CypherParser::SP);
      }
      setState(2090);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2091);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_StructFieldContext ------------------------------------------------------------------

CypherParser::KU_StructFieldContext::KU_StructFieldContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_StructFieldContext::COLON() {
  return getToken(CypherParser::COLON, 0);
}

CypherParser::OC_ExpressionContext* CypherParser::KU_StructFieldContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_StructFieldContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_StructFieldContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_StructFieldContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_StructFieldContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_StructFieldContext::getRuleIndex() const {
  return CypherParser::RuleKU_StructField;
}


CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() {
  KU_StructFieldContext *_localctx = _tracker.createInstance<KU_StructFieldContext>(_ctx, getState());
  enterRule(_localctx, 248, CypherParser::RuleKU_StructField);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2095);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::IN:
      case CypherParser::COUNT:
      case CypherParser::END:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2093);
        oC_SymbolicName();
        break;
      }

      case CypherParser::StringLiteral: {
        setState(2094);
        match(CypherParser::StringLiteral);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2098);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2097);
      match(CypherParser::SP);
    }
    setState(2100);
    match(CypherParser::COLON);
    setState(2102);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2101);
      match(CypherParser::SP);
    }
    setState(2104);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_ParenthesizedExpressionContext ------------------------------------------------------------------

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, 250, 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(2106);
    match(CypherParser::T__1);
    setState(2108);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2107);
      match(CypherParser::SP);
    }
    setState(2110);
    oC_Expression();
    setState(2112);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2111);
      match(CypherParser::SP);
    }
    setState(2114);
    match(CypherParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_FunctionInvocationContext ------------------------------------------------------------------

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);
}

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);
}

std::vector<CypherParser::KU_FunctionParameterContext *> CypherParser::OC_FunctionInvocationContext::kU_FunctionParameter() {
  return getRuleContexts<CypherParser::KU_FunctionParameterContext>();
}

CypherParser::KU_FunctionParameterContext* CypherParser::OC_FunctionInvocationContext::kU_FunctionParameter(size_t i) {
  return getRuleContext<CypherParser::KU_FunctionParameterContext>(i);
}


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, 252, CypherParser::RuleOC_FunctionInvocation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2164);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 364, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2116);
      match(CypherParser::COUNT);
      setState(2118);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2117);
        match(CypherParser::SP);
      }
      setState(2120);
      match(CypherParser::T__1);
      setState(2122);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2121);
        match(CypherParser::SP);
      }
      setState(2124);
      match(CypherParser::STAR);
      setState(2126);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2125);
        match(CypherParser::SP);
      }
      setState(2128);
      match(CypherParser::T__3);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2129);
      oC_FunctionName();
      setState(2131);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2130);
        match(CypherParser::SP);
      }
      setState(2133);
      match(CypherParser::T__1);
      setState(2135);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2134);
        match(CypherParser::SP);
      }
      setState(2141);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::DISTINCT) {
        setState(2137);
        match(CypherParser::DISTINCT);
        setState(2139);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2138);
          match(CypherParser::SP);
        }
      }
      setState(2160);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 1082271285519581828) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 70)) & -4681139968930742255) != 0) || ((((_la - 136) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 136)) & 9741) != 0)) {
        setState(2143);
        kU_FunctionParameter();
        setState(2145);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2144);
          match(CypherParser::SP);
        }
        setState(2157);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__2) {
          setState(2147);
          match(CypherParser::T__2);
          setState(2149);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2148);
            match(CypherParser::SP);
          }
          setState(2151);
          kU_FunctionParameter();
          setState(2153);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2152);
            match(CypherParser::SP);
          }
          setState(2159);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(2162);
      match(CypherParser::T__3);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_FunctionNameContext ------------------------------------------------------------------

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, 254, CypherParser::RuleOC_FunctionName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2166);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_FunctionParameterContext ------------------------------------------------------------------

CypherParser::KU_FunctionParameterContext::KU_FunctionParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_ExpressionContext* CypherParser::KU_FunctionParameterContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}

CypherParser::OC_SymbolicNameContext* CypherParser::KU_FunctionParameterContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* CypherParser::KU_FunctionParameterContext::COLON() {
  return getToken(CypherParser::COLON, 0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_FunctionParameterContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_FunctionParameterContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::KU_FunctionParameterContext::getRuleIndex() const {
  return CypherParser::RuleKU_FunctionParameter;
}


CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() {
  KU_FunctionParameterContext *_localctx = _tracker.createInstance<KU_FunctionParameterContext>(_ctx, getState());
  enterRule(_localctx, 256, CypherParser::RuleKU_FunctionParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2177);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 367, _ctx)) {
    case 1: {
      setState(2168);
      oC_SymbolicName();
      setState(2170);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2169);
        match(CypherParser::SP);
      }
      setState(2172);
      match(CypherParser::COLON);
      setState(2173);
      match(CypherParser::T__5);
      setState(2175);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2174);
        match(CypherParser::SP);
      }
      break;
    }

    default:
      break;
    }
    setState(2179);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PathPatternsContext ------------------------------------------------------------------

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, 258, 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(2181);
    oC_NodePattern();
    setState(2186); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2183);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == CypherParser::SP) {
                setState(2182);
                match(CypherParser::SP);
              }
              setState(2185);
              oC_PatternElementChain();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(2188); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _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;
}

//----------------- OC_ExistSubqueryContext ------------------------------------------------------------------

CypherParser::OC_ExistSubqueryContext::OC_ExistSubqueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::OC_ExistSubqueryContext::EXISTS() {
  return getToken(CypherParser::EXISTS, 0);
}

tree::TerminalNode* CypherParser::OC_ExistSubqueryContext::MATCH() {
  return getToken(CypherParser::MATCH, 0);
}

CypherParser::OC_PatternContext* CypherParser::OC_ExistSubqueryContext::oC_Pattern() {
  return getRuleContext<CypherParser::OC_PatternContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::OC_ExistSubqueryContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::OC_ExistSubqueryContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_WhereContext* CypherParser::OC_ExistSubqueryContext::oC_Where() {
  return getRuleContext<CypherParser::OC_WhereContext>(0);
}


size_t CypherParser::OC_ExistSubqueryContext::getRuleIndex() const {
  return CypherParser::RuleOC_ExistSubquery;
}


CypherParser::OC_ExistSubqueryContext* CypherParser::oC_ExistSubquery() {
  OC_ExistSubqueryContext *_localctx = _tracker.createInstance<OC_ExistSubqueryContext>(_ctx, getState());
  enterRule(_localctx, 260, CypherParser::RuleOC_ExistSubquery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2190);
    match(CypherParser::EXISTS);
    setState(2192);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2191);
      match(CypherParser::SP);
    }
    setState(2194);
    match(CypherParser::T__8);
    setState(2196);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2195);
      match(CypherParser::SP);
    }
    setState(2198);
    match(CypherParser::MATCH);
    setState(2200);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2199);
      match(CypherParser::SP);
    }
    setState(2202);
    oC_Pattern();
    setState(2207);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 374, _ctx)) {
    case 1: {
      setState(2204);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2203);
        match(CypherParser::SP);
      }
      setState(2206);
      oC_Where();
      break;
    }

    default:
      break;
    }
    setState(2210);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2209);
      match(CypherParser::SP);
    }
    setState(2212);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CountSubqueryContext ------------------------------------------------------------------

CypherParser::KU_CountSubqueryContext::KU_CountSubqueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_CountSubqueryContext::COUNT() {
  return getToken(CypherParser::COUNT, 0);
}

tree::TerminalNode* CypherParser::KU_CountSubqueryContext::MATCH() {
  return getToken(CypherParser::MATCH, 0);
}

CypherParser::OC_PatternContext* CypherParser::KU_CountSubqueryContext::oC_Pattern() {
  return getRuleContext<CypherParser::OC_PatternContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::KU_CountSubqueryContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::KU_CountSubqueryContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::OC_WhereContext* CypherParser::KU_CountSubqueryContext::oC_Where() {
  return getRuleContext<CypherParser::OC_WhereContext>(0);
}


size_t CypherParser::KU_CountSubqueryContext::getRuleIndex() const {
  return CypherParser::RuleKU_CountSubquery;
}


CypherParser::KU_CountSubqueryContext* CypherParser::kU_CountSubquery() {
  KU_CountSubqueryContext *_localctx = _tracker.createInstance<KU_CountSubqueryContext>(_ctx, getState());
  enterRule(_localctx, 262, CypherParser::RuleKU_CountSubquery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2214);
    match(CypherParser::COUNT);
    setState(2216);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2215);
      match(CypherParser::SP);
    }
    setState(2218);
    match(CypherParser::T__8);
    setState(2220);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2219);
      match(CypherParser::SP);
    }
    setState(2222);
    match(CypherParser::MATCH);
    setState(2224);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2223);
      match(CypherParser::SP);
    }
    setState(2226);
    oC_Pattern();
    setState(2231);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 380, _ctx)) {
    case 1: {
      setState(2228);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2227);
        match(CypherParser::SP);
      }
      setState(2230);
      oC_Where();
      break;
    }

    default:
      break;
    }
    setState(2234);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2233);
      match(CypherParser::SP);
    }
    setState(2236);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertyLookupContext ------------------------------------------------------------------

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, 264, 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(2238);
    match(CypherParser::T__4);
    setState(2240);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2239);
      match(CypherParser::SP);
    }
    setState(2244);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::IN:
      case CypherParser::COUNT:
      case CypherParser::END:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2242);
        oC_PropertyKeyName();
        break;
      }

      case CypherParser::STAR: {
        setState(2243);
        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;
}

//----------------- OC_CaseExpressionContext ------------------------------------------------------------------

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, 266, 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(2268);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 389, _ctx)) {
    case 1: {
      setState(2246);
      match(CypherParser::CASE);
      setState(2251); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2248);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(2247);
                  match(CypherParser::SP);
                }
                setState(2250);
                oC_CaseAlternative();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(2253); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 385, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 2: {
      setState(2255);
      match(CypherParser::CASE);
      setState(2257);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2256);
        match(CypherParser::SP);
      }
      setState(2259);
      oC_Expression();
      setState(2264); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2261);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(2260);
                  match(CypherParser::SP);
                }
                setState(2263);
                oC_CaseAlternative();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(2266); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 388, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    default:
      break;
    }
    setState(2278);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 392, _ctx)) {
    case 1: {
      setState(2271);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2270);
        match(CypherParser::SP);
      }
      setState(2273);
      match(CypherParser::ELSE);
      setState(2275);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2274);
        match(CypherParser::SP);
      }
      setState(2277);
      oC_Expression();
      break;
    }

    default:
      break;
    }
    setState(2281);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2280);
      match(CypherParser::SP);
    }
    setState(2283);
    match(CypherParser::END);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_CaseAlternativeContext ------------------------------------------------------------------

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, 268, 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(2285);
    match(CypherParser::WHEN);
    setState(2287);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2286);
      match(CypherParser::SP);
    }
    setState(2289);
    oC_Expression();
    setState(2291);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2290);
      match(CypherParser::SP);
    }
    setState(2293);
    match(CypherParser::THEN);
    setState(2295);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2294);
      match(CypherParser::SP);
    }
    setState(2297);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_VariableContext ------------------------------------------------------------------

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, 270, CypherParser::RuleOC_Variable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2299);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_NumberLiteralContext ------------------------------------------------------------------

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, 272, CypherParser::RuleOC_NumberLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2303);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(2301);
        oC_DoubleLiteral();
        break;
      }

      case CypherParser::DecimalInteger: {
        enterOuterAlt(_localctx, 2);
        setState(2302);
        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;
}

//----------------- OC_ParameterContext ------------------------------------------------------------------

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, 274, CypherParser::RuleOC_Parameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2305);
    match(CypherParser::T__25);
    setState(2308);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::IN:
      case CypherParser::COUNT:
      case CypherParser::END:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2306);
        oC_SymbolicName();
        break;
      }

      case CypherParser::DecimalInteger: {
        setState(2307);
        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;
}

//----------------- OC_PropertyExpressionContext ------------------------------------------------------------------

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, 276, 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(2310);
    oC_Atom();
    setState(2312);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2311);
      match(CypherParser::SP);
    }
    setState(2314);
    oC_PropertyLookup();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_PropertyKeyNameContext ------------------------------------------------------------------

CypherParser::OC_PropertyKeyNameContext::OC_PropertyKeyNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_SchemaNameContext* CypherParser::OC_PropertyKeyNameContext::oC_SchemaName() {
  return getRuleContext<CypherParser::OC_SchemaNameContext>(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, 278, CypherParser::RuleOC_PropertyKeyName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2316);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_IntegerLiteralContext ------------------------------------------------------------------

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, 280, CypherParser::RuleOC_IntegerLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2318);
    match(CypherParser::DecimalInteger);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_DoubleLiteralContext ------------------------------------------------------------------

CypherParser::OC_DoubleLiteralContext::OC_DoubleLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

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, 282, CypherParser::RuleOC_DoubleLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2320);
    match(CypherParser::RegularDecimalReal);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SchemaNameContext ------------------------------------------------------------------

CypherParser::OC_SchemaNameContext::OC_SchemaNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_SymbolicNameContext* CypherParser::OC_SchemaNameContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}


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, 284, CypherParser::RuleOC_SchemaName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2322);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_SymbolicNameContext ------------------------------------------------------------------

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::KU_NonReservedKeywordsContext* CypherParser::OC_SymbolicNameContext::kU_NonReservedKeywords() {
  return getRuleContext<CypherParser::KU_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, 286, CypherParser::RuleOC_SymbolicName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2329);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::UnescapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(2324);
        match(CypherParser::UnescapedSymbolicName);
        break;
      }

      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 2);
        setState(2325);
        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(2327);
        match(CypherParser::HexLetter);
        break;
      }

      case CypherParser::USE:
      case CypherParser::COMMENT_:
      case CypherParser::EXPORT:
      case CypherParser::IMPORT:
      case CypherParser::DATABASE:
      case CypherParser::NODE:
      case CypherParser::REL:
      case CypherParser::BEGIN:
      case CypherParser::IN:
      case CypherParser::COUNT:
      case CypherParser::END: {
        enterOuterAlt(_localctx, 4);
        setState(2328);
        kU_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;
}

//----------------- KU_NonReservedKeywordsContext ------------------------------------------------------------------

CypherParser::KU_NonReservedKeywordsContext::KU_NonReservedKeywordsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::COMMENT_() {
  return getToken(CypherParser::COMMENT_, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::COUNT() {
  return getToken(CypherParser::COUNT, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::NODE() {
  return getToken(CypherParser::NODE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::REL() {
  return getToken(CypherParser::REL, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::BEGIN() {
  return getToken(CypherParser::BEGIN, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::END() {
  return getToken(CypherParser::END, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::IN() {
  return getToken(CypherParser::IN, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::IMPORT() {
  return getToken(CypherParser::IMPORT, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::EXPORT() {
  return getToken(CypherParser::EXPORT, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::DATABASE() {
  return getToken(CypherParser::DATABASE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::USE() {
  return getToken(CypherParser::USE, 0);
}


size_t CypherParser::KU_NonReservedKeywordsContext::getRuleIndex() const {
  return CypherParser::RuleKU_NonReservedKeywords;
}


CypherParser::KU_NonReservedKeywordsContext* CypherParser::kU_NonReservedKeywords() {
  KU_NonReservedKeywordsContext *_localctx = _tracker.createInstance<KU_NonReservedKeywordsContext>(_ctx, getState());
  enterRule(_localctx, 288, CypherParser::RuleKU_NonReservedKeywords);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2331);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1082271285452472320) != 0) || ((((_la - 70) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 70)) & -8644659484737667055) != 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;
}

//----------------- OC_LeftArrowHeadContext ------------------------------------------------------------------

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, 290, 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(2333);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 2013282304) != 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;
}

//----------------- OC_RightArrowHeadContext ------------------------------------------------------------------

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, 292, 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(2335);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 32212320256) != 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;
}

//----------------- OC_DashContext ------------------------------------------------------------------

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, 294, 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(2337);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 70334384439296) != 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 36: return kU_DataTypeSempred(antlrcpp::downCast<KU_DataTypeContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool CypherParser::kU_DataTypeSempred(KU_DataTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 4);

  default:
    break;
  }
  return true;
}

void CypherParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  cypherParserInitialize();
#else
  ::antlr4::internal::call_once(cypherParserOnceFlag, cypherParserInitialize);
#endif
}
