
// 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_Option", "kU_Options", 
      "kU_DetachDatabase", "kU_UseDatabase", "kU_StandaloneCall", "kU_CommentOn", 
      "kU_CreateMacro", "kU_PositionalArgs", "kU_DefaultArg", "kU_FilePaths", 
      "kU_IfNotExists", "kU_CreateNodeTable", "kU_CreateRelTable", "kU_FromToConnections", 
      "kU_FromToConnection", "kU_CreateSequence", "kU_CreateType", "kU_SequenceOptions", 
      "kU_CreateUser", "kU_IncrementBy", "kU_MinValue", "kU_MaxValue", "kU_StartWith", 
      "kU_Cycle", "kU_IfExists", "kU_Drop", "kU_AlterTable", "kU_AlterOptions", 
      "kU_AddProperty", "kU_Default", "kU_DropProperty", "kU_RenameTable", 
      "kU_RenameProperty", "kU_AddFromToConnection", "kU_DropFromToConnection", 
      "kU_ColumnDefinitions", "kU_ColumnDefinition", "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", "kU_UninstallExtension", "kU_UpdateExtension", 
      "oC_Query", "oC_RegularQuery", "oC_Union", "oC_SingleQuery", "oC_SinglePartQuery", 
      "oC_MultiPartQuery", "kU_QueryPart", "oC_UpdatingClause", "oC_ReadingClause", 
      "kU_LoadFrom", "oC_YieldItem", "oC_YieldItems", "kU_InQueryCall", 
      "oC_Match", "kU_Hint", "kU_JoinNode", "oC_Unwind", "oC_Create", "oC_Merge", 
      "oC_MergeAction", "oC_Set", "oC_SetItem", "oC_Delete", "oC_With", 
      "oC_Return", "oC_ProjectionBody", "oC_ProjectionItems", "oC_ProjectionItem", 
      "oC_Order", "oC_Skip", "oC_Limit", "oC_SortItem", "oC_Where", "oC_Pattern", 
      "oC_PatternPart", "oC_AnonymousPatternPart", "oC_PatternElement", 
      "oC_NodePattern", "oC_PatternElementChain", "oC_RelationshipPattern", 
      "oC_RelationshipDetail", "kU_Properties", "oC_RelationshipTypes", 
      "oC_NodeLabels", "oC_NodeLabel", "kU_RecursiveDetail", "kU_RecursiveType", 
      "oC_RangeLiteral", "kU_RecursiveComprehension", "kU_RecursiveProjectionItems", 
      "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_StringListNullOperatorExpression", "oC_ListOperatorExpression", 
      "oC_StringOperatorExpression", "oC_RegularExpression", "oC_NullOperatorExpression", 
      "oC_UnaryAddSubtractOrFactorialExpression", "oC_PropertyOrLabelsExpression", 
      "oC_Atom", "oC_Quantifier", "oC_FilterExpression", "oC_IdInColl", 
      "oC_Literal", "oC_BooleanLiteral", "oC_ListLiteral", "kU_ListEntry", 
      "kU_StructLiteral", "kU_StructField", "oC_ParenthesizedExpression", 
      "oC_FunctionInvocation", "oC_FunctionName", "kU_FunctionParameter", 
      "kU_LambdaParameter", "kU_LambdaVars", "oC_PathPatterns", "oC_ExistCountSubquery", 
      "oC_PropertyLookup", "oC_CaseExpression", "oC_CaseAlternative", "oC_Variable", 
      "oC_NumberLiteral", "oC_Parameter", "oC_PropertyExpression", "oC_PropertyKeyName", 
      "oC_IntegerLiteral", "oC_DoubleLiteral", "oC_SchemaName", "oC_SymbolicName", 
      "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>{
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "ACYCLIC", "ANY", 
      "ADD", "ALL", "ALTER", "AND", "AS", "ASC", "ASCENDING", "ATTACH", 
      "BEGIN", "BY", "CALL", "CASE", "CAST", "CHECKPOINT", "COLUMN", "COMMENT", 
      "COMMIT", "COMMIT_SKIP_CHECKPOINT", "CONTAINS", "COPY", "COUNT", "CREATE", 
      "CYCLE", "DATABASE", "DBTYPE", "DEFAULT", "DELETE", "DESC", "DESCENDING", 
      "DETACH", "DISTINCT", "DROP", "ELSE", "END", "ENDS", "EXISTS", "EXPLAIN", 
      "EXPORT", "EXTENSION", "FALSE", "FROM", "FORCE", "GLOB", "GRAPH", 
      "GROUP", "HEADERS", "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", 
      "IS", "JOIN", "KEY", "LIMIT", "LOAD", "LOGICAL", "MACRO", "MATCH", 
      "MAXVALUE", "MERGE", "MINVALUE", "MULTI_JOIN", "NO", "NODE", "NOT", 
      "NONE", "NULL", "ON", "ONLY", "OPTIONAL", "OR", "ORDER", "PRIMARY", 
      "PROFILE", "PROJECT", "READ", "REL", "RENAME", "RETURN", "ROLLBACK", 
      "ROLLBACK_SKIP_CHECKPOINT", "SEQUENCE", "SET", "SHORTEST", "START", 
      "STARTS", "STRUCT", "TABLE", "THEN", "TO", "TRAIL", "TRANSACTION", 
      "TRUE", "TYPE", "UNION", "UNWIND", "UNINSTALL", "UPDATE", "USE", "WHEN", 
      "WHERE", "WITH", "WRITE", "WSHORTEST", "XOR", "SINGLE", "YIELD", "USER", 
      "DECIMAL", "STAR", "L_SKIP", "INVALID_NOT_EQUAL", "COLON", "MINUS", 
      "FACTORIAL", "StringLiteral", "EscapedChar", "DecimalInteger", "HexLetter", 
      "HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", "ZeroDigit", 
      "ExponentDecimalReal", "RegularDecimalReal", "UnescapedSymbolicName", 
      "IdentifierStart", "IdentifierPart", "EscapedSymbolicName", "SP", 
      "WHITESPACE", "CypherComment", "Unknown"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,183,2864,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
  	2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
  	7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
  	7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
  	7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
  	7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
  	7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
  	7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
  	7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
  	7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
  	7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
  	7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
  	7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
  	7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
  	7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,
  	7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,
  	7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,
  	7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122,
  	7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128,
  	7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134,
  	7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,
  	7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,
  	7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,
  	7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,
  	7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
  	7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170,
  	7,170,2,171,7,171,2,172,7,172,2,173,7,173,1,0,1,0,3,0,351,8,0,1,0,1,0,
  	3,0,355,8,0,1,0,5,0,358,8,0,10,0,12,0,361,9,0,1,0,3,0,364,8,0,1,0,1,0,
  	1,1,3,1,369,8,1,1,1,3,1,372,8,1,1,1,1,1,3,1,376,8,1,1,1,3,1,379,8,1,1,
  	2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
  	1,2,1,2,1,2,3,2,402,8,2,1,3,1,3,1,3,1,3,3,3,408,8,3,1,3,1,3,1,3,1,3,1,
  	3,3,3,415,8,3,1,3,1,3,3,3,419,8,3,1,3,1,3,3,3,423,8,3,1,3,1,3,3,3,427,
  	8,3,1,4,3,4,430,8,4,1,4,1,4,3,4,434,8,4,1,4,1,4,3,4,438,8,4,1,4,1,4,3,
  	4,442,8,4,1,4,5,4,445,8,4,10,4,12,4,448,9,4,1,4,3,4,451,8,4,3,4,453,8,
  	4,1,4,1,4,1,5,1,5,1,5,3,5,460,8,5,1,5,1,5,3,5,464,8,5,1,5,1,5,1,5,1,5,
  	1,5,1,5,1,5,3,5,473,8,5,1,5,1,5,1,5,3,5,478,8,5,1,6,1,6,1,6,1,6,1,6,1,
  	6,1,6,1,6,3,6,488,8,6,1,6,1,6,3,6,492,8,6,1,6,1,6,3,6,496,8,6,1,6,5,6,
  	499,8,6,10,6,12,6,502,9,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,3,7,
  	514,8,7,1,7,1,7,3,7,518,8,7,1,7,1,7,1,7,1,7,1,7,1,7,3,7,526,8,7,1,7,1,
  	7,3,7,530,8,7,1,7,1,7,3,7,534,8,7,1,7,1,7,3,7,538,8,7,1,8,1,8,1,8,1,8,
  	1,8,1,8,3,8,546,8,8,1,8,1,8,3,8,550,8,8,1,8,1,8,3,8,554,8,8,1,8,1,8,3,
  	8,558,8,8,1,9,1,9,1,9,1,9,1,9,1,9,1,10,1,10,1,10,1,10,1,10,1,10,1,10,
  	3,10,573,8,10,1,10,1,10,1,10,3,10,578,8,10,1,10,1,10,1,10,1,10,3,10,584,
  	8,10,1,10,1,10,3,10,588,8,10,1,10,3,10,591,8,10,1,10,3,10,594,8,10,1,
  	10,1,10,1,11,1,11,3,11,600,8,11,1,11,1,11,3,11,604,8,11,1,11,5,11,607,
  	8,11,10,11,12,11,610,9,11,3,11,612,8,11,1,11,1,11,1,11,3,11,617,8,11,
  	1,12,1,12,3,12,621,8,12,1,12,1,12,3,12,625,8,12,1,12,5,12,628,8,12,10,
  	12,12,12,631,9,12,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15,1,
  	15,1,15,3,15,645,8,15,1,15,1,15,3,15,649,8,15,1,15,1,15,1,15,1,15,1,15,
  	3,15,656,8,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,
  	1,16,1,17,1,17,1,17,1,17,1,17,1,17,3,17,676,8,17,1,17,1,17,3,17,680,8,
  	17,1,17,3,17,683,8,17,1,17,3,17,686,8,17,1,17,3,17,689,8,17,1,17,3,17,
  	692,8,17,1,17,1,17,3,17,696,8,17,1,17,5,17,699,8,17,10,17,12,17,702,9,
  	17,1,17,3,17,705,8,17,1,17,1,17,1,17,1,17,1,17,1,17,1,18,1,18,3,18,715,
  	8,18,1,18,1,18,3,18,719,8,18,1,18,5,18,722,8,18,10,18,12,18,725,9,18,
  	1,19,1,19,3,19,729,8,19,1,19,1,19,1,19,3,19,734,8,19,1,19,1,19,1,20,1,
  	20,3,20,740,8,20,1,20,1,20,3,20,744,8,20,1,20,1,20,3,20,748,8,20,1,20,
  	5,20,751,8,20,10,20,12,20,754,9,20,1,20,1,20,1,20,1,20,3,20,760,8,20,
  	1,20,1,20,3,20,764,8,20,1,20,1,20,3,20,768,8,20,1,20,3,20,771,8,20,1,
  	21,1,21,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,22,1,
  	22,3,22,788,8,22,1,22,1,22,3,22,792,8,22,1,22,1,22,3,22,796,8,22,1,22,
  	1,22,3,22,800,8,22,1,22,1,22,3,22,804,8,22,1,22,3,22,807,8,22,1,22,3,
  	22,810,8,22,1,22,1,22,1,22,1,22,1,22,1,22,3,22,818,8,22,1,23,1,23,1,23,
  	1,23,1,23,1,23,1,23,3,23,827,8,23,1,23,1,23,3,23,831,8,23,1,23,1,23,1,
  	23,3,23,836,8,23,1,23,1,23,3,23,840,8,23,1,23,1,23,3,23,844,8,23,1,23,
  	1,23,3,23,848,8,23,1,23,1,23,3,23,852,8,23,3,23,854,8,23,1,23,1,23,3,
  	23,858,8,23,1,23,1,23,3,23,862,8,23,3,23,864,8,23,1,23,1,23,1,23,1,23,
  	1,23,1,23,3,23,872,8,23,1,23,1,23,1,23,3,23,877,8,23,1,23,1,23,3,23,881,
  	8,23,1,23,1,23,3,23,885,8,23,1,23,1,23,3,23,889,8,23,1,24,1,24,3,24,893,
  	8,24,1,24,1,24,3,24,897,8,24,1,24,5,24,900,8,24,10,24,12,24,903,9,24,
  	1,25,1,25,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,26,3,26,920,8,26,1,26,1,26,1,26,5,26,925,8,26,10,26,12,26,928,9,26,
  	1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,3,27,940,8,27,1,28,
  	1,28,1,28,1,28,1,28,3,28,947,8,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,
  	3,29,956,8,29,1,29,1,29,1,30,1,30,1,30,1,30,3,30,964,8,30,1,30,3,30,967,
  	8,30,1,30,1,30,1,31,1,31,1,31,1,31,1,31,1,31,3,31,977,8,31,1,31,3,31,
  	980,8,31,1,32,1,32,1,32,1,32,1,32,1,32,3,32,988,8,32,1,32,3,32,991,8,
  	32,1,33,1,33,1,33,1,33,3,33,997,8,33,1,33,3,33,1000,8,33,1,33,1,33,1,
  	34,1,34,3,34,1006,8,34,1,34,1,34,1,35,1,35,1,35,1,35,1,36,1,36,1,36,1,
  	36,1,36,1,36,1,36,3,36,1021,8,36,1,36,1,36,1,37,1,37,1,37,1,37,1,37,1,
  	37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,38,3,38,1039,8,38,1,39,1,39,1,
  	39,1,39,1,39,3,39,1046,8,39,1,39,1,39,1,39,1,39,1,39,3,39,1053,8,39,1,
  	40,1,40,1,40,1,40,1,41,1,41,1,41,1,41,1,41,3,41,1064,8,41,1,41,1,41,1,
  	42,1,42,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,43,1,
  	44,1,44,1,44,1,44,1,44,3,44,1087,8,44,1,44,1,44,1,45,1,45,1,45,1,45,1,
  	45,3,45,1096,8,45,1,45,1,45,1,46,1,46,3,46,1102,8,46,1,46,1,46,3,46,1106,
  	8,46,1,46,5,46,1109,8,46,10,46,12,46,1112,9,46,1,47,1,47,1,47,1,47,1,
  	48,1,48,3,48,1120,8,48,1,48,1,48,3,48,1124,8,48,1,48,5,48,1127,8,48,10,
  	48,12,48,1130,9,48,1,49,1,49,1,49,3,49,1135,8,49,1,49,1,49,1,49,1,49,
  	3,49,1141,8,49,1,50,1,50,1,50,1,50,3,50,1147,8,50,1,50,1,50,3,50,1151,
  	8,50,1,50,1,50,3,50,1155,8,50,1,50,1,50,1,51,1,51,1,51,1,51,3,51,1163,
  	8,51,1,51,1,51,3,51,1167,8,51,1,51,1,51,3,51,1171,8,51,1,51,1,51,1,51,
  	1,51,3,51,1177,8,51,1,51,1,51,3,51,1181,8,51,1,51,1,51,3,51,1185,8,51,
  	1,51,1,51,1,51,1,51,3,51,1191,8,51,1,51,1,51,3,51,1195,8,51,1,51,1,51,
  	3,51,1199,8,51,1,51,1,51,1,51,1,51,3,51,1205,8,51,1,51,1,51,3,51,1209,
  	8,51,1,51,1,51,3,51,1213,8,51,1,51,1,51,3,51,1217,8,51,1,51,1,51,3,51,
  	1221,8,51,1,51,1,51,1,51,1,51,3,51,1227,8,51,1,51,1,51,3,51,1231,8,51,
  	1,51,1,51,3,51,1235,8,51,1,51,1,51,3,51,1239,8,51,1,51,1,51,3,51,1243,
  	8,51,1,51,1,51,3,51,1247,8,51,1,51,1,51,5,51,1251,8,51,10,51,12,51,1254,
  	9,51,1,52,1,52,5,52,1258,8,52,10,52,12,52,1261,9,52,1,53,1,53,3,53,1265,
  	8,53,1,53,1,53,1,54,1,54,3,54,1271,8,54,1,55,1,55,1,55,3,55,1276,8,55,
  	1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,1,57,
  	1,57,3,57,1293,8,57,1,58,1,58,1,58,1,58,3,58,1299,8,58,1,59,1,59,1,59,
  	1,59,3,59,1305,8,59,1,59,1,59,3,59,1309,8,59,1,60,1,60,3,60,1313,8,60,
  	1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,1322,8,60,1,61,1,61,1,61,1,61,
  	1,62,1,62,1,62,1,62,1,63,1,63,1,64,1,64,3,64,1336,8,64,1,64,5,64,1339,
  	8,64,10,64,12,64,1342,9,64,1,64,1,64,3,64,1346,8,64,4,64,1348,8,64,11,
  	64,12,64,1349,1,64,1,64,1,64,3,64,1355,8,64,1,65,1,65,1,65,1,65,3,65,
  	1361,8,65,1,65,1,65,1,65,3,65,1366,8,65,1,65,3,65,1369,8,65,1,66,1,66,
  	3,66,1373,8,66,1,67,1,67,3,67,1377,8,67,5,67,1379,8,67,10,67,12,67,1382,
  	9,67,1,67,1,67,1,67,3,67,1387,8,67,5,67,1389,8,67,10,67,12,67,1392,9,
  	67,1,67,1,67,3,67,1396,8,67,1,67,5,67,1399,8,67,10,67,12,67,1402,9,67,
  	1,67,3,67,1405,8,67,1,67,3,67,1408,8,67,3,67,1410,8,67,1,68,1,68,3,68,
  	1414,8,68,4,68,1416,8,68,11,68,12,68,1417,1,68,1,68,1,69,1,69,3,69,1424,
  	8,69,5,69,1426,8,69,10,69,12,69,1429,9,69,1,69,1,69,3,69,1433,8,69,5,
  	69,1435,8,69,10,69,12,69,1438,9,69,1,69,1,69,1,70,1,70,1,70,1,70,3,70,
  	1446,8,70,1,71,1,71,1,71,1,71,3,71,1452,8,71,1,72,1,72,1,72,1,72,1,72,
  	1,72,3,72,1460,8,72,1,72,1,72,3,72,1464,8,72,1,72,1,72,3,72,1468,8,72,
  	1,72,1,72,3,72,1472,8,72,1,72,1,72,1,72,1,72,1,72,3,72,1479,8,72,1,72,
  	1,72,3,72,1483,8,72,1,72,1,72,3,72,1487,8,72,1,72,1,72,3,72,1491,8,72,
  	1,72,3,72,1494,8,72,1,72,3,72,1497,8,72,1,73,1,73,1,73,1,73,1,73,3,73,
  	1504,8,73,1,73,1,73,1,74,1,74,3,74,1510,8,74,1,74,1,74,3,74,1514,8,74,
  	1,74,5,74,1517,8,74,10,74,12,74,1520,9,74,1,75,1,75,1,75,1,75,3,75,1526,
  	8,75,1,75,3,75,1529,8,75,1,75,3,75,1532,8,75,1,75,1,75,1,75,3,75,1537,
  	8,75,1,76,1,76,3,76,1541,8,76,1,76,1,76,3,76,1545,8,76,1,76,1,76,1,76,
  	3,76,1550,8,76,1,76,1,76,3,76,1554,8,76,1,77,1,77,1,77,1,77,1,78,1,78,
  	1,78,3,78,1563,8,78,1,78,1,78,3,78,1567,8,78,1,78,1,78,1,78,3,78,1572,
  	8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,4,78,1584,8,78,
  	11,78,12,78,1585,5,78,1588,8,78,10,78,12,78,1591,9,78,1,79,1,79,3,79,
  	1595,8,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1,80,3,80,1605,8,80,1,80,
  	1,80,1,81,1,81,3,81,1611,8,81,1,81,1,81,1,81,5,81,1616,8,81,10,81,12,
  	81,1619,9,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1631,
  	8,82,1,83,1,83,3,83,1635,8,83,1,83,1,83,3,83,1639,8,83,1,83,1,83,3,83,
  	1643,8,83,1,83,5,83,1646,8,83,10,83,12,83,1649,9,83,1,84,1,84,3,84,1653,
  	8,84,1,84,1,84,3,84,1657,8,84,1,84,1,84,1,85,1,85,3,85,1663,8,85,1,85,
  	1,85,3,85,1667,8,85,1,85,1,85,3,85,1671,8,85,1,85,1,85,3,85,1675,8,85,
  	1,85,5,85,1678,8,85,10,85,12,85,1681,9,85,1,86,1,86,1,86,3,86,1686,8,
  	86,1,86,3,86,1689,8,86,1,87,1,87,1,87,1,88,3,88,1695,8,88,1,88,3,88,1698,
  	8,88,1,88,1,88,1,88,1,88,3,88,1704,8,88,1,88,1,88,3,88,1708,8,88,1,88,
  	1,88,3,88,1712,8,88,1,89,1,89,3,89,1716,8,89,1,89,1,89,3,89,1720,8,89,
  	1,89,5,89,1723,8,89,10,89,12,89,1726,9,89,1,89,1,89,3,89,1730,8,89,1,
  	89,1,89,3,89,1734,8,89,1,89,5,89,1737,8,89,10,89,12,89,1740,9,89,3,89,
  	1742,8,89,1,90,1,90,1,90,1,90,1,90,1,90,1,90,3,90,1751,8,90,1,91,1,91,
  	1,91,1,91,1,91,1,91,1,91,3,91,1760,8,91,1,91,5,91,1763,8,91,10,91,12,
  	91,1766,9,91,1,92,1,92,1,92,1,92,1,93,1,93,1,93,1,93,1,94,1,94,3,94,1778,
  	8,94,1,94,3,94,1781,8,94,1,95,1,95,1,95,1,95,1,96,1,96,3,96,1789,8,96,
  	1,96,1,96,3,96,1793,8,96,1,96,5,96,1796,8,96,10,96,12,96,1799,9,96,1,
  	97,1,97,3,97,1803,8,97,1,97,1,97,3,97,1807,8,97,1,97,1,97,1,97,3,97,1812,
  	8,97,1,98,1,98,1,99,1,99,3,99,1818,8,99,1,99,5,99,1821,8,99,10,99,12,
  	99,1824,9,99,1,99,1,99,1,99,1,99,3,99,1830,8,99,1,100,1,100,3,100,1834,
  	8,100,1,100,1,100,3,100,1838,8,100,3,100,1840,8,100,1,100,1,100,3,100,
  	1844,8,100,3,100,1846,8,100,1,100,1,100,3,100,1850,8,100,3,100,1852,8,
  	100,1,100,1,100,1,101,1,101,3,101,1858,8,101,1,101,1,101,1,102,1,102,
  	3,102,1864,8,102,1,102,1,102,3,102,1868,8,102,1,102,3,102,1871,8,102,
  	1,102,3,102,1874,8,102,1,102,1,102,1,102,1,102,3,102,1880,8,102,1,102,
  	3,102,1883,8,102,1,102,3,102,1886,8,102,1,102,1,102,3,102,1890,8,102,
  	1,102,1,102,1,102,1,102,3,102,1896,8,102,1,102,3,102,1899,8,102,1,102,
  	3,102,1902,8,102,1,102,1,102,3,102,1906,8,102,1,103,1,103,3,103,1910,
  	8,103,1,103,1,103,3,103,1914,8,103,3,103,1916,8,103,1,103,1,103,3,103,
  	1920,8,103,3,103,1922,8,103,1,103,1,103,3,103,1926,8,103,3,103,1928,8,
  	103,1,103,1,103,3,103,1932,8,103,3,103,1934,8,103,1,103,1,103,1,104,1,
  	104,3,104,1940,8,104,1,104,1,104,3,104,1944,8,104,1,104,1,104,3,104,1948,
  	8,104,1,104,1,104,3,104,1952,8,104,1,104,1,104,3,104,1956,8,104,1,104,
  	1,104,3,104,1960,8,104,1,104,1,104,3,104,1964,8,104,1,104,1,104,3,104,
  	1968,8,104,5,104,1970,8,104,10,104,12,104,1973,9,104,3,104,1975,8,104,
  	1,104,1,104,1,105,1,105,3,105,1981,8,105,1,105,1,105,3,105,1985,8,105,
  	1,105,1,105,3,105,1989,8,105,1,105,3,105,1992,8,105,1,105,5,105,1995,
  	8,105,10,105,12,105,1998,9,105,1,106,1,106,3,106,2002,8,106,1,106,5,106,
  	2005,8,106,10,106,12,106,2008,9,106,1,107,1,107,3,107,2012,8,107,1,107,
  	1,107,1,108,1,108,3,108,2018,8,108,1,108,3,108,2021,8,108,1,108,3,108,
  	2024,8,108,1,108,3,108,2027,8,108,1,108,3,108,2030,8,108,1,108,3,108,
  	2033,8,108,1,109,1,109,3,109,2037,8,109,1,109,1,109,3,109,2041,8,109,
  	1,109,1,109,3,109,2045,8,109,1,109,1,109,3,109,2049,8,109,1,109,1,109,
  	1,109,1,109,1,109,1,109,1,109,1,109,3,109,2059,8,109,1,110,3,110,2062,
  	8,110,1,110,3,110,2065,8,110,1,110,1,110,3,110,2069,8,110,1,110,3,110,
  	2072,8,110,1,110,3,110,2075,8,110,1,111,1,111,3,111,2079,8,111,1,111,
  	1,111,3,111,2083,8,111,1,111,1,111,3,111,2087,8,111,1,111,1,111,3,111,
  	2091,8,111,1,111,1,111,3,111,2095,8,111,1,111,1,111,3,111,2099,8,111,
  	3,111,2101,8,111,1,111,3,111,2104,8,111,1,111,1,111,3,111,2108,8,111,
  	1,111,1,111,3,111,2112,8,111,1,111,1,111,3,111,2116,8,111,1,111,1,111,
  	3,111,2120,8,111,3,111,2122,8,111,1,111,1,111,1,112,1,112,3,112,2128,
  	8,112,1,112,3,112,2131,8,112,1,112,3,112,2134,8,112,1,112,1,112,1,113,
  	1,113,1,114,1,114,1,115,1,115,1,116,1,116,1,117,1,117,1,118,1,118,1,118,
  	1,118,1,118,5,118,2153,8,118,10,118,12,118,2156,9,118,1,119,1,119,1,119,
  	1,119,1,119,5,119,2163,8,119,10,119,12,119,2166,9,119,1,120,1,120,1,120,
  	1,120,1,120,5,120,2173,8,120,10,120,12,120,2176,9,120,1,121,1,121,3,121,
  	2180,8,121,5,121,2182,8,121,10,121,12,121,2185,9,121,1,121,1,121,1,122,
  	1,122,3,122,2191,8,122,1,122,1,122,3,122,2195,8,122,1,122,1,122,3,122,
  	2199,8,122,1,122,1,122,3,122,2203,8,122,1,122,1,122,3,122,2207,8,122,
  	1,122,1,122,1,122,1,122,1,122,1,122,3,122,2215,8,122,1,122,1,122,3,122,
  	2219,8,122,1,122,1,122,3,122,2223,8,122,1,122,1,122,3,122,2227,8,122,
  	1,122,1,122,4,122,2231,8,122,11,122,12,122,2232,1,122,1,122,3,122,2237,
  	8,122,1,123,1,123,1,124,1,124,3,124,2243,8,124,1,124,1,124,3,124,2247,
  	8,124,1,124,5,124,2250,8,124,10,124,12,124,2253,9,124,1,125,1,125,3,125,
  	2257,8,125,1,125,1,125,3,125,2261,8,125,1,125,5,125,2264,8,125,10,125,
  	12,125,2267,9,125,1,126,1,126,3,126,2271,8,126,1,126,1,126,3,126,2275,
  	8,126,1,126,1,126,5,126,2279,8,126,10,126,12,126,2282,9,126,1,127,1,127,
  	1,128,1,128,3,128,2288,8,128,1,128,1,128,3,128,2292,8,128,1,128,1,128,
  	5,128,2296,8,128,10,128,12,128,2299,9,128,1,129,1,129,1,130,1,130,3,130,
  	2305,8,130,1,130,1,130,3,130,2309,8,130,1,130,1,130,5,130,2313,8,130,
  	10,130,12,130,2316,9,130,1,131,1,131,1,132,1,132,3,132,2322,8,132,1,132,
  	1,132,3,132,2326,8,132,1,132,5,132,2329,8,132,10,132,12,132,2332,9,132,
  	1,133,1,133,1,133,4,133,2337,8,133,11,133,12,133,2338,1,133,3,133,2342,
  	8,133,1,134,1,134,1,134,3,134,2347,8,134,1,134,1,134,1,134,1,134,1,134,
  	1,134,1,134,3,134,2356,8,134,1,134,1,134,3,134,2360,8,134,1,134,3,134,
  	2363,8,134,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,
  	1,135,3,135,2376,8,135,1,135,3,135,2379,8,135,1,135,1,135,1,136,3,136,
  	2384,8,136,1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,
  	1,137,1,137,3,137,2398,8,137,1,138,1,138,3,138,2402,8,138,5,138,2404,
  	8,138,10,138,12,138,2407,9,138,1,138,1,138,3,138,2411,8,138,1,138,3,138,
  	2414,8,138,1,139,1,139,3,139,2418,8,139,1,139,5,139,2421,8,139,10,139,
  	12,139,2424,9,139,1,140,1,140,1,140,1,140,1,140,1,140,1,140,1,140,1,140,
  	3,140,2435,8,140,1,141,1,141,3,141,2439,8,141,1,141,1,141,3,141,2443,
  	8,141,1,141,1,141,3,141,2447,8,141,1,141,1,141,1,141,1,141,3,141,2453,
  	8,141,1,141,1,141,3,141,2457,8,141,1,141,1,141,3,141,2461,8,141,1,141,
  	1,141,1,141,1,141,3,141,2467,8,141,1,141,1,141,3,141,2471,8,141,1,141,
  	1,141,3,141,2475,8,141,1,141,1,141,1,141,1,141,3,141,2481,8,141,1,141,
  	1,141,3,141,2485,8,141,1,141,1,141,3,141,2489,8,141,1,141,1,141,3,141,
  	2493,8,141,1,142,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,143,
  	1,144,1,144,1,144,1,144,1,144,1,144,3,144,2511,8,144,1,145,1,145,1,146,
  	1,146,3,146,2517,8,146,1,146,1,146,3,146,2521,8,146,1,146,1,146,3,146,
  	2525,8,146,5,146,2527,8,146,10,146,12,146,2530,9,146,3,146,2532,8,146,
  	1,146,1,146,1,147,1,147,3,147,2538,8,147,1,147,3,147,2541,8,147,1,148,
  	1,148,3,148,2545,8,148,1,148,1,148,3,148,2549,8,148,1,148,1,148,3,148,
  	2553,8,148,1,148,1,148,3,148,2557,8,148,5,148,2559,8,148,10,148,12,148,
  	2562,9,148,1,148,1,148,1,149,1,149,3,149,2568,8,149,1,149,3,149,2571,
  	8,149,1,149,1,149,3,149,2575,8,149,1,149,1,149,1,150,1,150,3,150,2581,
  	8,150,1,150,1,150,3,150,2585,8,150,1,150,1,150,1,151,1,151,3,151,2591,
  	8,151,1,151,1,151,3,151,2595,8,151,1,151,1,151,3,151,2599,8,151,1,151,
  	1,151,1,151,3,151,2604,8,151,1,151,1,151,3,151,2608,8,151,1,151,1,151,
  	3,151,2612,8,151,1,151,1,151,3,151,2616,8,151,1,151,1,151,1,151,3,151,
  	2621,8,151,1,151,3,151,2624,8,151,1,151,3,151,2627,8,151,1,151,1,151,
  	1,151,1,151,3,151,2633,8,151,1,151,1,151,3,151,2637,8,151,1,151,1,151,
  	3,151,2641,8,151,3,151,2643,8,151,1,151,1,151,3,151,2647,8,151,1,151,
  	1,151,3,151,2651,8,151,1,151,1,151,3,151,2655,8,151,5,151,2657,8,151,
  	10,151,12,151,2660,9,151,3,151,2662,8,151,1,151,1,151,3,151,2666,8,151,
  	1,152,1,152,1,153,1,153,3,153,2672,8,153,1,153,1,153,1,153,3,153,2677,
  	8,153,3,153,2679,8,153,1,153,1,153,3,153,2683,8,153,1,154,1,154,3,154,
  	2687,8,154,1,154,1,154,1,154,3,154,2692,8,154,1,154,1,154,3,154,2696,
  	8,154,1,155,1,155,1,155,3,155,2701,8,155,1,155,1,155,3,155,2705,8,155,
  	1,155,1,155,3,155,2709,8,155,1,155,1,155,3,155,2713,8,155,5,155,2715,
  	8,155,10,155,12,155,2718,9,155,1,155,1,155,3,155,2722,8,155,1,156,1,156,
  	3,156,2726,8,156,1,156,4,156,2729,8,156,11,156,12,156,2730,1,157,1,157,
  	3,157,2735,8,157,1,157,1,157,3,157,2739,8,157,1,157,1,157,3,157,2743,
  	8,157,1,157,1,157,3,157,2747,8,157,1,157,3,157,2750,8,157,1,157,3,157,
  	2753,8,157,1,157,3,157,2756,8,157,1,157,3,157,2759,8,157,1,157,1,157,
  	1,158,1,158,3,158,2765,8,158,1,158,1,158,3,158,2769,8,158,1,159,1,159,
  	3,159,2773,8,159,1,159,4,159,2776,8,159,11,159,12,159,2777,1,159,1,159,
  	3,159,2782,8,159,1,159,1,159,3,159,2786,8,159,1,159,4,159,2789,8,159,
  	11,159,12,159,2790,3,159,2793,8,159,1,159,3,159,2796,8,159,1,159,1,159,
  	3,159,2800,8,159,1,159,3,159,2803,8,159,1,159,3,159,2806,8,159,1,159,
  	1,159,1,160,1,160,3,160,2812,8,160,1,160,1,160,3,160,2816,8,160,1,160,
  	1,160,3,160,2820,8,160,1,160,1,160,1,161,1,161,1,162,1,162,3,162,2828,
  	8,162,1,163,1,163,1,163,3,163,2833,8,163,1,164,1,164,3,164,2837,8,164,
  	1,164,1,164,1,165,1,165,1,166,1,166,1,167,1,167,1,168,1,168,1,169,1,169,
  	1,169,1,169,1,169,3,169,2854,8,169,1,170,1,170,1,171,1,171,1,172,1,172,
  	1,173,1,173,1,173,0,2,102,156,174,0,2,4,6,8,10,12,14,16,18,20,22,24,26,
  	28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,
  	74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,
  	116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,
  	152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,
  	188,190,192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,
  	224,226,228,230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,
  	260,262,264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,
  	296,298,300,302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,
  	332,334,336,338,340,342,344,346,0,13,2,0,131,131,137,137,2,0,53,54,75,
  	76,2,0,6,6,13,17,1,0,19,20,2,0,21,21,163,163,2,0,22,23,159,159,2,0,87,
  	87,142,142,2,0,68,68,83,83,1,0,174,175,31,0,48,48,50,50,52,52,55,58,61,
  	61,63,64,66,68,70,71,74,74,77,77,79,79,84,86,88,89,91,91,95,96,98,98,
  	100,100,102,105,107,110,112,113,124,129,131,132,134,134,136,136,139,139,
  	141,141,143,143,146,148,152,152,156,158,160,160,2,0,14,14,27,30,2,0,16,
  	16,31,34,2,0,35,45,163,163,3248,0,348,1,0,0,0,2,368,1,0,0,0,4,401,1,0,
  	0,0,6,403,1,0,0,0,8,429,1,0,0,0,10,477,1,0,0,0,12,479,1,0,0,0,14,509,
  	1,0,0,0,16,539,1,0,0,0,18,559,1,0,0,0,20,565,1,0,0,0,22,616,1,0,0,0,24,
  	618,1,0,0,0,26,632,1,0,0,0,28,636,1,0,0,0,30,655,1,0,0,0,32,657,1,0,0,
  	0,34,669,1,0,0,0,36,712,1,0,0,0,38,726,1,0,0,0,40,770,1,0,0,0,42,772,
  	1,0,0,0,44,778,1,0,0,0,46,819,1,0,0,0,48,890,1,0,0,0,50,904,1,0,0,0,52,
  	912,1,0,0,0,54,929,1,0,0,0,56,946,1,0,0,0,58,948,1,0,0,0,60,959,1,0,0,
  	0,62,979,1,0,0,0,64,990,1,0,0,0,66,992,1,0,0,0,68,1005,1,0,0,0,70,1009,
  	1,0,0,0,72,1013,1,0,0,0,74,1024,1,0,0,0,76,1038,1,0,0,0,78,1040,1,0,0,
  	0,80,1054,1,0,0,0,82,1058,1,0,0,0,84,1067,1,0,0,0,86,1073,1,0,0,0,88,
  	1081,1,0,0,0,90,1090,1,0,0,0,92,1099,1,0,0,0,94,1113,1,0,0,0,96,1117,
  	1,0,0,0,98,1131,1,0,0,0,100,1142,1,0,0,0,102,1246,1,0,0,0,104,1255,1,
  	0,0,0,106,1262,1,0,0,0,108,1270,1,0,0,0,110,1272,1,0,0,0,112,1277,1,0,
  	0,0,114,1292,1,0,0,0,116,1298,1,0,0,0,118,1300,1,0,0,0,120,1312,1,0,0,
  	0,122,1323,1,0,0,0,124,1327,1,0,0,0,126,1331,1,0,0,0,128,1354,1,0,0,0,
  	130,1368,1,0,0,0,132,1372,1,0,0,0,134,1409,1,0,0,0,136,1415,1,0,0,0,138,
  	1427,1,0,0,0,140,1445,1,0,0,0,142,1451,1,0,0,0,144,1453,1,0,0,0,146,1503,
  	1,0,0,0,148,1507,1,0,0,0,150,1521,1,0,0,0,152,1540,1,0,0,0,154,1555,1,
  	0,0,0,156,1571,1,0,0,0,158,1592,1,0,0,0,160,1602,1,0,0,0,162,1608,1,0,
  	0,0,164,1630,1,0,0,0,166,1632,1,0,0,0,168,1650,1,0,0,0,170,1662,1,0,0,
  	0,172,1682,1,0,0,0,174,1690,1,0,0,0,176,1697,1,0,0,0,178,1741,1,0,0,0,
  	180,1750,1,0,0,0,182,1752,1,0,0,0,184,1767,1,0,0,0,186,1771,1,0,0,0,188,
  	1775,1,0,0,0,190,1782,1,0,0,0,192,1786,1,0,0,0,194,1811,1,0,0,0,196,1813,
  	1,0,0,0,198,1829,1,0,0,0,200,1831,1,0,0,0,202,1855,1,0,0,0,204,1905,1,
  	0,0,0,206,1907,1,0,0,0,208,1937,1,0,0,0,210,1978,1,0,0,0,212,1999,1,0,
  	0,0,214,2009,1,0,0,0,216,2015,1,0,0,0,218,2058,1,0,0,0,220,2074,1,0,0,
  	0,222,2076,1,0,0,0,224,2125,1,0,0,0,226,2137,1,0,0,0,228,2139,1,0,0,0,
  	230,2141,1,0,0,0,232,2143,1,0,0,0,234,2145,1,0,0,0,236,2147,1,0,0,0,238,
  	2157,1,0,0,0,240,2167,1,0,0,0,242,2183,1,0,0,0,244,2236,1,0,0,0,246,2238,
  	1,0,0,0,248,2240,1,0,0,0,250,2254,1,0,0,0,252,2268,1,0,0,0,254,2283,1,
  	0,0,0,256,2285,1,0,0,0,258,2300,1,0,0,0,260,2302,1,0,0,0,262,2317,1,0,
  	0,0,264,2319,1,0,0,0,266,2333,1,0,0,0,268,2362,1,0,0,0,270,2375,1,0,0,
  	0,272,2383,1,0,0,0,274,2397,1,0,0,0,276,2405,1,0,0,0,278,2415,1,0,0,0,
  	280,2434,1,0,0,0,282,2492,1,0,0,0,284,2494,1,0,0,0,286,2498,1,0,0,0,288,
  	2510,1,0,0,0,290,2512,1,0,0,0,292,2514,1,0,0,0,294,2535,1,0,0,0,296,2542,
  	1,0,0,0,298,2567,1,0,0,0,300,2578,1,0,0,0,302,2665,1,0,0,0,304,2667,1,
  	0,0,0,306,2682,1,0,0,0,308,2684,1,0,0,0,310,2721,1,0,0,0,312,2723,1,0,
  	0,0,314,2732,1,0,0,0,316,2762,1,0,0,0,318,2792,1,0,0,0,320,2809,1,0,0,
  	0,322,2823,1,0,0,0,324,2827,1,0,0,0,326,2829,1,0,0,0,328,2834,1,0,0,0,
  	330,2840,1,0,0,0,332,2842,1,0,0,0,334,2844,1,0,0,0,336,2846,1,0,0,0,338,
  	2853,1,0,0,0,340,2855,1,0,0,0,342,2857,1,0,0,0,344,2859,1,0,0,0,346,2861,
  	1,0,0,0,348,359,3,2,1,0,349,351,5,180,0,0,350,349,1,0,0,0,350,351,1,0,
  	0,0,351,352,1,0,0,0,352,354,5,1,0,0,353,355,5,180,0,0,354,353,1,0,0,0,
  	354,355,1,0,0,0,355,356,1,0,0,0,356,358,3,2,1,0,357,350,1,0,0,0,358,361,
  	1,0,0,0,359,357,1,0,0,0,359,360,1,0,0,0,360,363,1,0,0,0,361,359,1,0,0,
  	0,362,364,5,180,0,0,363,362,1,0,0,0,363,364,1,0,0,0,364,365,1,0,0,0,365,
  	366,5,0,0,1,366,1,1,0,0,0,367,369,3,108,54,0,368,367,1,0,0,0,368,369,
  	1,0,0,0,369,371,1,0,0,0,370,372,5,180,0,0,371,370,1,0,0,0,371,372,1,0,
  	0,0,372,373,1,0,0,0,373,378,3,4,2,0,374,376,5,180,0,0,375,374,1,0,0,0,
  	375,376,1,0,0,0,376,377,1,0,0,0,377,379,5,1,0,0,378,375,1,0,0,0,378,379,
  	1,0,0,0,379,3,1,0,0,0,380,402,3,126,63,0,381,402,3,58,29,0,382,402,3,
  	44,22,0,383,402,3,46,23,0,384,402,3,52,26,0,385,402,3,54,27,0,386,402,
  	3,72,36,0,387,402,3,74,37,0,388,402,3,6,3,0,389,402,3,12,6,0,390,402,
  	3,14,7,0,391,402,3,30,15,0,392,402,3,34,17,0,393,402,3,32,16,0,394,402,
  	3,114,57,0,395,402,3,116,58,0,396,402,3,16,8,0,397,402,3,18,9,0,398,402,
  	3,20,10,0,399,402,3,26,13,0,400,402,3,28,14,0,401,380,1,0,0,0,401,381,
  	1,0,0,0,401,382,1,0,0,0,401,383,1,0,0,0,401,384,1,0,0,0,401,385,1,0,0,
  	0,401,386,1,0,0,0,401,387,1,0,0,0,401,388,1,0,0,0,401,389,1,0,0,0,401,
  	390,1,0,0,0,401,391,1,0,0,0,401,392,1,0,0,0,401,393,1,0,0,0,401,394,1,
  	0,0,0,401,395,1,0,0,0,401,396,1,0,0,0,401,397,1,0,0,0,401,398,1,0,0,0,
  	401,399,1,0,0,0,401,400,1,0,0,0,402,5,1,0,0,0,403,404,5,67,0,0,404,405,
  	5,180,0,0,405,407,3,336,168,0,406,408,3,8,4,0,407,406,1,0,0,0,407,408,
  	1,0,0,0,408,409,1,0,0,0,409,410,5,180,0,0,410,411,5,88,0,0,411,412,5,
  	180,0,0,412,426,3,10,5,0,413,415,5,180,0,0,414,413,1,0,0,0,414,415,1,
  	0,0,0,415,416,1,0,0,0,416,418,5,2,0,0,417,419,5,180,0,0,418,417,1,0,0,
  	0,418,419,1,0,0,0,419,420,1,0,0,0,420,422,3,24,12,0,421,423,5,180,0,0,
  	422,421,1,0,0,0,422,423,1,0,0,0,423,424,1,0,0,0,424,425,5,3,0,0,425,427,
  	1,0,0,0,426,414,1,0,0,0,426,427,1,0,0,0,427,7,1,0,0,0,428,430,5,180,0,
  	0,429,428,1,0,0,0,429,430,1,0,0,0,430,431,1,0,0,0,431,433,5,2,0,0,432,
  	434,5,180,0,0,433,432,1,0,0,0,433,434,1,0,0,0,434,452,1,0,0,0,435,446,
  	3,336,168,0,436,438,5,180,0,0,437,436,1,0,0,0,437,438,1,0,0,0,438,439,
  	1,0,0,0,439,441,5,4,0,0,440,442,5,180,0,0,441,440,1,0,0,0,441,442,1,0,
  	0,0,442,443,1,0,0,0,443,445,3,336,168,0,444,437,1,0,0,0,445,448,1,0,0,
  	0,446,444,1,0,0,0,446,447,1,0,0,0,447,450,1,0,0,0,448,446,1,0,0,0,449,
  	451,5,180,0,0,450,449,1,0,0,0,450,451,1,0,0,0,451,453,1,0,0,0,452,435,
  	1,0,0,0,452,453,1,0,0,0,453,454,1,0,0,0,454,455,5,3,0,0,455,9,1,0,0,0,
  	456,478,3,40,20,0,457,459,5,2,0,0,458,460,5,180,0,0,459,458,1,0,0,0,459,
  	460,1,0,0,0,460,461,1,0,0,0,461,463,3,126,63,0,462,464,5,180,0,0,463,
  	462,1,0,0,0,463,464,1,0,0,0,464,465,1,0,0,0,465,466,5,3,0,0,466,478,1,
  	0,0,0,467,478,3,326,163,0,468,478,3,322,161,0,469,470,3,322,161,0,470,
  	472,5,5,0,0,471,473,5,180,0,0,472,471,1,0,0,0,472,473,1,0,0,0,473,474,
  	1,0,0,0,474,475,3,336,168,0,475,478,1,0,0,0,476,478,3,302,151,0,477,456,
  	1,0,0,0,477,457,1,0,0,0,477,467,1,0,0,0,477,468,1,0,0,0,477,469,1,0,0,
  	0,477,476,1,0,0,0,478,11,1,0,0,0,479,480,5,67,0,0,480,481,5,180,0,0,481,
  	482,3,336,168,0,482,483,5,180,0,0,483,484,5,88,0,0,484,485,5,180,0,0,
  	485,487,5,2,0,0,486,488,5,180,0,0,487,486,1,0,0,0,487,488,1,0,0,0,488,
  	489,1,0,0,0,489,500,5,165,0,0,490,492,5,180,0,0,491,490,1,0,0,0,491,492,
  	1,0,0,0,492,493,1,0,0,0,493,495,5,4,0,0,494,496,5,180,0,0,495,494,1,0,
  	0,0,495,496,1,0,0,0,496,497,1,0,0,0,497,499,5,165,0,0,498,491,1,0,0,0,
  	499,502,1,0,0,0,500,498,1,0,0,0,500,501,1,0,0,0,501,503,1,0,0,0,502,500,
  	1,0,0,0,503,504,5,3,0,0,504,505,5,180,0,0,505,506,5,57,0,0,506,507,5,
  	180,0,0,507,508,5,62,0,0,508,13,1,0,0,0,509,510,5,67,0,0,510,511,5,180,
  	0,0,511,513,5,2,0,0,512,514,5,180,0,0,513,512,1,0,0,0,513,514,1,0,0,0,
  	514,515,1,0,0,0,515,517,3,126,63,0,516,518,5,180,0,0,517,516,1,0,0,0,
  	517,518,1,0,0,0,518,519,1,0,0,0,519,520,5,3,0,0,520,521,5,180,0,0,521,
  	522,5,139,0,0,522,523,5,180,0,0,523,537,5,165,0,0,524,526,5,180,0,0,525,
  	524,1,0,0,0,525,526,1,0,0,0,526,527,1,0,0,0,527,529,5,2,0,0,528,530,5,
  	180,0,0,529,528,1,0,0,0,529,530,1,0,0,0,530,531,1,0,0,0,531,533,3,24,
  	12,0,532,534,5,180,0,0,533,532,1,0,0,0,533,534,1,0,0,0,534,535,1,0,0,
  	0,535,536,5,3,0,0,536,538,1,0,0,0,537,525,1,0,0,0,537,538,1,0,0,0,538,
  	15,1,0,0,0,539,540,5,85,0,0,540,541,5,180,0,0,541,542,5,71,0,0,542,543,
  	5,180,0,0,543,557,5,165,0,0,544,546,5,180,0,0,545,544,1,0,0,0,545,546,
  	1,0,0,0,546,547,1,0,0,0,547,549,5,2,0,0,548,550,5,180,0,0,549,548,1,0,
  	0,0,549,550,1,0,0,0,550,551,1,0,0,0,551,553,3,24,12,0,552,554,5,180,0,
  	0,553,552,1,0,0,0,553,554,1,0,0,0,554,555,1,0,0,0,555,556,5,3,0,0,556,
  	558,1,0,0,0,557,545,1,0,0,0,557,558,1,0,0,0,558,17,1,0,0,0,559,560,5,
  	95,0,0,560,561,5,180,0,0,561,562,5,71,0,0,562,563,5,180,0,0,563,564,5,
  	165,0,0,564,19,1,0,0,0,565,566,5,55,0,0,566,567,5,180,0,0,567,572,5,165,
  	0,0,568,569,5,180,0,0,569,570,5,52,0,0,570,571,5,180,0,0,571,573,3,336,
  	168,0,572,568,1,0,0,0,572,573,1,0,0,0,573,574,1,0,0,0,574,575,5,180,0,
  	0,575,577,5,2,0,0,576,578,5,180,0,0,577,576,1,0,0,0,577,578,1,0,0,0,578,
  	579,1,0,0,0,579,580,5,72,0,0,580,581,5,180,0,0,581,590,3,338,169,0,582,
  	584,5,180,0,0,583,582,1,0,0,0,583,584,1,0,0,0,584,585,1,0,0,0,585,587,
  	5,4,0,0,586,588,5,180,0,0,587,586,1,0,0,0,587,588,1,0,0,0,588,589,1,0,
  	0,0,589,591,3,24,12,0,590,583,1,0,0,0,590,591,1,0,0,0,591,593,1,0,0,0,
  	592,594,5,180,0,0,593,592,1,0,0,0,593,594,1,0,0,0,594,595,1,0,0,0,595,
  	596,5,3,0,0,596,21,1,0,0,0,597,611,3,338,169,0,598,600,5,180,0,0,599,
  	598,1,0,0,0,599,600,1,0,0,0,600,601,1,0,0,0,601,603,5,6,0,0,602,604,5,
  	180,0,0,603,602,1,0,0,0,603,604,1,0,0,0,604,612,1,0,0,0,605,607,5,180,
  	0,0,606,605,1,0,0,0,607,610,1,0,0,0,608,606,1,0,0,0,608,609,1,0,0,0,609,
  	612,1,0,0,0,610,608,1,0,0,0,611,599,1,0,0,0,611,608,1,0,0,0,612,613,1,
  	0,0,0,613,614,3,288,144,0,614,617,1,0,0,0,615,617,3,338,169,0,616,597,
  	1,0,0,0,616,615,1,0,0,0,617,23,1,0,0,0,618,629,3,22,11,0,619,621,5,180,
  	0,0,620,619,1,0,0,0,620,621,1,0,0,0,621,622,1,0,0,0,622,624,5,4,0,0,623,
  	625,5,180,0,0,624,623,1,0,0,0,624,625,1,0,0,0,625,626,1,0,0,0,626,628,
  	3,22,11,0,627,620,1,0,0,0,628,631,1,0,0,0,629,627,1,0,0,0,629,630,1,0,
  	0,0,630,25,1,0,0,0,631,629,1,0,0,0,632,633,5,77,0,0,633,634,5,180,0,0,
  	634,635,3,336,168,0,635,27,1,0,0,0,636,637,5,148,0,0,637,638,5,180,0,
  	0,638,639,3,336,168,0,639,29,1,0,0,0,640,641,5,58,0,0,641,642,5,180,0,
  	0,642,644,3,338,169,0,643,645,5,180,0,0,644,643,1,0,0,0,644,645,1,0,0,
  	0,645,646,1,0,0,0,646,648,5,6,0,0,647,649,5,180,0,0,648,647,1,0,0,0,648,
  	649,1,0,0,0,649,650,1,0,0,0,650,651,3,234,117,0,651,656,1,0,0,0,652,653,
  	5,58,0,0,653,654,5,180,0,0,654,656,3,302,151,0,655,640,1,0,0,0,655,652,
  	1,0,0,0,656,31,1,0,0,0,657,658,5,63,0,0,658,659,5,180,0,0,659,660,5,117,
  	0,0,660,661,5,180,0,0,661,662,5,137,0,0,662,663,5,180,0,0,663,664,3,336,
  	168,0,664,665,5,180,0,0,665,666,5,100,0,0,666,667,5,180,0,0,667,668,5,
  	165,0,0,668,33,1,0,0,0,669,670,5,69,0,0,670,671,5,180,0,0,671,672,5,106,
  	0,0,672,673,5,180,0,0,673,675,3,304,152,0,674,676,5,180,0,0,675,674,1,
  	0,0,0,675,676,1,0,0,0,676,677,1,0,0,0,677,679,5,2,0,0,678,680,5,180,0,
  	0,679,678,1,0,0,0,679,680,1,0,0,0,680,682,1,0,0,0,681,683,3,36,18,0,682,
  	681,1,0,0,0,682,683,1,0,0,0,683,685,1,0,0,0,684,686,5,180,0,0,685,684,
  	1,0,0,0,685,686,1,0,0,0,686,688,1,0,0,0,687,689,3,38,19,0,688,687,1,0,
  	0,0,688,689,1,0,0,0,689,700,1,0,0,0,690,692,5,180,0,0,691,690,1,0,0,0,
  	691,692,1,0,0,0,692,693,1,0,0,0,693,695,5,4,0,0,694,696,5,180,0,0,695,
  	694,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,699,3,38,19,0,698,691,
  	1,0,0,0,699,702,1,0,0,0,700,698,1,0,0,0,700,701,1,0,0,0,701,704,1,0,0,
  	0,702,700,1,0,0,0,703,705,5,180,0,0,704,703,1,0,0,0,704,705,1,0,0,0,705,
  	706,1,0,0,0,706,707,5,3,0,0,707,708,5,180,0,0,708,709,5,52,0,0,709,710,
  	5,180,0,0,710,711,3,234,117,0,711,35,1,0,0,0,712,723,3,338,169,0,713,
  	715,5,180,0,0,714,713,1,0,0,0,714,715,1,0,0,0,715,716,1,0,0,0,716,718,
  	5,4,0,0,717,719,5,180,0,0,718,717,1,0,0,0,718,719,1,0,0,0,719,720,1,0,
  	0,0,720,722,3,338,169,0,721,714,1,0,0,0,722,725,1,0,0,0,723,721,1,0,0,
  	0,723,724,1,0,0,0,724,37,1,0,0,0,725,723,1,0,0,0,726,728,3,338,169,0,
  	727,729,5,180,0,0,728,727,1,0,0,0,728,729,1,0,0,0,729,730,1,0,0,0,730,
  	731,5,162,0,0,731,733,5,6,0,0,732,734,5,180,0,0,733,732,1,0,0,0,733,734,
  	1,0,0,0,734,735,1,0,0,0,735,736,3,288,144,0,736,39,1,0,0,0,737,739,5,
  	7,0,0,738,740,5,180,0,0,739,738,1,0,0,0,739,740,1,0,0,0,740,741,1,0,0,
  	0,741,752,5,165,0,0,742,744,5,180,0,0,743,742,1,0,0,0,743,744,1,0,0,0,
  	744,745,1,0,0,0,745,747,5,4,0,0,746,748,5,180,0,0,747,746,1,0,0,0,747,
  	748,1,0,0,0,748,749,1,0,0,0,749,751,5,165,0,0,750,743,1,0,0,0,751,754,
  	1,0,0,0,752,750,1,0,0,0,752,753,1,0,0,0,753,755,1,0,0,0,754,752,1,0,0,
  	0,755,771,5,8,0,0,756,771,5,165,0,0,757,759,5,90,0,0,758,760,5,180,0,
  	0,759,758,1,0,0,0,759,760,1,0,0,0,760,761,1,0,0,0,761,763,5,2,0,0,762,
  	764,5,180,0,0,763,762,1,0,0,0,763,764,1,0,0,0,764,765,1,0,0,0,765,767,
  	5,165,0,0,766,768,5,180,0,0,767,766,1,0,0,0,767,768,1,0,0,0,768,769,1,
  	0,0,0,769,771,5,3,0,0,770,737,1,0,0,0,770,756,1,0,0,0,770,757,1,0,0,0,
  	771,41,1,0,0,0,772,773,5,96,0,0,773,774,5,180,0,0,774,775,5,114,0,0,775,
  	776,5,180,0,0,776,777,5,83,0,0,777,43,1,0,0,0,778,779,5,69,0,0,779,780,
  	5,180,0,0,780,781,5,113,0,0,781,782,5,180,0,0,782,783,5,137,0,0,783,787,
  	5,180,0,0,784,785,3,42,21,0,785,786,5,180,0,0,786,788,1,0,0,0,787,784,
  	1,0,0,0,787,788,1,0,0,0,788,789,1,0,0,0,789,817,3,336,168,0,790,792,5,
  	180,0,0,791,790,1,0,0,0,791,792,1,0,0,0,792,793,1,0,0,0,793,795,5,2,0,
  	0,794,796,5,180,0,0,795,794,1,0,0,0,795,796,1,0,0,0,796,797,1,0,0,0,797,
  	799,3,96,48,0,798,800,5,180,0,0,799,798,1,0,0,0,799,800,1,0,0,0,800,806,
  	1,0,0,0,801,803,5,4,0,0,802,804,5,180,0,0,803,802,1,0,0,0,803,804,1,0,
  	0,0,804,805,1,0,0,0,805,807,3,100,50,0,806,801,1,0,0,0,806,807,1,0,0,
  	0,807,809,1,0,0,0,808,810,5,180,0,0,809,808,1,0,0,0,809,810,1,0,0,0,810,
  	811,1,0,0,0,811,812,5,3,0,0,812,818,1,0,0,0,813,814,5,180,0,0,814,815,
  	5,52,0,0,815,816,5,180,0,0,816,818,3,126,63,0,817,791,1,0,0,0,817,813,
  	1,0,0,0,818,45,1,0,0,0,819,820,5,69,0,0,820,821,5,180,0,0,821,822,5,126,
  	0,0,822,823,5,180,0,0,823,826,5,137,0,0,824,825,5,180,0,0,825,827,5,92,
  	0,0,826,824,1,0,0,0,826,827,1,0,0,0,827,830,1,0,0,0,828,829,5,180,0,0,
  	829,831,3,42,21,0,830,828,1,0,0,0,830,831,1,0,0,0,831,832,1,0,0,0,832,
  	833,5,180,0,0,833,835,3,336,168,0,834,836,5,180,0,0,835,834,1,0,0,0,835,
  	836,1,0,0,0,836,837,1,0,0,0,837,839,5,2,0,0,838,840,5,180,0,0,839,838,
  	1,0,0,0,839,840,1,0,0,0,840,841,1,0,0,0,841,843,3,48,24,0,842,844,5,180,
  	0,0,843,842,1,0,0,0,843,844,1,0,0,0,844,871,1,0,0,0,845,847,5,4,0,0,846,
  	848,5,180,0,0,847,846,1,0,0,0,847,848,1,0,0,0,848,849,1,0,0,0,849,851,
  	3,96,48,0,850,852,5,180,0,0,851,850,1,0,0,0,851,852,1,0,0,0,852,854,1,
  	0,0,0,853,845,1,0,0,0,853,854,1,0,0,0,854,863,1,0,0,0,855,857,5,4,0,0,
  	856,858,5,180,0,0,857,856,1,0,0,0,857,858,1,0,0,0,858,859,1,0,0,0,859,
  	861,3,338,169,0,860,862,5,180,0,0,861,860,1,0,0,0,861,862,1,0,0,0,862,
  	864,1,0,0,0,863,855,1,0,0,0,863,864,1,0,0,0,864,865,1,0,0,0,865,872,5,
  	3,0,0,866,867,5,3,0,0,867,868,5,180,0,0,868,869,5,52,0,0,869,870,5,180,
  	0,0,870,872,3,126,63,0,871,853,1,0,0,0,871,866,1,0,0,0,872,888,1,0,0,
  	0,873,874,5,180,0,0,874,876,5,151,0,0,875,877,5,180,0,0,876,875,1,0,0,
  	0,876,877,1,0,0,0,877,878,1,0,0,0,878,880,5,2,0,0,879,881,5,180,0,0,880,
  	879,1,0,0,0,880,881,1,0,0,0,881,882,1,0,0,0,882,884,3,24,12,0,883,885,
  	5,180,0,0,884,883,1,0,0,0,884,885,1,0,0,0,885,886,1,0,0,0,886,887,5,3,
  	0,0,887,889,1,0,0,0,888,873,1,0,0,0,888,889,1,0,0,0,889,47,1,0,0,0,890,
  	901,3,50,25,0,891,893,5,180,0,0,892,891,1,0,0,0,892,893,1,0,0,0,893,894,
  	1,0,0,0,894,896,5,4,0,0,895,897,5,180,0,0,896,895,1,0,0,0,896,897,1,0,
  	0,0,897,898,1,0,0,0,898,900,3,50,25,0,899,892,1,0,0,0,900,903,1,0,0,0,
  	901,899,1,0,0,0,901,902,1,0,0,0,902,49,1,0,0,0,903,901,1,0,0,0,904,905,
  	5,88,0,0,905,906,5,180,0,0,906,907,3,336,168,0,907,908,5,180,0,0,908,
  	909,5,139,0,0,909,910,5,180,0,0,910,911,3,336,168,0,911,51,1,0,0,0,912,
  	913,5,69,0,0,913,914,5,180,0,0,914,915,5,131,0,0,915,919,5,180,0,0,916,
  	917,3,42,21,0,917,918,5,180,0,0,918,920,1,0,0,0,919,916,1,0,0,0,919,920,
  	1,0,0,0,920,921,1,0,0,0,921,926,3,336,168,0,922,923,5,180,0,0,923,925,
  	3,56,28,0,924,922,1,0,0,0,925,928,1,0,0,0,926,924,1,0,0,0,926,927,1,0,
  	0,0,927,53,1,0,0,0,928,926,1,0,0,0,929,930,5,69,0,0,930,931,5,180,0,0,
  	931,932,5,143,0,0,932,933,5,180,0,0,933,934,3,336,168,0,934,935,5,180,
  	0,0,935,936,5,52,0,0,936,937,5,180,0,0,937,939,3,102,51,0,938,940,5,180,
  	0,0,939,938,1,0,0,0,939,940,1,0,0,0,940,55,1,0,0,0,941,947,3,60,30,0,
  	942,947,3,62,31,0,943,947,3,64,32,0,944,947,3,66,33,0,945,947,3,68,34,
  	0,946,941,1,0,0,0,946,942,1,0,0,0,946,943,1,0,0,0,946,944,1,0,0,0,946,
  	945,1,0,0,0,947,57,1,0,0,0,948,949,5,69,0,0,949,950,5,180,0,0,950,951,
  	5,157,0,0,951,955,5,180,0,0,952,953,3,42,21,0,953,954,5,180,0,0,954,956,
  	1,0,0,0,955,952,1,0,0,0,955,956,1,0,0,0,956,957,1,0,0,0,957,958,3,322,
  	161,0,958,59,1,0,0,0,959,960,5,98,0,0,960,963,5,180,0,0,961,962,5,57,
  	0,0,962,964,5,180,0,0,963,961,1,0,0,0,963,964,1,0,0,0,964,966,1,0,0,0,
  	965,967,5,163,0,0,966,965,1,0,0,0,966,967,1,0,0,0,967,968,1,0,0,0,968,
  	969,3,332,166,0,969,61,1,0,0,0,970,971,5,112,0,0,971,972,5,180,0,0,972,
  	980,5,110,0,0,973,974,5,110,0,0,974,976,5,180,0,0,975,977,5,163,0,0,976,
  	975,1,0,0,0,976,977,1,0,0,0,977,978,1,0,0,0,978,980,3,332,166,0,979,970,
  	1,0,0,0,979,973,1,0,0,0,980,63,1,0,0,0,981,982,5,112,0,0,982,983,5,180,
  	0,0,983,991,5,108,0,0,984,985,5,108,0,0,985,987,5,180,0,0,986,988,5,163,
  	0,0,987,986,1,0,0,0,987,988,1,0,0,0,988,989,1,0,0,0,989,991,3,332,166,
  	0,990,981,1,0,0,0,990,984,1,0,0,0,991,65,1,0,0,0,992,993,5,134,0,0,993,
  	996,5,180,0,0,994,995,5,151,0,0,995,997,5,180,0,0,996,994,1,0,0,0,996,
  	997,1,0,0,0,997,999,1,0,0,0,998,1000,5,163,0,0,999,998,1,0,0,0,999,1000,
  	1,0,0,0,1000,1001,1,0,0,0,1001,1002,3,332,166,0,1002,67,1,0,0,0,1003,
  	1004,5,112,0,0,1004,1006,5,180,0,0,1005,1003,1,0,0,0,1005,1006,1,0,0,
  	0,1006,1007,1,0,0,0,1007,1008,5,70,0,0,1008,69,1,0,0,0,1009,1010,5,96,
  	0,0,1010,1011,5,180,0,0,1011,1012,5,83,0,0,1012,71,1,0,0,0,1013,1014,
  	5,79,0,0,1014,1015,5,180,0,0,1015,1016,7,0,0,0,1016,1020,5,180,0,0,1017,
  	1018,3,70,35,0,1018,1019,5,180,0,0,1019,1021,1,0,0,0,1020,1017,1,0,0,
  	0,1020,1021,1,0,0,0,1021,1022,1,0,0,0,1022,1023,3,336,168,0,1023,73,1,
  	0,0,0,1024,1025,5,50,0,0,1025,1026,5,180,0,0,1026,1027,5,137,0,0,1027,
  	1028,5,180,0,0,1028,1029,3,336,168,0,1029,1030,5,180,0,0,1030,1031,3,
  	76,38,0,1031,75,1,0,0,0,1032,1039,3,78,39,0,1033,1039,3,82,41,0,1034,
  	1039,3,84,42,0,1035,1039,3,86,43,0,1036,1039,3,88,44,0,1037,1039,3,90,
  	45,0,1038,1032,1,0,0,0,1038,1033,1,0,0,0,1038,1034,1,0,0,0,1038,1035,
  	1,0,0,0,1038,1036,1,0,0,0,1038,1037,1,0,0,0,1039,77,1,0,0,0,1040,1041,
  	5,48,0,0,1041,1045,5,180,0,0,1042,1043,3,42,21,0,1043,1044,5,180,0,0,
  	1044,1046,1,0,0,0,1045,1042,1,0,0,0,1045,1046,1,0,0,0,1046,1047,1,0,0,
  	0,1047,1048,3,330,165,0,1048,1049,5,180,0,0,1049,1052,3,102,51,0,1050,
  	1051,5,180,0,0,1051,1053,3,80,40,0,1052,1050,1,0,0,0,1052,1053,1,0,0,
  	0,1053,79,1,0,0,0,1054,1055,5,73,0,0,1055,1056,5,180,0,0,1056,1057,3,
  	234,117,0,1057,81,1,0,0,0,1058,1059,5,79,0,0,1059,1063,5,180,0,0,1060,
  	1061,3,70,35,0,1061,1062,5,180,0,0,1062,1064,1,0,0,0,1063,1060,1,0,0,
  	0,1063,1064,1,0,0,0,1064,1065,1,0,0,0,1065,1066,3,330,165,0,1066,83,1,
  	0,0,0,1067,1068,5,127,0,0,1068,1069,5,180,0,0,1069,1070,5,139,0,0,1070,
  	1071,5,180,0,0,1071,1072,3,336,168,0,1072,85,1,0,0,0,1073,1074,5,127,
  	0,0,1074,1075,5,180,0,0,1075,1076,3,330,165,0,1076,1077,5,180,0,0,1077,
  	1078,5,139,0,0,1078,1079,5,180,0,0,1079,1080,3,330,165,0,1080,87,1,0,
  	0,0,1081,1082,5,48,0,0,1082,1086,5,180,0,0,1083,1084,3,42,21,0,1084,1085,
  	5,180,0,0,1085,1087,1,0,0,0,1086,1083,1,0,0,0,1086,1087,1,0,0,0,1087,
  	1088,1,0,0,0,1088,1089,3,50,25,0,1089,89,1,0,0,0,1090,1091,5,79,0,0,1091,
  	1095,5,180,0,0,1092,1093,3,70,35,0,1093,1094,5,180,0,0,1094,1096,1,0,
  	0,0,1095,1092,1,0,0,0,1095,1096,1,0,0,0,1096,1097,1,0,0,0,1097,1098,3,
  	50,25,0,1098,91,1,0,0,0,1099,1110,3,94,47,0,1100,1102,5,180,0,0,1101,
  	1100,1,0,0,0,1101,1102,1,0,0,0,1102,1103,1,0,0,0,1103,1105,5,4,0,0,1104,
  	1106,5,180,0,0,1105,1104,1,0,0,0,1105,1106,1,0,0,0,1106,1107,1,0,0,0,
  	1107,1109,3,94,47,0,1108,1101,1,0,0,0,1109,1112,1,0,0,0,1110,1108,1,0,
  	0,0,1110,1111,1,0,0,0,1111,93,1,0,0,0,1112,1110,1,0,0,0,1113,1114,3,330,
  	165,0,1114,1115,5,180,0,0,1115,1116,3,102,51,0,1116,95,1,0,0,0,1117,1128,
  	3,98,49,0,1118,1120,5,180,0,0,1119,1118,1,0,0,0,1119,1120,1,0,0,0,1120,
  	1121,1,0,0,0,1121,1123,5,4,0,0,1122,1124,5,180,0,0,1123,1122,1,0,0,0,
  	1123,1124,1,0,0,0,1124,1125,1,0,0,0,1125,1127,3,98,49,0,1126,1119,1,0,
  	0,0,1127,1130,1,0,0,0,1128,1126,1,0,0,0,1128,1129,1,0,0,0,1129,97,1,0,
  	0,0,1130,1128,1,0,0,0,1131,1134,3,94,47,0,1132,1133,5,180,0,0,1133,1135,
  	3,80,40,0,1134,1132,1,0,0,0,1134,1135,1,0,0,0,1135,1140,1,0,0,0,1136,
  	1137,5,180,0,0,1137,1138,5,122,0,0,1138,1139,5,180,0,0,1139,1141,5,102,
  	0,0,1140,1136,1,0,0,0,1140,1141,1,0,0,0,1141,99,1,0,0,0,1142,1143,5,122,
  	0,0,1143,1144,5,180,0,0,1144,1146,5,102,0,0,1145,1147,5,180,0,0,1146,
  	1145,1,0,0,0,1146,1147,1,0,0,0,1147,1148,1,0,0,0,1148,1150,5,2,0,0,1149,
  	1151,5,180,0,0,1150,1149,1,0,0,0,1150,1151,1,0,0,0,1151,1152,1,0,0,0,
  	1152,1154,3,330,165,0,1153,1155,5,180,0,0,1154,1153,1,0,0,0,1154,1155,
  	1,0,0,0,1155,1156,1,0,0,0,1156,1157,5,3,0,0,1157,101,1,0,0,0,1158,1159,
  	6,51,-1,0,1159,1247,3,338,169,0,1160,1162,5,144,0,0,1161,1163,5,180,0,
  	0,1162,1161,1,0,0,0,1162,1163,1,0,0,0,1163,1164,1,0,0,0,1164,1166,5,2,
  	0,0,1165,1167,5,180,0,0,1166,1165,1,0,0,0,1166,1167,1,0,0,0,1167,1168,
  	1,0,0,0,1168,1170,3,92,46,0,1169,1171,5,180,0,0,1170,1169,1,0,0,0,1170,
  	1171,1,0,0,0,1171,1172,1,0,0,0,1172,1173,5,3,0,0,1173,1247,1,0,0,0,1174,
  	1176,5,136,0,0,1175,1177,5,180,0,0,1176,1175,1,0,0,0,1176,1177,1,0,0,
  	0,1177,1178,1,0,0,0,1178,1180,5,2,0,0,1179,1181,5,180,0,0,1180,1179,1,
  	0,0,0,1180,1181,1,0,0,0,1181,1182,1,0,0,0,1182,1184,3,92,46,0,1183,1185,
  	5,180,0,0,1184,1183,1,0,0,0,1184,1185,1,0,0,0,1185,1186,1,0,0,0,1186,
  	1187,5,3,0,0,1187,1247,1,0,0,0,1188,1190,3,338,169,0,1189,1191,5,180,
  	0,0,1190,1189,1,0,0,0,1190,1191,1,0,0,0,1191,1192,1,0,0,0,1192,1194,5,
  	2,0,0,1193,1195,5,180,0,0,1194,1193,1,0,0,0,1194,1195,1,0,0,0,1195,1196,
  	1,0,0,0,1196,1198,3,92,46,0,1197,1199,5,180,0,0,1198,1197,1,0,0,0,1198,
  	1199,1,0,0,0,1199,1200,1,0,0,0,1200,1201,5,3,0,0,1201,1247,1,0,0,0,1202,
  	1204,3,338,169,0,1203,1205,5,180,0,0,1204,1203,1,0,0,0,1204,1205,1,0,
  	0,0,1205,1206,1,0,0,0,1206,1208,5,2,0,0,1207,1209,5,180,0,0,1208,1207,
  	1,0,0,0,1208,1209,1,0,0,0,1209,1210,1,0,0,0,1210,1212,3,102,51,0,1211,
  	1213,5,180,0,0,1212,1211,1,0,0,0,1212,1213,1,0,0,0,1213,1214,1,0,0,0,
  	1214,1216,5,4,0,0,1215,1217,5,180,0,0,1216,1215,1,0,0,0,1216,1217,1,0,
  	0,0,1217,1218,1,0,0,0,1218,1220,3,102,51,0,1219,1221,5,180,0,0,1220,1219,
  	1,0,0,0,1220,1221,1,0,0,0,1221,1222,1,0,0,0,1222,1223,5,3,0,0,1223,1247,
  	1,0,0,0,1224,1226,5,158,0,0,1225,1227,5,180,0,0,1226,1225,1,0,0,0,1226,
  	1227,1,0,0,0,1227,1228,1,0,0,0,1228,1230,5,2,0,0,1229,1231,5,180,0,0,
  	1230,1229,1,0,0,0,1230,1231,1,0,0,0,1231,1232,1,0,0,0,1232,1234,3,332,
  	166,0,1233,1235,5,180,0,0,1234,1233,1,0,0,0,1234,1235,1,0,0,0,1235,1236,
  	1,0,0,0,1236,1238,5,4,0,0,1237,1239,5,180,0,0,1238,1237,1,0,0,0,1238,
  	1239,1,0,0,0,1239,1240,1,0,0,0,1240,1242,3,332,166,0,1241,1243,5,180,
  	0,0,1242,1241,1,0,0,0,1242,1243,1,0,0,0,1243,1244,1,0,0,0,1244,1245,5,
  	3,0,0,1245,1247,1,0,0,0,1246,1158,1,0,0,0,1246,1160,1,0,0,0,1246,1174,
  	1,0,0,0,1246,1188,1,0,0,0,1246,1202,1,0,0,0,1246,1224,1,0,0,0,1247,1252,
  	1,0,0,0,1248,1249,10,6,0,0,1249,1251,3,104,52,0,1250,1248,1,0,0,0,1251,
  	1254,1,0,0,0,1252,1250,1,0,0,0,1252,1253,1,0,0,0,1253,103,1,0,0,0,1254,
  	1252,1,0,0,0,1255,1259,3,106,53,0,1256,1258,3,106,53,0,1257,1256,1,0,
  	0,0,1258,1261,1,0,0,0,1259,1257,1,0,0,0,1259,1260,1,0,0,0,1260,105,1,
  	0,0,0,1261,1259,1,0,0,0,1262,1264,5,7,0,0,1263,1265,3,332,166,0,1264,
  	1263,1,0,0,0,1264,1265,1,0,0,0,1265,1266,1,0,0,0,1266,1267,5,8,0,0,1267,
  	107,1,0,0,0,1268,1271,3,110,55,0,1269,1271,3,112,56,0,1270,1268,1,0,0,
  	0,1270,1269,1,0,0,0,1271,109,1,0,0,0,1272,1275,5,84,0,0,1273,1274,5,180,
  	0,0,1274,1276,5,105,0,0,1275,1273,1,0,0,0,1275,1276,1,0,0,0,1276,111,
  	1,0,0,0,1277,1278,5,123,0,0,1278,113,1,0,0,0,1279,1280,5,56,0,0,1280,
  	1281,5,180,0,0,1281,1293,5,141,0,0,1282,1283,5,56,0,0,1283,1284,5,180,
  	0,0,1284,1285,5,141,0,0,1285,1286,5,180,0,0,1286,1287,5,125,0,0,1287,
  	1288,5,180,0,0,1288,1293,5,118,0,0,1289,1293,5,64,0,0,1290,1293,5,129,
  	0,0,1291,1293,5,61,0,0,1292,1279,1,0,0,0,1292,1282,1,0,0,0,1292,1289,
  	1,0,0,0,1292,1290,1,0,0,0,1292,1291,1,0,0,0,1293,115,1,0,0,0,1294,1299,
  	3,118,59,0,1295,1299,3,120,60,0,1296,1299,3,122,61,0,1297,1299,3,124,
  	62,0,1298,1294,1,0,0,0,1298,1295,1,0,0,0,1298,1296,1,0,0,0,1298,1297,
  	1,0,0,0,1299,117,1,0,0,0,1300,1301,5,104,0,0,1301,1304,5,180,0,0,1302,
  	1303,5,86,0,0,1303,1305,5,180,0,0,1304,1302,1,0,0,0,1304,1305,1,0,0,0,
  	1305,1308,1,0,0,0,1306,1309,5,165,0,0,1307,1309,3,322,161,0,1308,1306,
  	1,0,0,0,1308,1307,1,0,0,0,1309,119,1,0,0,0,1310,1311,5,89,0,0,1311,1313,
  	5,180,0,0,1312,1310,1,0,0,0,1312,1313,1,0,0,0,1313,1314,1,0,0,0,1314,
  	1315,5,99,0,0,1315,1316,5,180,0,0,1316,1321,3,322,161,0,1317,1318,5,180,
  	0,0,1318,1319,5,88,0,0,1319,1320,5,180,0,0,1320,1322,5,165,0,0,1321,1317,
  	1,0,0,0,1321,1322,1,0,0,0,1322,121,1,0,0,0,1323,1324,5,146,0,0,1324,1325,
  	5,180,0,0,1325,1326,3,322,161,0,1326,123,1,0,0,0,1327,1328,5,147,0,0,
  	1328,1329,5,180,0,0,1329,1330,3,322,161,0,1330,125,1,0,0,0,1331,1332,
  	3,128,64,0,1332,127,1,0,0,0,1333,1340,3,132,66,0,1334,1336,5,180,0,0,
  	1335,1334,1,0,0,0,1335,1336,1,0,0,0,1336,1337,1,0,0,0,1337,1339,3,130,
  	65,0,1338,1335,1,0,0,0,1339,1342,1,0,0,0,1340,1338,1,0,0,0,1340,1341,
  	1,0,0,0,1341,1355,1,0,0,0,1342,1340,1,0,0,0,1343,1345,3,174,87,0,1344,
  	1346,5,180,0,0,1345,1344,1,0,0,0,1345,1346,1,0,0,0,1346,1348,1,0,0,0,
  	1347,1343,1,0,0,0,1348,1349,1,0,0,0,1349,1347,1,0,0,0,1349,1350,1,0,0,
  	0,1350,1351,1,0,0,0,1351,1352,3,132,66,0,1352,1353,6,64,-1,0,1353,1355,
  	1,0,0,0,1354,1333,1,0,0,0,1354,1347,1,0,0,0,1355,129,1,0,0,0,1356,1357,
  	5,144,0,0,1357,1358,5,180,0,0,1358,1360,5,49,0,0,1359,1361,5,180,0,0,
  	1360,1359,1,0,0,0,1360,1361,1,0,0,0,1361,1362,1,0,0,0,1362,1369,3,132,
  	66,0,1363,1365,5,144,0,0,1364,1366,5,180,0,0,1365,1364,1,0,0,0,1365,1366,
  	1,0,0,0,1366,1367,1,0,0,0,1367,1369,3,132,66,0,1368,1356,1,0,0,0,1368,
  	1363,1,0,0,0,1369,131,1,0,0,0,1370,1373,3,134,67,0,1371,1373,3,136,68,
  	0,1372,1370,1,0,0,0,1372,1371,1,0,0,0,1373,133,1,0,0,0,1374,1376,3,142,
  	71,0,1375,1377,5,180,0,0,1376,1375,1,0,0,0,1376,1377,1,0,0,0,1377,1379,
  	1,0,0,0,1378,1374,1,0,0,0,1379,1382,1,0,0,0,1380,1378,1,0,0,0,1380,1381,
  	1,0,0,0,1381,1383,1,0,0,0,1382,1380,1,0,0,0,1383,1410,3,174,87,0,1384,
  	1386,3,142,71,0,1385,1387,5,180,0,0,1386,1385,1,0,0,0,1386,1387,1,0,0,
  	0,1387,1389,1,0,0,0,1388,1384,1,0,0,0,1389,1392,1,0,0,0,1390,1388,1,0,
  	0,0,1390,1391,1,0,0,0,1391,1393,1,0,0,0,1392,1390,1,0,0,0,1393,1400,3,
  	140,70,0,1394,1396,5,180,0,0,1395,1394,1,0,0,0,1395,1396,1,0,0,0,1396,
  	1397,1,0,0,0,1397,1399,3,140,70,0,1398,1395,1,0,0,0,1399,1402,1,0,0,0,
  	1400,1398,1,0,0,0,1400,1401,1,0,0,0,1401,1407,1,0,0,0,1402,1400,1,0,0,
  	0,1403,1405,5,180,0,0,1404,1403,1,0,0,0,1404,1405,1,0,0,0,1405,1406,1,
  	0,0,0,1406,1408,3,174,87,0,1407,1404,1,0,0,0,1407,1408,1,0,0,0,1408,1410,
  	1,0,0,0,1409,1380,1,0,0,0,1409,1390,1,0,0,0,1410,135,1,0,0,0,1411,1413,
  	3,138,69,0,1412,1414,5,180,0,0,1413,1412,1,0,0,0,1413,1414,1,0,0,0,1414,
  	1416,1,0,0,0,1415,1411,1,0,0,0,1416,1417,1,0,0,0,1417,1415,1,0,0,0,1417,
  	1418,1,0,0,0,1418,1419,1,0,0,0,1419,1420,3,134,67,0,1420,137,1,0,0,0,
  	1421,1423,3,142,71,0,1422,1424,5,180,0,0,1423,1422,1,0,0,0,1423,1424,
  	1,0,0,0,1424,1426,1,0,0,0,1425,1421,1,0,0,0,1426,1429,1,0,0,0,1427,1425,
  	1,0,0,0,1427,1428,1,0,0,0,1428,1436,1,0,0,0,1429,1427,1,0,0,0,1430,1432,
  	3,140,70,0,1431,1433,5,180,0,0,1432,1431,1,0,0,0,1432,1433,1,0,0,0,1433,
  	1435,1,0,0,0,1434,1430,1,0,0,0,1435,1438,1,0,0,0,1436,1434,1,0,0,0,1436,
  	1437,1,0,0,0,1437,1439,1,0,0,0,1438,1436,1,0,0,0,1439,1440,3,172,86,0,
  	1440,139,1,0,0,0,1441,1446,3,160,80,0,1442,1446,3,162,81,0,1443,1446,
  	3,166,83,0,1444,1446,3,170,85,0,1445,1441,1,0,0,0,1445,1442,1,0,0,0,1445,
  	1443,1,0,0,0,1445,1444,1,0,0,0,1446,141,1,0,0,0,1447,1452,3,152,76,0,
  	1448,1452,3,158,79,0,1449,1452,3,150,75,0,1450,1452,3,144,72,0,1451,1447,
  	1,0,0,0,1451,1448,1,0,0,0,1451,1449,1,0,0,0,1451,1450,1,0,0,0,1452,143,
  	1,0,0,0,1453,1471,5,104,0,0,1454,1455,5,180,0,0,1455,1456,5,151,0,0,1456,
  	1457,5,180,0,0,1457,1459,5,93,0,0,1458,1460,5,180,0,0,1459,1458,1,0,0,
  	0,1459,1460,1,0,0,0,1460,1461,1,0,0,0,1461,1463,5,2,0,0,1462,1464,5,180,
  	0,0,1463,1462,1,0,0,0,1463,1464,1,0,0,0,1464,1465,1,0,0,0,1465,1467,3,
  	92,46,0,1466,1468,5,180,0,0,1467,1466,1,0,0,0,1467,1468,1,0,0,0,1468,
  	1469,1,0,0,0,1469,1470,5,3,0,0,1470,1472,1,0,0,0,1471,1454,1,0,0,0,1471,
  	1472,1,0,0,0,1472,1473,1,0,0,0,1473,1474,5,180,0,0,1474,1475,5,88,0,0,
  	1475,1476,5,180,0,0,1476,1490,3,10,5,0,1477,1479,5,180,0,0,1478,1477,
  	1,0,0,0,1478,1479,1,0,0,0,1479,1480,1,0,0,0,1480,1482,5,2,0,0,1481,1483,
  	5,180,0,0,1482,1481,1,0,0,0,1482,1483,1,0,0,0,1483,1484,1,0,0,0,1484,
  	1486,3,24,12,0,1485,1487,5,180,0,0,1486,1485,1,0,0,0,1486,1487,1,0,0,
  	0,1487,1488,1,0,0,0,1488,1489,5,3,0,0,1489,1491,1,0,0,0,1490,1478,1,0,
  	0,0,1490,1491,1,0,0,0,1491,1496,1,0,0,0,1492,1494,5,180,0,0,1493,1492,
  	1,0,0,0,1493,1494,1,0,0,0,1494,1495,1,0,0,0,1495,1497,3,190,95,0,1496,
  	1493,1,0,0,0,1496,1497,1,0,0,0,1497,145,1,0,0,0,1498,1499,3,322,161,0,
  	1499,1500,5,180,0,0,1500,1501,5,52,0,0,1501,1502,5,180,0,0,1502,1504,
  	1,0,0,0,1503,1498,1,0,0,0,1503,1504,1,0,0,0,1504,1505,1,0,0,0,1505,1506,
  	3,322,161,0,1506,147,1,0,0,0,1507,1518,3,146,73,0,1508,1510,5,180,0,0,
  	1509,1508,1,0,0,0,1509,1510,1,0,0,0,1510,1511,1,0,0,0,1511,1513,5,4,0,
  	0,1512,1514,5,180,0,0,1513,1512,1,0,0,0,1513,1514,1,0,0,0,1514,1515,1,
  	0,0,0,1515,1517,3,146,73,0,1516,1509,1,0,0,0,1517,1520,1,0,0,0,1518,1516,
  	1,0,0,0,1518,1519,1,0,0,0,1519,149,1,0,0,0,1520,1518,1,0,0,0,1521,1522,
  	5,58,0,0,1522,1523,5,180,0,0,1523,1528,3,302,151,0,1524,1526,5,180,0,
  	0,1525,1524,1,0,0,0,1525,1526,1,0,0,0,1526,1527,1,0,0,0,1527,1529,3,190,
  	95,0,1528,1525,1,0,0,0,1528,1529,1,0,0,0,1529,1536,1,0,0,0,1530,1532,
  	5,180,0,0,1531,1530,1,0,0,0,1531,1532,1,0,0,0,1532,1533,1,0,0,0,1533,
  	1534,5,156,0,0,1534,1535,5,180,0,0,1535,1537,3,148,74,0,1536,1531,1,0,
  	0,0,1536,1537,1,0,0,0,1537,151,1,0,0,0,1538,1539,5,119,0,0,1539,1541,
  	5,180,0,0,1540,1538,1,0,0,0,1540,1541,1,0,0,0,1541,1542,1,0,0,0,1542,
  	1544,5,107,0,0,1543,1545,5,180,0,0,1544,1543,1,0,0,0,1544,1545,1,0,0,
  	0,1545,1546,1,0,0,0,1546,1549,3,192,96,0,1547,1548,5,180,0,0,1548,1550,
  	3,190,95,0,1549,1547,1,0,0,0,1549,1550,1,0,0,0,1550,1553,1,0,0,0,1551,
  	1552,5,180,0,0,1552,1554,3,154,77,0,1553,1551,1,0,0,0,1553,1554,1,0,0,
  	0,1554,153,1,0,0,0,1555,1556,5,94,0,0,1556,1557,5,180,0,0,1557,1558,3,
  	156,78,0,1558,155,1,0,0,0,1559,1560,6,78,-1,0,1560,1562,5,2,0,0,1561,
  	1563,5,180,0,0,1562,1561,1,0,0,0,1562,1563,1,0,0,0,1563,1564,1,0,0,0,
  	1564,1566,3,156,78,0,1565,1567,5,180,0,0,1566,1565,1,0,0,0,1566,1567,
  	1,0,0,0,1567,1568,1,0,0,0,1568,1569,5,3,0,0,1569,1572,1,0,0,0,1570,1572,
  	3,336,168,0,1571,1559,1,0,0,0,1571,1570,1,0,0,0,1572,1589,1,0,0,0,1573,
  	1574,10,4,0,0,1574,1575,5,180,0,0,1575,1576,5,101,0,0,1576,1577,5,180,
  	0,0,1577,1588,3,156,78,5,1578,1583,10,3,0,0,1579,1580,5,180,0,0,1580,
  	1581,5,111,0,0,1581,1582,5,180,0,0,1582,1584,3,336,168,0,1583,1579,1,
  	0,0,0,1584,1585,1,0,0,0,1585,1583,1,0,0,0,1585,1586,1,0,0,0,1586,1588,
  	1,0,0,0,1587,1573,1,0,0,0,1587,1578,1,0,0,0,1588,1591,1,0,0,0,1589,1587,
  	1,0,0,0,1589,1590,1,0,0,0,1590,157,1,0,0,0,1591,1589,1,0,0,0,1592,1594,
  	5,145,0,0,1593,1595,5,180,0,0,1594,1593,1,0,0,0,1594,1595,1,0,0,0,1595,
  	1596,1,0,0,0,1596,1597,3,234,117,0,1597,1598,5,180,0,0,1598,1599,5,52,
  	0,0,1599,1600,5,180,0,0,1600,1601,3,322,161,0,1601,159,1,0,0,0,1602,1604,
  	5,69,0,0,1603,1605,5,180,0,0,1604,1603,1,0,0,0,1604,1605,1,0,0,0,1605,
  	1606,1,0,0,0,1606,1607,3,192,96,0,1607,161,1,0,0,0,1608,1610,5,109,0,
  	0,1609,1611,5,180,0,0,1610,1609,1,0,0,0,1610,1611,1,0,0,0,1611,1612,1,
  	0,0,0,1612,1617,3,192,96,0,1613,1614,5,180,0,0,1614,1616,3,164,82,0,1615,
  	1613,1,0,0,0,1616,1619,1,0,0,0,1617,1615,1,0,0,0,1617,1618,1,0,0,0,1618,
  	163,1,0,0,0,1619,1617,1,0,0,0,1620,1621,5,117,0,0,1621,1622,5,180,0,0,
  	1622,1623,5,107,0,0,1623,1624,5,180,0,0,1624,1631,3,166,83,0,1625,1626,
  	5,117,0,0,1626,1627,5,180,0,0,1627,1628,5,69,0,0,1628,1629,5,180,0,0,
  	1629,1631,3,166,83,0,1630,1620,1,0,0,0,1630,1625,1,0,0,0,1631,165,1,0,
  	0,0,1632,1634,5,132,0,0,1633,1635,5,180,0,0,1634,1633,1,0,0,0,1634,1635,
  	1,0,0,0,1635,1636,1,0,0,0,1636,1647,3,168,84,0,1637,1639,5,180,0,0,1638,
  	1637,1,0,0,0,1638,1639,1,0,0,0,1639,1640,1,0,0,0,1640,1642,5,4,0,0,1641,
  	1643,5,180,0,0,1642,1641,1,0,0,0,1642,1643,1,0,0,0,1643,1644,1,0,0,0,
  	1644,1646,3,168,84,0,1645,1638,1,0,0,0,1646,1649,1,0,0,0,1647,1645,1,
  	0,0,0,1647,1648,1,0,0,0,1648,167,1,0,0,0,1649,1647,1,0,0,0,1650,1652,
  	3,328,164,0,1651,1653,5,180,0,0,1652,1651,1,0,0,0,1652,1653,1,0,0,0,1653,
  	1654,1,0,0,0,1654,1656,5,6,0,0,1655,1657,5,180,0,0,1656,1655,1,0,0,0,
  	1656,1657,1,0,0,0,1657,1658,1,0,0,0,1658,1659,3,234,117,0,1659,169,1,
  	0,0,0,1660,1661,5,77,0,0,1661,1663,5,180,0,0,1662,1660,1,0,0,0,1662,1663,
  	1,0,0,0,1663,1664,1,0,0,0,1664,1666,5,74,0,0,1665,1667,5,180,0,0,1666,
  	1665,1,0,0,0,1666,1667,1,0,0,0,1667,1668,1,0,0,0,1668,1679,3,234,117,
  	0,1669,1671,5,180,0,0,1670,1669,1,0,0,0,1670,1671,1,0,0,0,1671,1672,1,
  	0,0,0,1672,1674,5,4,0,0,1673,1675,5,180,0,0,1674,1673,1,0,0,0,1674,1675,
  	1,0,0,0,1675,1676,1,0,0,0,1676,1678,3,234,117,0,1677,1670,1,0,0,0,1678,
  	1681,1,0,0,0,1679,1677,1,0,0,0,1679,1680,1,0,0,0,1680,171,1,0,0,0,1681,
  	1679,1,0,0,0,1682,1683,5,151,0,0,1683,1688,3,176,88,0,1684,1686,5,180,
  	0,0,1685,1684,1,0,0,0,1685,1686,1,0,0,0,1686,1687,1,0,0,0,1687,1689,3,
  	190,95,0,1688,1685,1,0,0,0,1688,1689,1,0,0,0,1689,173,1,0,0,0,1690,1691,
  	5,128,0,0,1691,1692,3,176,88,0,1692,175,1,0,0,0,1693,1695,5,180,0,0,1694,
  	1693,1,0,0,0,1694,1695,1,0,0,0,1695,1696,1,0,0,0,1696,1698,5,78,0,0,1697,
  	1694,1,0,0,0,1697,1698,1,0,0,0,1698,1699,1,0,0,0,1699,1700,5,180,0,0,
  	1700,1703,3,178,89,0,1701,1702,5,180,0,0,1702,1704,3,182,91,0,1703,1701,
  	1,0,0,0,1703,1704,1,0,0,0,1704,1707,1,0,0,0,1705,1706,5,180,0,0,1706,
  	1708,3,184,92,0,1707,1705,1,0,0,0,1707,1708,1,0,0,0,1708,1711,1,0,0,0,
  	1709,1710,5,180,0,0,1710,1712,3,186,93,0,1711,1709,1,0,0,0,1711,1712,
  	1,0,0,0,1712,177,1,0,0,0,1713,1724,5,159,0,0,1714,1716,5,180,0,0,1715,
  	1714,1,0,0,0,1715,1716,1,0,0,0,1716,1717,1,0,0,0,1717,1719,5,4,0,0,1718,
  	1720,5,180,0,0,1719,1718,1,0,0,0,1719,1720,1,0,0,0,1720,1721,1,0,0,0,
  	1721,1723,3,180,90,0,1722,1715,1,0,0,0,1723,1726,1,0,0,0,1724,1722,1,
  	0,0,0,1724,1725,1,0,0,0,1725,1742,1,0,0,0,1726,1724,1,0,0,0,1727,1738,
  	3,180,90,0,1728,1730,5,180,0,0,1729,1728,1,0,0,0,1729,1730,1,0,0,0,1730,
  	1731,1,0,0,0,1731,1733,5,4,0,0,1732,1734,5,180,0,0,1733,1732,1,0,0,0,
  	1733,1734,1,0,0,0,1734,1735,1,0,0,0,1735,1737,3,180,90,0,1736,1729,1,
  	0,0,0,1737,1740,1,0,0,0,1738,1736,1,0,0,0,1738,1739,1,0,0,0,1739,1742,
  	1,0,0,0,1740,1738,1,0,0,0,1741,1713,1,0,0,0,1741,1727,1,0,0,0,1742,179,
  	1,0,0,0,1743,1744,3,234,117,0,1744,1745,5,180,0,0,1745,1746,5,52,0,0,
  	1746,1747,5,180,0,0,1747,1748,3,322,161,0,1748,1751,1,0,0,0,1749,1751,
  	3,234,117,0,1750,1743,1,0,0,0,1750,1749,1,0,0,0,1751,181,1,0,0,0,1752,
  	1753,5,121,0,0,1753,1754,5,180,0,0,1754,1755,5,57,0,0,1755,1756,5,180,
  	0,0,1756,1764,3,188,94,0,1757,1759,5,4,0,0,1758,1760,5,180,0,0,1759,1758,
  	1,0,0,0,1759,1760,1,0,0,0,1760,1761,1,0,0,0,1761,1763,3,188,94,0,1762,
  	1757,1,0,0,0,1763,1766,1,0,0,0,1764,1762,1,0,0,0,1764,1765,1,0,0,0,1765,
  	183,1,0,0,0,1766,1764,1,0,0,0,1767,1768,5,160,0,0,1768,1769,5,180,0,0,
  	1769,1770,3,234,117,0,1770,185,1,0,0,0,1771,1772,5,103,0,0,1772,1773,
  	5,180,0,0,1773,1774,3,234,117,0,1774,187,1,0,0,0,1775,1780,3,234,117,
  	0,1776,1778,5,180,0,0,1777,1776,1,0,0,0,1777,1778,1,0,0,0,1778,1779,1,
  	0,0,0,1779,1781,7,1,0,0,1780,1777,1,0,0,0,1780,1781,1,0,0,0,1781,189,
  	1,0,0,0,1782,1783,5,150,0,0,1783,1784,5,180,0,0,1784,1785,3,234,117,0,
  	1785,191,1,0,0,0,1786,1797,3,194,97,0,1787,1789,5,180,0,0,1788,1787,1,
  	0,0,0,1788,1789,1,0,0,0,1789,1790,1,0,0,0,1790,1792,5,4,0,0,1791,1793,
  	5,180,0,0,1792,1791,1,0,0,0,1792,1793,1,0,0,0,1793,1794,1,0,0,0,1794,
  	1796,3,194,97,0,1795,1788,1,0,0,0,1796,1799,1,0,0,0,1797,1795,1,0,0,0,
  	1797,1798,1,0,0,0,1798,193,1,0,0,0,1799,1797,1,0,0,0,1800,1802,3,322,
  	161,0,1801,1803,5,180,0,0,1802,1801,1,0,0,0,1802,1803,1,0,0,0,1803,1804,
  	1,0,0,0,1804,1806,5,6,0,0,1805,1807,5,180,0,0,1806,1805,1,0,0,0,1806,
  	1807,1,0,0,0,1807,1808,1,0,0,0,1808,1809,3,196,98,0,1809,1812,1,0,0,0,
  	1810,1812,3,196,98,0,1811,1800,1,0,0,0,1811,1810,1,0,0,0,1812,195,1,0,
  	0,0,1813,1814,3,198,99,0,1814,197,1,0,0,0,1815,1822,3,200,100,0,1816,
  	1818,5,180,0,0,1817,1816,1,0,0,0,1817,1818,1,0,0,0,1818,1819,1,0,0,0,
  	1819,1821,3,202,101,0,1820,1817,1,0,0,0,1821,1824,1,0,0,0,1822,1820,1,
  	0,0,0,1822,1823,1,0,0,0,1823,1830,1,0,0,0,1824,1822,1,0,0,0,1825,1826,
  	5,2,0,0,1826,1827,3,198,99,0,1827,1828,5,3,0,0,1828,1830,1,0,0,0,1829,
  	1815,1,0,0,0,1829,1825,1,0,0,0,1830,199,1,0,0,0,1831,1833,5,2,0,0,1832,
  	1834,5,180,0,0,1833,1832,1,0,0,0,1833,1834,1,0,0,0,1834,1839,1,0,0,0,
  	1835,1837,3,322,161,0,1836,1838,5,180,0,0,1837,1836,1,0,0,0,1837,1838,
  	1,0,0,0,1838,1840,1,0,0,0,1839,1835,1,0,0,0,1839,1840,1,0,0,0,1840,1845,
  	1,0,0,0,1841,1843,3,212,106,0,1842,1844,5,180,0,0,1843,1842,1,0,0,0,1843,
  	1844,1,0,0,0,1844,1846,1,0,0,0,1845,1841,1,0,0,0,1845,1846,1,0,0,0,1846,
  	1851,1,0,0,0,1847,1849,3,208,104,0,1848,1850,5,180,0,0,1849,1848,1,0,
  	0,0,1849,1850,1,0,0,0,1850,1852,1,0,0,0,1851,1847,1,0,0,0,1851,1852,1,
  	0,0,0,1852,1853,1,0,0,0,1853,1854,5,3,0,0,1854,201,1,0,0,0,1855,1857,
  	3,204,102,0,1856,1858,5,180,0,0,1857,1856,1,0,0,0,1857,1858,1,0,0,0,1858,
  	1859,1,0,0,0,1859,1860,3,200,100,0,1860,203,1,0,0,0,1861,1863,3,342,171,
  	0,1862,1864,5,180,0,0,1863,1862,1,0,0,0,1863,1864,1,0,0,0,1864,1865,1,
  	0,0,0,1865,1867,3,346,173,0,1866,1868,5,180,0,0,1867,1866,1,0,0,0,1867,
  	1868,1,0,0,0,1868,1870,1,0,0,0,1869,1871,3,206,103,0,1870,1869,1,0,0,
  	0,1870,1871,1,0,0,0,1871,1873,1,0,0,0,1872,1874,5,180,0,0,1873,1872,1,
  	0,0,0,1873,1874,1,0,0,0,1874,1875,1,0,0,0,1875,1876,3,346,173,0,1876,
  	1906,1,0,0,0,1877,1879,3,346,173,0,1878,1880,5,180,0,0,1879,1878,1,0,
  	0,0,1879,1880,1,0,0,0,1880,1882,1,0,0,0,1881,1883,3,206,103,0,1882,1881,
  	1,0,0,0,1882,1883,1,0,0,0,1883,1885,1,0,0,0,1884,1886,5,180,0,0,1885,
  	1884,1,0,0,0,1885,1886,1,0,0,0,1886,1887,1,0,0,0,1887,1889,3,346,173,
  	0,1888,1890,5,180,0,0,1889,1888,1,0,0,0,1889,1890,1,0,0,0,1890,1891,1,
  	0,0,0,1891,1892,3,344,172,0,1892,1906,1,0,0,0,1893,1895,3,346,173,0,1894,
  	1896,5,180,0,0,1895,1894,1,0,0,0,1895,1896,1,0,0,0,1896,1898,1,0,0,0,
  	1897,1899,3,206,103,0,1898,1897,1,0,0,0,1898,1899,1,0,0,0,1899,1901,1,
  	0,0,0,1900,1902,5,180,0,0,1901,1900,1,0,0,0,1901,1902,1,0,0,0,1902,1903,
  	1,0,0,0,1903,1904,3,346,173,0,1904,1906,1,0,0,0,1905,1861,1,0,0,0,1905,
  	1877,1,0,0,0,1905,1893,1,0,0,0,1906,205,1,0,0,0,1907,1909,5,7,0,0,1908,
  	1910,5,180,0,0,1909,1908,1,0,0,0,1909,1910,1,0,0,0,1910,1915,1,0,0,0,
  	1911,1913,3,322,161,0,1912,1914,5,180,0,0,1913,1912,1,0,0,0,1913,1914,
  	1,0,0,0,1914,1916,1,0,0,0,1915,1911,1,0,0,0,1915,1916,1,0,0,0,1916,1921,
  	1,0,0,0,1917,1919,3,210,105,0,1918,1920,5,180,0,0,1919,1918,1,0,0,0,1919,
  	1920,1,0,0,0,1920,1922,1,0,0,0,1921,1917,1,0,0,0,1921,1922,1,0,0,0,1922,
  	1927,1,0,0,0,1923,1925,3,216,108,0,1924,1926,5,180,0,0,1925,1924,1,0,
  	0,0,1925,1926,1,0,0,0,1926,1928,1,0,0,0,1927,1923,1,0,0,0,1927,1928,1,
  	0,0,0,1928,1933,1,0,0,0,1929,1931,3,208,104,0,1930,1932,5,180,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,1933,
  	1934,1,0,0,0,1934,1935,1,0,0,0,1935,1936,5,8,0,0,1936,207,1,0,0,0,1937,
  	1939,5,9,0,0,1938,1940,5,180,0,0,1939,1938,1,0,0,0,1939,1940,1,0,0,0,
  	1940,1974,1,0,0,0,1941,1943,3,330,165,0,1942,1944,5,180,0,0,1943,1942,
  	1,0,0,0,1943,1944,1,0,0,0,1944,1945,1,0,0,0,1945,1947,5,162,0,0,1946,
  	1948,5,180,0,0,1947,1946,1,0,0,0,1947,1948,1,0,0,0,1948,1949,1,0,0,0,
  	1949,1951,3,234,117,0,1950,1952,5,180,0,0,1951,1950,1,0,0,0,1951,1952,
  	1,0,0,0,1952,1971,1,0,0,0,1953,1955,5,4,0,0,1954,1956,5,180,0,0,1955,
  	1954,1,0,0,0,1955,1956,1,0,0,0,1956,1957,1,0,0,0,1957,1959,3,330,165,
  	0,1958,1960,5,180,0,0,1959,1958,1,0,0,0,1959,1960,1,0,0,0,1960,1961,1,
  	0,0,0,1961,1963,5,162,0,0,1962,1964,5,180,0,0,1963,1962,1,0,0,0,1963,
  	1964,1,0,0,0,1964,1965,1,0,0,0,1965,1967,3,234,117,0,1966,1968,5,180,
  	0,0,1967,1966,1,0,0,0,1967,1968,1,0,0,0,1968,1970,1,0,0,0,1969,1953,1,
  	0,0,0,1970,1973,1,0,0,0,1971,1969,1,0,0,0,1971,1972,1,0,0,0,1972,1975,
  	1,0,0,0,1973,1971,1,0,0,0,1974,1941,1,0,0,0,1974,1975,1,0,0,0,1975,1976,
  	1,0,0,0,1976,1977,5,10,0,0,1977,209,1,0,0,0,1978,1980,5,162,0,0,1979,
  	1981,5,180,0,0,1980,1979,1,0,0,0,1980,1981,1,0,0,0,1981,1982,1,0,0,0,
  	1982,1996,3,232,116,0,1983,1985,5,180,0,0,1984,1983,1,0,0,0,1984,1985,
  	1,0,0,0,1985,1986,1,0,0,0,1986,1988,5,11,0,0,1987,1989,5,162,0,0,1988,
  	1987,1,0,0,0,1988,1989,1,0,0,0,1989,1991,1,0,0,0,1990,1992,5,180,0,0,
  	1991,1990,1,0,0,0,1991,1992,1,0,0,0,1992,1993,1,0,0,0,1993,1995,3,232,
  	116,0,1994,1984,1,0,0,0,1995,1998,1,0,0,0,1996,1994,1,0,0,0,1996,1997,
  	1,0,0,0,1997,211,1,0,0,0,1998,1996,1,0,0,0,1999,2006,3,214,107,0,2000,
  	2002,5,180,0,0,2001,2000,1,0,0,0,2001,2002,1,0,0,0,2002,2003,1,0,0,0,
  	2003,2005,3,214,107,0,2004,2001,1,0,0,0,2005,2008,1,0,0,0,2006,2004,1,
  	0,0,0,2006,2007,1,0,0,0,2007,213,1,0,0,0,2008,2006,1,0,0,0,2009,2011,
  	5,162,0,0,2010,2012,5,180,0,0,2011,2010,1,0,0,0,2011,2012,1,0,0,0,2012,
  	2013,1,0,0,0,2013,2014,3,230,115,0,2014,215,1,0,0,0,2015,2020,5,159,0,
  	0,2016,2018,5,180,0,0,2017,2016,1,0,0,0,2017,2018,1,0,0,0,2018,2019,1,
  	0,0,0,2019,2021,3,218,109,0,2020,2017,1,0,0,0,2020,2021,1,0,0,0,2021,
  	2026,1,0,0,0,2022,2024,5,180,0,0,2023,2022,1,0,0,0,2023,2024,1,0,0,0,
  	2024,2025,1,0,0,0,2025,2027,3,220,110,0,2026,2023,1,0,0,0,2026,2027,1,
  	0,0,0,2027,2032,1,0,0,0,2028,2030,5,180,0,0,2029,2028,1,0,0,0,2029,2030,
  	1,0,0,0,2030,2031,1,0,0,0,2031,2033,3,222,111,0,2032,2029,1,0,0,0,2032,
  	2033,1,0,0,0,2033,217,1,0,0,0,2034,2035,5,49,0,0,2035,2037,5,180,0,0,
  	2036,2034,1,0,0,0,2036,2037,1,0,0,0,2037,2038,1,0,0,0,2038,2040,5,153,
  	0,0,2039,2041,5,180,0,0,2040,2039,1,0,0,0,2040,2041,1,0,0,0,2041,2042,
  	1,0,0,0,2042,2044,5,2,0,0,2043,2045,5,180,0,0,2044,2043,1,0,0,0,2044,
  	2045,1,0,0,0,2045,2046,1,0,0,0,2046,2048,3,330,165,0,2047,2049,5,180,
  	0,0,2048,2047,1,0,0,0,2048,2049,1,0,0,0,2049,2050,1,0,0,0,2050,2051,5,
  	3,0,0,2051,2059,1,0,0,0,2052,2059,5,133,0,0,2053,2054,5,49,0,0,2054,2055,
  	5,180,0,0,2055,2059,5,133,0,0,2056,2059,5,140,0,0,2057,2059,5,46,0,0,
  	2058,2036,1,0,0,0,2058,2052,1,0,0,0,2058,2053,1,0,0,0,2058,2056,1,0,0,
  	0,2058,2057,1,0,0,0,2059,219,1,0,0,0,2060,2062,3,226,113,0,2061,2060,
  	1,0,0,0,2061,2062,1,0,0,0,2062,2064,1,0,0,0,2063,2065,5,180,0,0,2064,
  	2063,1,0,0,0,2064,2065,1,0,0,0,2065,2066,1,0,0,0,2066,2068,5,12,0,0,2067,
  	2069,5,180,0,0,2068,2067,1,0,0,0,2068,2069,1,0,0,0,2069,2071,1,0,0,0,
  	2070,2072,3,228,114,0,2071,2070,1,0,0,0,2071,2072,1,0,0,0,2072,2075,1,
  	0,0,0,2073,2075,3,332,166,0,2074,2061,1,0,0,0,2074,2073,1,0,0,0,2075,
  	221,1,0,0,0,2076,2078,5,2,0,0,2077,2079,5,180,0,0,2078,2077,1,0,0,0,2078,
  	2079,1,0,0,0,2079,2080,1,0,0,0,2080,2082,3,322,161,0,2081,2083,5,180,
  	0,0,2082,2081,1,0,0,0,2082,2083,1,0,0,0,2083,2084,1,0,0,0,2084,2086,5,
  	4,0,0,2085,2087,5,180,0,0,2086,2085,1,0,0,0,2086,2087,1,0,0,0,2087,2088,
  	1,0,0,0,2088,2100,3,322,161,0,2089,2091,5,180,0,0,2090,2089,1,0,0,0,2090,
  	2091,1,0,0,0,2091,2092,1,0,0,0,2092,2094,5,11,0,0,2093,2095,5,180,0,0,
  	2094,2093,1,0,0,0,2094,2095,1,0,0,0,2095,2096,1,0,0,0,2096,2098,3,190,
  	95,0,2097,2099,5,180,0,0,2098,2097,1,0,0,0,2098,2099,1,0,0,0,2099,2101,
  	1,0,0,0,2100,2090,1,0,0,0,2100,2101,1,0,0,0,2101,2121,1,0,0,0,2102,2104,
  	5,180,0,0,2103,2102,1,0,0,0,2103,2104,1,0,0,0,2104,2105,1,0,0,0,2105,
  	2107,5,11,0,0,2106,2108,5,180,0,0,2107,2106,1,0,0,0,2107,2108,1,0,0,0,
  	2108,2109,1,0,0,0,2109,2111,3,224,112,0,2110,2112,5,180,0,0,2111,2110,
  	1,0,0,0,2111,2112,1,0,0,0,2112,2113,1,0,0,0,2113,2115,5,4,0,0,2114,2116,
  	5,180,0,0,2115,2114,1,0,0,0,2115,2116,1,0,0,0,2116,2117,1,0,0,0,2117,
  	2119,3,224,112,0,2118,2120,5,180,0,0,2119,2118,1,0,0,0,2119,2120,1,0,
  	0,0,2120,2122,1,0,0,0,2121,2103,1,0,0,0,2121,2122,1,0,0,0,2122,2123,1,
  	0,0,0,2123,2124,5,3,0,0,2124,223,1,0,0,0,2125,2127,5,9,0,0,2126,2128,
  	5,180,0,0,2127,2126,1,0,0,0,2127,2128,1,0,0,0,2128,2130,1,0,0,0,2129,
  	2131,3,178,89,0,2130,2129,1,0,0,0,2130,2131,1,0,0,0,2131,2133,1,0,0,0,
  	2132,2134,5,180,0,0,2133,2132,1,0,0,0,2133,2134,1,0,0,0,2134,2135,1,0,
  	0,0,2135,2136,5,10,0,0,2136,225,1,0,0,0,2137,2138,5,167,0,0,2138,227,
  	1,0,0,0,2139,2140,5,167,0,0,2140,229,1,0,0,0,2141,2142,3,336,168,0,2142,
  	231,1,0,0,0,2143,2144,3,336,168,0,2144,233,1,0,0,0,2145,2146,3,236,118,
  	0,2146,235,1,0,0,0,2147,2154,3,238,119,0,2148,2149,5,180,0,0,2149,2150,
  	5,120,0,0,2150,2151,5,180,0,0,2151,2153,3,238,119,0,2152,2148,1,0,0,0,
  	2153,2156,1,0,0,0,2154,2152,1,0,0,0,2154,2155,1,0,0,0,2155,237,1,0,0,
  	0,2156,2154,1,0,0,0,2157,2164,3,240,120,0,2158,2159,5,180,0,0,2159,2160,
  	5,154,0,0,2160,2161,5,180,0,0,2161,2163,3,240,120,0,2162,2158,1,0,0,0,
  	2163,2166,1,0,0,0,2164,2162,1,0,0,0,2164,2165,1,0,0,0,2165,239,1,0,0,
  	0,2166,2164,1,0,0,0,2167,2174,3,242,121,0,2168,2169,5,180,0,0,2169,2170,
  	5,51,0,0,2170,2171,5,180,0,0,2171,2173,3,242,121,0,2172,2168,1,0,0,0,
  	2173,2176,1,0,0,0,2174,2172,1,0,0,0,2174,2175,1,0,0,0,2175,241,1,0,0,
  	0,2176,2174,1,0,0,0,2177,2179,5,114,0,0,2178,2180,5,180,0,0,2179,2178,
  	1,0,0,0,2179,2180,1,0,0,0,2180,2182,1,0,0,0,2181,2177,1,0,0,0,2182,2185,
  	1,0,0,0,2183,2181,1,0,0,0,2183,2184,1,0,0,0,2184,2186,1,0,0,0,2185,2183,
  	1,0,0,0,2186,2187,3,244,122,0,2187,243,1,0,0,0,2188,2198,3,248,124,0,
  	2189,2191,5,180,0,0,2190,2189,1,0,0,0,2190,2191,1,0,0,0,2191,2192,1,0,
  	0,0,2192,2194,3,246,123,0,2193,2195,5,180,0,0,2194,2193,1,0,0,0,2194,
  	2195,1,0,0,0,2195,2196,1,0,0,0,2196,2197,3,248,124,0,2197,2199,1,0,0,
  	0,2198,2190,1,0,0,0,2198,2199,1,0,0,0,2199,2237,1,0,0,0,2200,2202,3,248,
  	124,0,2201,2203,5,180,0,0,2202,2201,1,0,0,0,2202,2203,1,0,0,0,2203,2204,
  	1,0,0,0,2204,2206,5,161,0,0,2205,2207,5,180,0,0,2206,2205,1,0,0,0,2206,
  	2207,1,0,0,0,2207,2208,1,0,0,0,2208,2209,3,248,124,0,2209,2210,1,0,0,
  	0,2210,2211,6,122,-1,0,2211,2237,1,0,0,0,2212,2214,3,248,124,0,2213,2215,
  	5,180,0,0,2214,2213,1,0,0,0,2214,2215,1,0,0,0,2215,2216,1,0,0,0,2216,
  	2218,3,246,123,0,2217,2219,5,180,0,0,2218,2217,1,0,0,0,2218,2219,1,0,
  	0,0,2219,2220,1,0,0,0,2220,2230,3,248,124,0,2221,2223,5,180,0,0,2222,
  	2221,1,0,0,0,2222,2223,1,0,0,0,2223,2224,1,0,0,0,2224,2226,3,246,123,
  	0,2225,2227,5,180,0,0,2226,2225,1,0,0,0,2226,2227,1,0,0,0,2227,2228,1,
  	0,0,0,2228,2229,3,248,124,0,2229,2231,1,0,0,0,2230,2222,1,0,0,0,2231,
  	2232,1,0,0,0,2232,2230,1,0,0,0,2232,2233,1,0,0,0,2233,2234,1,0,0,0,2234,
  	2235,6,122,-1,0,2235,2237,1,0,0,0,2236,2188,1,0,0,0,2236,2200,1,0,0,0,
  	2236,2212,1,0,0,0,2237,245,1,0,0,0,2238,2239,7,2,0,0,2239,247,1,0,0,0,
  	2240,2251,3,250,125,0,2241,2243,5,180,0,0,2242,2241,1,0,0,0,2242,2243,
  	1,0,0,0,2243,2244,1,0,0,0,2244,2246,5,11,0,0,2245,2247,5,180,0,0,2246,
  	2245,1,0,0,0,2246,2247,1,0,0,0,2247,2248,1,0,0,0,2248,2250,3,250,125,
  	0,2249,2242,1,0,0,0,2250,2253,1,0,0,0,2251,2249,1,0,0,0,2251,2252,1,0,
  	0,0,2252,249,1,0,0,0,2253,2251,1,0,0,0,2254,2265,3,252,126,0,2255,2257,
  	5,180,0,0,2256,2255,1,0,0,0,2256,2257,1,0,0,0,2257,2258,1,0,0,0,2258,
  	2260,5,18,0,0,2259,2261,5,180,0,0,2260,2259,1,0,0,0,2260,2261,1,0,0,0,
  	2261,2262,1,0,0,0,2262,2264,3,252,126,0,2263,2256,1,0,0,0,2264,2267,1,
  	0,0,0,2265,2263,1,0,0,0,2265,2266,1,0,0,0,2266,251,1,0,0,0,2267,2265,
  	1,0,0,0,2268,2280,3,256,128,0,2269,2271,5,180,0,0,2270,2269,1,0,0,0,2270,
  	2271,1,0,0,0,2271,2272,1,0,0,0,2272,2274,3,254,127,0,2273,2275,5,180,
  	0,0,2274,2273,1,0,0,0,2274,2275,1,0,0,0,2275,2276,1,0,0,0,2276,2277,3,
  	256,128,0,2277,2279,1,0,0,0,2278,2270,1,0,0,0,2279,2282,1,0,0,0,2280,
  	2278,1,0,0,0,2280,2281,1,0,0,0,2281,253,1,0,0,0,2282,2280,1,0,0,0,2283,
  	2284,7,3,0,0,2284,255,1,0,0,0,2285,2297,3,260,130,0,2286,2288,5,180,0,
  	0,2287,2286,1,0,0,0,2287,2288,1,0,0,0,2288,2289,1,0,0,0,2289,2291,3,258,
  	129,0,2290,2292,5,180,0,0,2291,2290,1,0,0,0,2291,2292,1,0,0,0,2292,2293,
  	1,0,0,0,2293,2294,3,260,130,0,2294,2296,1,0,0,0,2295,2287,1,0,0,0,2296,
  	2299,1,0,0,0,2297,2295,1,0,0,0,2297,2298,1,0,0,0,2298,257,1,0,0,0,2299,
  	2297,1,0,0,0,2300,2301,7,4,0,0,2301,259,1,0,0,0,2302,2314,3,264,132,0,
  	2303,2305,5,180,0,0,2304,2303,1,0,0,0,2304,2305,1,0,0,0,2305,2306,1,0,
  	0,0,2306,2308,3,262,131,0,2307,2309,5,180,0,0,2308,2307,1,0,0,0,2308,
  	2309,1,0,0,0,2309,2310,1,0,0,0,2310,2311,3,264,132,0,2311,2313,1,0,0,
  	0,2312,2304,1,0,0,0,2313,2316,1,0,0,0,2314,2312,1,0,0,0,2314,2315,1,0,
  	0,0,2315,261,1,0,0,0,2316,2314,1,0,0,0,2317,2318,7,5,0,0,2318,263,1,0,
  	0,0,2319,2330,3,266,133,0,2320,2322,5,180,0,0,2321,2320,1,0,0,0,2321,
  	2322,1,0,0,0,2322,2323,1,0,0,0,2323,2325,5,24,0,0,2324,2326,5,180,0,0,
  	2325,2324,1,0,0,0,2325,2326,1,0,0,0,2326,2327,1,0,0,0,2327,2329,3,266,
  	133,0,2328,2321,1,0,0,0,2329,2332,1,0,0,0,2330,2328,1,0,0,0,2330,2331,
  	1,0,0,0,2331,265,1,0,0,0,2332,2330,1,0,0,0,2333,2341,3,276,138,0,2334,
  	2342,3,270,135,0,2335,2337,3,268,134,0,2336,2335,1,0,0,0,2337,2338,1,
  	0,0,0,2338,2336,1,0,0,0,2338,2339,1,0,0,0,2339,2342,1,0,0,0,2340,2342,
  	3,274,137,0,2341,2334,1,0,0,0,2341,2336,1,0,0,0,2341,2340,1,0,0,0,2341,
  	2342,1,0,0,0,2342,267,1,0,0,0,2343,2344,5,180,0,0,2344,2346,5,97,0,0,
  	2345,2347,5,180,0,0,2346,2345,1,0,0,0,2346,2347,1,0,0,0,2347,2348,1,0,
  	0,0,2348,2363,3,278,139,0,2349,2350,5,7,0,0,2350,2351,3,234,117,0,2351,
  	2352,5,8,0,0,2352,2363,1,0,0,0,2353,2355,5,7,0,0,2354,2356,3,234,117,
  	0,2355,2354,1,0,0,0,2355,2356,1,0,0,0,2356,2357,1,0,0,0,2357,2359,5,162,
  	0,0,2358,2360,3,234,117,0,2359,2358,1,0,0,0,2359,2360,1,0,0,0,2360,2361,
  	1,0,0,0,2361,2363,5,8,0,0,2362,2343,1,0,0,0,2362,2349,1,0,0,0,2362,2353,
  	1,0,0,0,2363,269,1,0,0,0,2364,2376,3,272,136,0,2365,2366,5,180,0,0,2366,
  	2367,5,135,0,0,2367,2368,5,180,0,0,2368,2376,5,151,0,0,2369,2370,5,180,
  	0,0,2370,2371,5,82,0,0,2371,2372,5,180,0,0,2372,2376,5,151,0,0,2373,2374,
  	5,180,0,0,2374,2376,5,66,0,0,2375,2364,1,0,0,0,2375,2365,1,0,0,0,2375,
  	2369,1,0,0,0,2375,2373,1,0,0,0,2376,2378,1,0,0,0,2377,2379,5,180,0,0,
  	2378,2377,1,0,0,0,2378,2379,1,0,0,0,2379,2380,1,0,0,0,2380,2381,3,278,
  	139,0,2381,271,1,0,0,0,2382,2384,5,180,0,0,2383,2382,1,0,0,0,2383,2384,
  	1,0,0,0,2384,2385,1,0,0,0,2385,2386,5,25,0,0,2386,273,1,0,0,0,2387,2388,
  	5,180,0,0,2388,2389,5,100,0,0,2389,2390,5,180,0,0,2390,2398,5,116,0,0,
  	2391,2392,5,180,0,0,2392,2393,5,100,0,0,2393,2394,5,180,0,0,2394,2395,
  	5,114,0,0,2395,2396,5,180,0,0,2396,2398,5,116,0,0,2397,2387,1,0,0,0,2397,
  	2391,1,0,0,0,2398,275,1,0,0,0,2399,2401,5,163,0,0,2400,2402,5,180,0,0,
  	2401,2400,1,0,0,0,2401,2402,1,0,0,0,2402,2404,1,0,0,0,2403,2399,1,0,0,
  	0,2404,2407,1,0,0,0,2405,2403,1,0,0,0,2405,2406,1,0,0,0,2406,2408,1,0,
  	0,0,2407,2405,1,0,0,0,2408,2413,3,278,139,0,2409,2411,5,180,0,0,2410,
  	2409,1,0,0,0,2410,2411,1,0,0,0,2411,2412,1,0,0,0,2412,2414,5,164,0,0,
  	2413,2410,1,0,0,0,2413,2414,1,0,0,0,2414,277,1,0,0,0,2415,2422,3,280,
  	140,0,2416,2418,5,180,0,0,2417,2416,1,0,0,0,2417,2418,1,0,0,0,2418,2419,
  	1,0,0,0,2419,2421,3,316,158,0,2420,2417,1,0,0,0,2421,2424,1,0,0,0,2422,
  	2420,1,0,0,0,2422,2423,1,0,0,0,2423,279,1,0,0,0,2424,2422,1,0,0,0,2425,
  	2435,3,288,144,0,2426,2435,3,326,163,0,2427,2435,3,318,159,0,2428,2435,
  	3,300,150,0,2429,2435,3,302,151,0,2430,2435,3,312,156,0,2431,2435,3,314,
  	157,0,2432,2435,3,322,161,0,2433,2435,3,282,141,0,2434,2425,1,0,0,0,2434,
  	2426,1,0,0,0,2434,2427,1,0,0,0,2434,2428,1,0,0,0,2434,2429,1,0,0,0,2434,
  	2430,1,0,0,0,2434,2431,1,0,0,0,2434,2432,1,0,0,0,2434,2433,1,0,0,0,2435,
  	281,1,0,0,0,2436,2438,5,49,0,0,2437,2439,5,180,0,0,2438,2437,1,0,0,0,
  	2438,2439,1,0,0,0,2439,2440,1,0,0,0,2440,2442,5,2,0,0,2441,2443,5,180,
  	0,0,2442,2441,1,0,0,0,2442,2443,1,0,0,0,2443,2444,1,0,0,0,2444,2446,3,
  	284,142,0,2445,2447,5,180,0,0,2446,2445,1,0,0,0,2446,2447,1,0,0,0,2447,
  	2448,1,0,0,0,2448,2449,5,3,0,0,2449,2493,1,0,0,0,2450,2452,5,47,0,0,2451,
  	2453,5,180,0,0,2452,2451,1,0,0,0,2452,2453,1,0,0,0,2453,2454,1,0,0,0,
  	2454,2456,5,2,0,0,2455,2457,5,180,0,0,2456,2455,1,0,0,0,2456,2457,1,0,
  	0,0,2457,2458,1,0,0,0,2458,2460,3,284,142,0,2459,2461,5,180,0,0,2460,
  	2459,1,0,0,0,2460,2461,1,0,0,0,2461,2462,1,0,0,0,2462,2463,5,3,0,0,2463,
  	2493,1,0,0,0,2464,2466,5,115,0,0,2465,2467,5,180,0,0,2466,2465,1,0,0,
  	0,2466,2467,1,0,0,0,2467,2468,1,0,0,0,2468,2470,5,2,0,0,2469,2471,5,180,
  	0,0,2470,2469,1,0,0,0,2470,2471,1,0,0,0,2471,2472,1,0,0,0,2472,2474,3,
  	284,142,0,2473,2475,5,180,0,0,2474,2473,1,0,0,0,2474,2475,1,0,0,0,2475,
  	2476,1,0,0,0,2476,2477,5,3,0,0,2477,2493,1,0,0,0,2478,2480,5,155,0,0,
  	2479,2481,5,180,0,0,2480,2479,1,0,0,0,2480,2481,1,0,0,0,2481,2482,1,0,
  	0,0,2482,2484,5,2,0,0,2483,2485,5,180,0,0,2484,2483,1,0,0,0,2484,2485,
  	1,0,0,0,2485,2486,1,0,0,0,2486,2488,3,284,142,0,2487,2489,5,180,0,0,2488,
  	2487,1,0,0,0,2488,2489,1,0,0,0,2489,2490,1,0,0,0,2490,2491,5,3,0,0,2491,
  	2493,1,0,0,0,2492,2436,1,0,0,0,2492,2450,1,0,0,0,2492,2464,1,0,0,0,2492,
  	2478,1,0,0,0,2493,283,1,0,0,0,2494,2495,3,286,143,0,2495,2496,5,180,0,
  	0,2496,2497,3,190,95,0,2497,285,1,0,0,0,2498,2499,3,322,161,0,2499,2500,
  	5,180,0,0,2500,2501,5,97,0,0,2501,2502,5,180,0,0,2502,2503,3,234,117,
  	0,2503,287,1,0,0,0,2504,2511,3,324,162,0,2505,2511,5,165,0,0,2506,2511,
  	3,290,145,0,2507,2511,5,116,0,0,2508,2511,3,292,146,0,2509,2511,3,296,
  	148,0,2510,2504,1,0,0,0,2510,2505,1,0,0,0,2510,2506,1,0,0,0,2510,2507,
  	1,0,0,0,2510,2508,1,0,0,0,2510,2509,1,0,0,0,2511,289,1,0,0,0,2512,2513,
  	7,6,0,0,2513,291,1,0,0,0,2514,2516,5,7,0,0,2515,2517,5,180,0,0,2516,2515,
  	1,0,0,0,2516,2517,1,0,0,0,2517,2531,1,0,0,0,2518,2520,3,234,117,0,2519,
  	2521,5,180,0,0,2520,2519,1,0,0,0,2520,2521,1,0,0,0,2521,2528,1,0,0,0,
  	2522,2524,3,294,147,0,2523,2525,5,180,0,0,2524,2523,1,0,0,0,2524,2525,
  	1,0,0,0,2525,2527,1,0,0,0,2526,2522,1,0,0,0,2527,2530,1,0,0,0,2528,2526,
  	1,0,0,0,2528,2529,1,0,0,0,2529,2532,1,0,0,0,2530,2528,1,0,0,0,2531,2518,
  	1,0,0,0,2531,2532,1,0,0,0,2532,2533,1,0,0,0,2533,2534,5,8,0,0,2534,293,
  	1,0,0,0,2535,2537,5,4,0,0,2536,2538,5,180,0,0,2537,2536,1,0,0,0,2537,
  	2538,1,0,0,0,2538,2540,1,0,0,0,2539,2541,3,234,117,0,2540,2539,1,0,0,
  	0,2540,2541,1,0,0,0,2541,295,1,0,0,0,2542,2544,5,9,0,0,2543,2545,5,180,
  	0,0,2544,2543,1,0,0,0,2544,2545,1,0,0,0,2545,2546,1,0,0,0,2546,2548,3,
  	298,149,0,2547,2549,5,180,0,0,2548,2547,1,0,0,0,2548,2549,1,0,0,0,2549,
  	2560,1,0,0,0,2550,2552,5,4,0,0,2551,2553,5,180,0,0,2552,2551,1,0,0,0,
  	2552,2553,1,0,0,0,2553,2554,1,0,0,0,2554,2556,3,298,149,0,2555,2557,5,
  	180,0,0,2556,2555,1,0,0,0,2556,2557,1,0,0,0,2557,2559,1,0,0,0,2558,2550,
  	1,0,0,0,2559,2562,1,0,0,0,2560,2558,1,0,0,0,2560,2561,1,0,0,0,2561,2563,
  	1,0,0,0,2562,2560,1,0,0,0,2563,2564,5,10,0,0,2564,297,1,0,0,0,2565,2568,
  	3,338,169,0,2566,2568,5,165,0,0,2567,2565,1,0,0,0,2567,2566,1,0,0,0,2568,
  	2570,1,0,0,0,2569,2571,5,180,0,0,2570,2569,1,0,0,0,2570,2571,1,0,0,0,
  	2571,2572,1,0,0,0,2572,2574,5,162,0,0,2573,2575,5,180,0,0,2574,2573,1,
  	0,0,0,2574,2575,1,0,0,0,2575,2576,1,0,0,0,2576,2577,3,234,117,0,2577,
  	299,1,0,0,0,2578,2580,5,2,0,0,2579,2581,5,180,0,0,2580,2579,1,0,0,0,2580,
  	2581,1,0,0,0,2581,2582,1,0,0,0,2582,2584,3,234,117,0,2583,2585,5,180,
  	0,0,2584,2583,1,0,0,0,2584,2585,1,0,0,0,2585,2586,1,0,0,0,2586,2587,5,
  	3,0,0,2587,301,1,0,0,0,2588,2590,5,68,0,0,2589,2591,5,180,0,0,2590,2589,
  	1,0,0,0,2590,2591,1,0,0,0,2591,2592,1,0,0,0,2592,2594,5,2,0,0,2593,2595,
  	5,180,0,0,2594,2593,1,0,0,0,2594,2595,1,0,0,0,2595,2596,1,0,0,0,2596,
  	2598,5,159,0,0,2597,2599,5,180,0,0,2598,2597,1,0,0,0,2598,2599,1,0,0,
  	0,2599,2600,1,0,0,0,2600,2666,5,3,0,0,2601,2603,5,60,0,0,2602,2604,5,
  	180,0,0,2603,2602,1,0,0,0,2603,2604,1,0,0,0,2604,2605,1,0,0,0,2605,2607,
  	5,2,0,0,2606,2608,5,180,0,0,2607,2606,1,0,0,0,2607,2608,1,0,0,0,2608,
  	2609,1,0,0,0,2609,2611,3,306,153,0,2610,2612,5,180,0,0,2611,2610,1,0,
  	0,0,2611,2612,1,0,0,0,2612,2623,1,0,0,0,2613,2615,5,52,0,0,2614,2616,
  	5,180,0,0,2615,2614,1,0,0,0,2615,2616,1,0,0,0,2616,2617,1,0,0,0,2617,
  	2624,3,102,51,0,2618,2620,5,4,0,0,2619,2621,5,180,0,0,2620,2619,1,0,0,
  	0,2620,2621,1,0,0,0,2621,2622,1,0,0,0,2622,2624,3,306,153,0,2623,2613,
  	1,0,0,0,2623,2618,1,0,0,0,2624,2626,1,0,0,0,2625,2627,5,180,0,0,2626,
  	2625,1,0,0,0,2626,2627,1,0,0,0,2627,2628,1,0,0,0,2628,2629,5,3,0,0,2629,
  	2666,1,0,0,0,2630,2632,3,304,152,0,2631,2633,5,180,0,0,2632,2631,1,0,
  	0,0,2632,2633,1,0,0,0,2633,2634,1,0,0,0,2634,2636,5,2,0,0,2635,2637,5,
  	180,0,0,2636,2635,1,0,0,0,2636,2637,1,0,0,0,2637,2642,1,0,0,0,2638,2640,
  	5,78,0,0,2639,2641,5,180,0,0,2640,2639,1,0,0,0,2640,2641,1,0,0,0,2641,
  	2643,1,0,0,0,2642,2638,1,0,0,0,2642,2643,1,0,0,0,2643,2661,1,0,0,0,2644,
  	2646,3,306,153,0,2645,2647,5,180,0,0,2646,2645,1,0,0,0,2646,2647,1,0,
  	0,0,2647,2658,1,0,0,0,2648,2650,5,4,0,0,2649,2651,5,180,0,0,2650,2649,
  	1,0,0,0,2650,2651,1,0,0,0,2651,2652,1,0,0,0,2652,2654,3,306,153,0,2653,
  	2655,5,180,0,0,2654,2653,1,0,0,0,2654,2655,1,0,0,0,2655,2657,1,0,0,0,
  	2656,2648,1,0,0,0,2657,2660,1,0,0,0,2658,2656,1,0,0,0,2658,2659,1,0,0,
  	0,2659,2662,1,0,0,0,2660,2658,1,0,0,0,2661,2644,1,0,0,0,2661,2662,1,0,
  	0,0,2662,2663,1,0,0,0,2663,2664,5,3,0,0,2664,2666,1,0,0,0,2665,2588,1,
  	0,0,0,2665,2601,1,0,0,0,2665,2630,1,0,0,0,2666,303,1,0,0,0,2667,2668,
  	3,338,169,0,2668,305,1,0,0,0,2669,2671,3,338,169,0,2670,2672,5,180,0,
  	0,2671,2670,1,0,0,0,2671,2672,1,0,0,0,2672,2673,1,0,0,0,2673,2674,5,162,
  	0,0,2674,2676,5,6,0,0,2675,2677,5,180,0,0,2676,2675,1,0,0,0,2676,2677,
  	1,0,0,0,2677,2679,1,0,0,0,2678,2669,1,0,0,0,2678,2679,1,0,0,0,2679,2680,
  	1,0,0,0,2680,2683,3,234,117,0,2681,2683,3,308,154,0,2682,2678,1,0,0,0,
  	2682,2681,1,0,0,0,2683,307,1,0,0,0,2684,2686,3,310,155,0,2685,2687,5,
  	180,0,0,2686,2685,1,0,0,0,2686,2687,1,0,0,0,2687,2688,1,0,0,0,2688,2689,
  	5,163,0,0,2689,2691,5,16,0,0,2690,2692,5,180,0,0,2691,2690,1,0,0,0,2691,
  	2692,1,0,0,0,2692,2693,1,0,0,0,2693,2695,3,234,117,0,2694,2696,5,180,
  	0,0,2695,2694,1,0,0,0,2695,2696,1,0,0,0,2696,309,1,0,0,0,2697,2722,3,
  	338,169,0,2698,2700,5,2,0,0,2699,2701,5,180,0,0,2700,2699,1,0,0,0,2700,
  	2701,1,0,0,0,2701,2702,1,0,0,0,2702,2704,3,338,169,0,2703,2705,5,180,
  	0,0,2704,2703,1,0,0,0,2704,2705,1,0,0,0,2705,2716,1,0,0,0,2706,2708,5,
  	4,0,0,2707,2709,5,180,0,0,2708,2707,1,0,0,0,2708,2709,1,0,0,0,2709,2710,
  	1,0,0,0,2710,2712,3,338,169,0,2711,2713,5,180,0,0,2712,2711,1,0,0,0,2712,
  	2713,1,0,0,0,2713,2715,1,0,0,0,2714,2706,1,0,0,0,2715,2718,1,0,0,0,2716,
  	2714,1,0,0,0,2716,2717,1,0,0,0,2717,2719,1,0,0,0,2718,2716,1,0,0,0,2719,
  	2720,5,3,0,0,2720,2722,1,0,0,0,2721,2697,1,0,0,0,2721,2698,1,0,0,0,2722,
  	311,1,0,0,0,2723,2728,3,200,100,0,2724,2726,5,180,0,0,2725,2724,1,0,0,
  	0,2725,2726,1,0,0,0,2726,2727,1,0,0,0,2727,2729,3,202,101,0,2728,2725,
  	1,0,0,0,2729,2730,1,0,0,0,2730,2728,1,0,0,0,2730,2731,1,0,0,0,2731,313,
  	1,0,0,0,2732,2734,7,7,0,0,2733,2735,5,180,0,0,2734,2733,1,0,0,0,2734,
  	2735,1,0,0,0,2735,2736,1,0,0,0,2736,2738,5,9,0,0,2737,2739,5,180,0,0,
  	2738,2737,1,0,0,0,2738,2739,1,0,0,0,2739,2740,1,0,0,0,2740,2742,5,107,
  	0,0,2741,2743,5,180,0,0,2742,2741,1,0,0,0,2742,2743,1,0,0,0,2743,2744,
  	1,0,0,0,2744,2749,3,192,96,0,2745,2747,5,180,0,0,2746,2745,1,0,0,0,2746,
  	2747,1,0,0,0,2747,2748,1,0,0,0,2748,2750,3,190,95,0,2749,2746,1,0,0,0,
  	2749,2750,1,0,0,0,2750,2755,1,0,0,0,2751,2753,5,180,0,0,2752,2751,1,0,
  	0,0,2752,2753,1,0,0,0,2753,2754,1,0,0,0,2754,2756,3,154,77,0,2755,2752,
  	1,0,0,0,2755,2756,1,0,0,0,2756,2758,1,0,0,0,2757,2759,5,180,0,0,2758,
  	2757,1,0,0,0,2758,2759,1,0,0,0,2759,2760,1,0,0,0,2760,2761,5,10,0,0,2761,
  	315,1,0,0,0,2762,2764,5,5,0,0,2763,2765,5,180,0,0,2764,2763,1,0,0,0,2764,
  	2765,1,0,0,0,2765,2768,1,0,0,0,2766,2769,3,330,165,0,2767,2769,5,159,
  	0,0,2768,2766,1,0,0,0,2768,2767,1,0,0,0,2769,317,1,0,0,0,2770,2775,5,
  	59,0,0,2771,2773,5,180,0,0,2772,2771,1,0,0,0,2772,2773,1,0,0,0,2773,2774,
  	1,0,0,0,2774,2776,3,320,160,0,2775,2772,1,0,0,0,2776,2777,1,0,0,0,2777,
  	2775,1,0,0,0,2777,2778,1,0,0,0,2778,2793,1,0,0,0,2779,2781,5,59,0,0,2780,
  	2782,5,180,0,0,2781,2780,1,0,0,0,2781,2782,1,0,0,0,2782,2783,1,0,0,0,
  	2783,2788,3,234,117,0,2784,2786,5,180,0,0,2785,2784,1,0,0,0,2785,2786,
  	1,0,0,0,2786,2787,1,0,0,0,2787,2789,3,320,160,0,2788,2785,1,0,0,0,2789,
  	2790,1,0,0,0,2790,2788,1,0,0,0,2790,2791,1,0,0,0,2791,2793,1,0,0,0,2792,
  	2770,1,0,0,0,2792,2779,1,0,0,0,2793,2802,1,0,0,0,2794,2796,5,180,0,0,
  	2795,2794,1,0,0,0,2795,2796,1,0,0,0,2796,2797,1,0,0,0,2797,2799,5,80,
  	0,0,2798,2800,5,180,0,0,2799,2798,1,0,0,0,2799,2800,1,0,0,0,2800,2801,
  	1,0,0,0,2801,2803,3,234,117,0,2802,2795,1,0,0,0,2802,2803,1,0,0,0,2803,
  	2805,1,0,0,0,2804,2806,5,180,0,0,2805,2804,1,0,0,0,2805,2806,1,0,0,0,
  	2806,2807,1,0,0,0,2807,2808,5,81,0,0,2808,319,1,0,0,0,2809,2811,5,149,
  	0,0,2810,2812,5,180,0,0,2811,2810,1,0,0,0,2811,2812,1,0,0,0,2812,2813,
  	1,0,0,0,2813,2815,3,234,117,0,2814,2816,5,180,0,0,2815,2814,1,0,0,0,2815,
  	2816,1,0,0,0,2816,2817,1,0,0,0,2817,2819,5,138,0,0,2818,2820,5,180,0,
  	0,2819,2818,1,0,0,0,2819,2820,1,0,0,0,2820,2821,1,0,0,0,2821,2822,3,234,
  	117,0,2822,321,1,0,0,0,2823,2824,3,338,169,0,2824,323,1,0,0,0,2825,2828,
  	3,334,167,0,2826,2828,3,332,166,0,2827,2825,1,0,0,0,2827,2826,1,0,0,0,
  	2828,325,1,0,0,0,2829,2832,5,26,0,0,2830,2833,3,338,169,0,2831,2833,5,
  	167,0,0,2832,2830,1,0,0,0,2832,2831,1,0,0,0,2833,327,1,0,0,0,2834,2836,
  	3,280,140,0,2835,2837,5,180,0,0,2836,2835,1,0,0,0,2836,2837,1,0,0,0,2837,
  	2838,1,0,0,0,2838,2839,3,316,158,0,2839,329,1,0,0,0,2840,2841,3,336,168,
  	0,2841,331,1,0,0,0,2842,2843,5,167,0,0,2843,333,1,0,0,0,2844,2845,7,8,
  	0,0,2845,335,1,0,0,0,2846,2847,3,338,169,0,2847,337,1,0,0,0,2848,2854,
  	5,176,0,0,2849,2850,5,179,0,0,2850,2854,6,169,-1,0,2851,2854,5,168,0,
  	0,2852,2854,3,340,170,0,2853,2848,1,0,0,0,2853,2849,1,0,0,0,2853,2851,
  	1,0,0,0,2853,2852,1,0,0,0,2854,339,1,0,0,0,2855,2856,7,9,0,0,2856,341,
  	1,0,0,0,2857,2858,7,10,0,0,2858,343,1,0,0,0,2859,2860,7,11,0,0,2860,345,
  	1,0,0,0,2861,2862,7,12,0,0,2862,347,1,0,0,0,489,350,354,359,363,368,371,
  	375,378,401,407,414,418,422,426,429,433,437,441,446,450,452,459,463,472,
  	477,487,491,495,500,513,517,525,529,533,537,545,549,553,557,572,577,583,
  	587,590,593,599,603,608,611,616,620,624,629,644,648,655,675,679,682,685,
  	688,691,695,700,704,714,718,723,728,733,739,743,747,752,759,763,767,770,
  	787,791,795,799,803,806,809,817,826,830,835,839,843,847,851,853,857,861,
  	863,871,876,880,884,888,892,896,901,919,926,939,946,955,963,966,976,979,
  	987,990,996,999,1005,1020,1038,1045,1052,1063,1086,1095,1101,1105,1110,
  	1119,1123,1128,1134,1140,1146,1150,1154,1162,1166,1170,1176,1180,1184,
  	1190,1194,1198,1204,1208,1212,1216,1220,1226,1230,1234,1238,1242,1246,
  	1252,1259,1264,1270,1275,1292,1298,1304,1308,1312,1321,1335,1340,1345,
  	1349,1354,1360,1365,1368,1372,1376,1380,1386,1390,1395,1400,1404,1407,
  	1409,1413,1417,1423,1427,1432,1436,1445,1451,1459,1463,1467,1471,1478,
  	1482,1486,1490,1493,1496,1503,1509,1513,1518,1525,1528,1531,1536,1540,
  	1544,1549,1553,1562,1566,1571,1585,1587,1589,1594,1604,1610,1617,1630,
  	1634,1638,1642,1647,1652,1656,1662,1666,1670,1674,1679,1685,1688,1694,
  	1697,1703,1707,1711,1715,1719,1724,1729,1733,1738,1741,1750,1759,1764,
  	1777,1780,1788,1792,1797,1802,1806,1811,1817,1822,1829,1833,1837,1839,
  	1843,1845,1849,1851,1857,1863,1867,1870,1873,1879,1882,1885,1889,1895,
  	1898,1901,1905,1909,1913,1915,1919,1921,1925,1927,1931,1933,1939,1943,
  	1947,1951,1955,1959,1963,1967,1971,1974,1980,1984,1988,1991,1996,2001,
  	2006,2011,2017,2020,2023,2026,2029,2032,2036,2040,2044,2048,2058,2061,
  	2064,2068,2071,2074,2078,2082,2086,2090,2094,2098,2100,2103,2107,2111,
  	2115,2119,2121,2127,2130,2133,2154,2164,2174,2179,2183,2190,2194,2198,
  	2202,2206,2214,2218,2222,2226,2232,2236,2242,2246,2251,2256,2260,2265,
  	2270,2274,2280,2287,2291,2297,2304,2308,2314,2321,2325,2330,2338,2341,
  	2346,2355,2359,2362,2375,2378,2383,2397,2401,2405,2410,2413,2417,2422,
  	2434,2438,2442,2446,2452,2456,2460,2466,2470,2474,2480,2484,2488,2492,
  	2510,2516,2520,2524,2528,2531,2537,2540,2544,2548,2552,2556,2560,2567,
  	2570,2574,2580,2584,2590,2594,2598,2603,2607,2611,2615,2620,2623,2626,
  	2632,2636,2640,2642,2646,2650,2654,2658,2661,2665,2671,2676,2678,2682,
  	2686,2691,2695,2700,2704,2708,2712,2716,2721,2725,2730,2734,2738,2742,
  	2746,2749,2752,2755,2758,2764,2768,2772,2777,2781,2785,2790,2792,2795,
  	2799,2802,2805,2811,2815,2819,2827,2832,2836,2853
  };
  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(348);
    oC_Cypher();
    setState(359);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(350);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(349);
          match(CypherParser::SP);
        }
        setState(352);
        match(CypherParser::T__0);
        setState(354);
        _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(362);
      match(CypherParser::SP);
    }
    setState(365);
    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(368);
    _errHandler->sync(this);

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

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

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

    setState(373);
    oC_Statement();
    setState(378);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(374);
        match(CypherParser::SP);
      }
      setState(377);
      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_CreateUserContext* CypherParser::OC_StatementContext::kU_CreateUser() {
  return getRuleContext<CypherParser::KU_CreateUserContext>(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_CreateSequenceContext* CypherParser::OC_StatementContext::kU_CreateSequence() {
  return getRuleContext<CypherParser::KU_CreateSequenceContext>(0);
}

CypherParser::KU_CreateTypeContext* CypherParser::OC_StatementContext::kU_CreateType() {
  return getRuleContext<CypherParser::KU_CreateTypeContext>(0);
}

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(381);
      kU_CreateUser();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(382);
      kU_CreateNodeTable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(383);
      kU_CreateRelTable();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(384);
      kU_CreateSequence();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(385);
      kU_CreateType();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(386);
      kU_Drop();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(387);
      kU_AlterTable();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(388);
      kU_CopyFrom();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(389);
      kU_CopyFromByColumn();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(390);
      kU_CopyTO();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(391);
      kU_StandaloneCall();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(392);
      kU_CreateMacro();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(393);
      kU_CommentOn();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(394);
      kU_Transaction();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(395);
      kU_Extension();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(396);
      kU_ExportDatabase();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(397);
      kU_ImportDatabase();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(398);
      kU_AttachDatabase();
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(399);
      kU_DetachDatabase();
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(400);
      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_ColumnNamesContext* CypherParser::KU_CopyFromContext::kU_ColumnNames() {
  return getRuleContext<CypherParser::KU_ColumnNamesContext>(0);
}

CypherParser::KU_OptionsContext* CypherParser::KU_CopyFromContext::kU_Options() {
  return getRuleContext<CypherParser::KU_OptionsContext>(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(403);
    match(CypherParser::COPY);
    setState(404);
    match(CypherParser::SP);
    setState(405);
    oC_SchemaName();
    setState(407);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
    case 1: {
      setState(406);
      kU_ColumnNames();
      break;
    }

    default:
      break;
    }
    setState(409);
    match(CypherParser::SP);
    setState(410);
    match(CypherParser::FROM);
    setState(411);
    match(CypherParser::SP);
    setState(412);
    kU_ScanSource();
    setState(426);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(413);
        match(CypherParser::SP);
      }
      setState(416);
      match(CypherParser::T__1);
      setState(418);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(417);
        match(CypherParser::SP);
      }
      setState(420);
      kU_Options();
      setState(422);
      _errHandler->sync(this);

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

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

  return _localctx;
}

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

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

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

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


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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(428);
      match(CypherParser::SP);
    }
    setState(431);
    match(CypherParser::T__1);
    setState(433);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -6371186097845698560) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1151940922579049251) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2534380494694747) != 0)) {
      setState(435);
      oC_SchemaName();
      setState(446);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(437);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(436);
            match(CypherParser::SP);
          }
          setState(439);
          match(CypherParser::T__3);
          setState(441);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(440);
            match(CypherParser::SP);
          }
          setState(443);
          oC_SchemaName(); 
        }
        setState(448);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
      }
      setState(450);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(449);
        match(CypherParser::SP);
      }
    }
    setState(454);
    match(CypherParser::T__2);
   
  }
  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_ParameterContext* CypherParser::KU_ScanSourceContext::oC_Parameter() {
  return getRuleContext<CypherParser::OC_ParameterContext>(0);
}

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

CypherParser::OC_FunctionInvocationContext* CypherParser::KU_ScanSourceContext::oC_FunctionInvocation() {
  return getRuleContext<CypherParser::OC_FunctionInvocationContext>(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(477);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(456);
      kU_FilePaths();
      break;
    }

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(458);
        match(CypherParser::SP);
      }
      setState(461);
      oC_Query();
      setState(463);
      _errHandler->sync(this);

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

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(467);
      oC_Parameter();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(468);
      oC_Variable();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(469);
      oC_Variable();
      setState(470);
      match(CypherParser::T__4);
      setState(472);
      _errHandler->sync(this);

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

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(476);
      oC_FunctionInvocation();
      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(479);
    match(CypherParser::COPY);
    setState(480);
    match(CypherParser::SP);
    setState(481);
    oC_SchemaName();
    setState(482);
    match(CypherParser::SP);
    setState(483);
    match(CypherParser::FROM);
    setState(484);
    match(CypherParser::SP);
    setState(485);
    match(CypherParser::T__1);
    setState(487);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(486);
      match(CypherParser::SP);
    }
    setState(489);
    match(CypherParser::StringLiteral);
    setState(500);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__3 || _la == CypherParser::SP) {
      setState(491);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(490);
        match(CypherParser::SP);
      }
      setState(493);
      match(CypherParser::T__3);
      setState(495);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(494);
        match(CypherParser::SP);
      }
      setState(497);
      match(CypherParser::StringLiteral);
      setState(502);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(503);
    match(CypherParser::T__2);
    setState(504);
    match(CypherParser::SP);
    setState(505);
    match(CypherParser::BY);
    setState(506);
    match(CypherParser::SP);
    setState(507);
    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_OptionsContext* CypherParser::KU_CopyTOContext::kU_Options() {
  return getRuleContext<CypherParser::KU_OptionsContext>(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(509);
    match(CypherParser::COPY);
    setState(510);
    match(CypherParser::SP);
    setState(511);
    match(CypherParser::T__1);
    setState(513);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(512);
      match(CypherParser::SP);
    }
    setState(515);
    oC_Query();
    setState(517);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(516);
      match(CypherParser::SP);
    }
    setState(519);
    match(CypherParser::T__2);
    setState(520);
    match(CypherParser::SP);
    setState(521);
    match(CypherParser::TO);
    setState(522);
    match(CypherParser::SP);
    setState(523);
    match(CypherParser::StringLiteral);
    setState(537);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(524);
        match(CypherParser::SP);
      }
      setState(527);
      match(CypherParser::T__1);
      setState(529);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(528);
        match(CypherParser::SP);
      }
      setState(531);
      kU_Options();
      setState(533);
      _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- 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_OptionsContext* CypherParser::KU_ExportDatabaseContext::kU_Options() {
  return getRuleContext<CypherParser::KU_OptionsContext>(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(539);
    match(CypherParser::EXPORT);
    setState(540);
    match(CypherParser::SP);
    setState(541);
    match(CypherParser::DATABASE);
    setState(542);
    match(CypherParser::SP);
    setState(543);
    match(CypherParser::StringLiteral);
    setState(557);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(544);
        match(CypherParser::SP);
      }
      setState(547);
      match(CypherParser::T__1);
      setState(549);
      _errHandler->sync(this);

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

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

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

  return _localctx;
}

//----------------- 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(559);
    match(CypherParser::IMPORT);
    setState(560);
    match(CypherParser::SP);
    setState(561);
    match(CypherParser::DATABASE);
    setState(562);
    match(CypherParser::SP);
    setState(563);
    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);
}

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

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

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

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

CypherParser::KU_OptionsContext* CypherParser::KU_AttachDatabaseContext::kU_Options() {
  return getRuleContext<CypherParser::KU_OptionsContext>(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(565);
    match(CypherParser::ATTACH);
    setState(566);
    match(CypherParser::SP);
    setState(567);
    match(CypherParser::StringLiteral);
    setState(572);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
    case 1: {
      setState(568);
      match(CypherParser::SP);
      setState(569);
      match(CypherParser::AS);
      setState(570);
      match(CypherParser::SP);
      setState(571);
      oC_SchemaName();
      break;
    }

    default:
      break;
    }
    setState(574);
    match(CypherParser::SP);
    setState(575);
    match(CypherParser::T__1);
    setState(577);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(576);
      match(CypherParser::SP);
    }
    setState(579);
    match(CypherParser::DBTYPE);
    setState(580);
    match(CypherParser::SP);
    setState(581);
    oC_SymbolicName();
    setState(590);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(582);
        match(CypherParser::SP);
      }
      setState(585);
      match(CypherParser::T__3);
      setState(587);
      _errHandler->sync(this);

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

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

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

  return _localctx;
}

//----------------- KU_OptionContext ------------------------------------------------------------------

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

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

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

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

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


size_t CypherParser::KU_OptionContext::getRuleIndex() const {
  return CypherParser::RuleKU_Option;
}


CypherParser::KU_OptionContext* CypherParser::kU_Option() {
  KU_OptionContext *_localctx = _tracker.createInstance<KU_OptionContext>(_ctx, getState());
  enterRule(_localctx, 22, CypherParser::RuleKU_Option);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(616);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(597);
      oC_SymbolicName();
      setState(611);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
      case 1: {
        setState(599);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(598);
          match(CypherParser::SP);
        }
        setState(601);
        match(CypherParser::T__5);
        setState(603);
        _errHandler->sync(this);

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

      case 2: {
        setState(608);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::SP) {
          setState(605);
          match(CypherParser::SP);
          setState(610);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      default:
        break;
      }
      setState(613);
      oC_Literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(615);
      oC_SymbolicName();
      break;
    }

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

  return _localctx;
}

//----------------- KU_OptionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::KU_OptionContext *> CypherParser::KU_OptionsContext::kU_Option() {
  return getRuleContexts<CypherParser::KU_OptionContext>();
}

CypherParser::KU_OptionContext* CypherParser::KU_OptionsContext::kU_Option(size_t i) {
  return getRuleContext<CypherParser::KU_OptionContext>(i);
}

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

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


size_t CypherParser::KU_OptionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_Options;
}


CypherParser::KU_OptionsContext* CypherParser::kU_Options() {
  KU_OptionsContext *_localctx = _tracker.createInstance<KU_OptionsContext>(_ctx, getState());
  enterRule(_localctx, 24, CypherParser::RuleKU_Options);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(618);
    kU_Option();
    setState(629);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(620);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(619);
          match(CypherParser::SP);
        }
        setState(622);
        match(CypherParser::T__3);
        setState(624);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(623);
          match(CypherParser::SP);
        }
        setState(626);
        kU_Option(); 
      }
      setState(631);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 52, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 26, CypherParser::RuleKU_DetachDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(632);
    match(CypherParser::DETACH);
    setState(633);
    match(CypherParser::SP);
    setState(634);
    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, 28, CypherParser::RuleKU_UseDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(636);
    match(CypherParser::USE);
    setState(637);
    match(CypherParser::SP);
    setState(638);
    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);
}

CypherParser::OC_FunctionInvocationContext* CypherParser::KU_StandaloneCallContext::oC_FunctionInvocation() {
  return getRuleContext<CypherParser::OC_FunctionInvocationContext>(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, 30, CypherParser::RuleKU_StandaloneCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(655);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 55, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(640);
      match(CypherParser::CALL);
      setState(641);
      match(CypherParser::SP);
      setState(642);
      oC_SymbolicName();
      setState(644);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(643);
        match(CypherParser::SP);
      }
      setState(646);
      match(CypherParser::T__5);
      setState(648);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(652);
      match(CypherParser::CALL);
      setState(653);
      match(CypherParser::SP);
      setState(654);
      oC_FunctionInvocation();
      break;
    }

    default:
      break;
    }
   
  }
  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, 32, CypherParser::RuleKU_CommentOn);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(657);
    match(CypherParser::COMMENT);
    setState(658);
    match(CypherParser::SP);
    setState(659);
    match(CypherParser::ON);
    setState(660);
    match(CypherParser::SP);
    setState(661);
    match(CypherParser::TABLE);
    setState(662);
    match(CypherParser::SP);
    setState(663);
    oC_SchemaName();
    setState(664);
    match(CypherParser::SP);
    setState(665);
    match(CypherParser::IS);
    setState(666);
    match(CypherParser::SP);
    setState(667);
    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, 34, 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(669);
    match(CypherParser::CREATE);
    setState(670);
    match(CypherParser::SP);
    setState(671);
    match(CypherParser::MACRO);
    setState(672);
    match(CypherParser::SP);
    setState(673);
    oC_FunctionName();
    setState(675);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(674);
      match(CypherParser::SP);
    }
    setState(677);
    match(CypherParser::T__1);
    setState(679);
    _errHandler->sync(this);

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

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

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

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

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -6371186097845698560) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1151940922579049251) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2534380494694747) != 0)) {
      setState(687);
      kU_DefaultArg();
    }
    setState(700);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(691);
        _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(694);
          match(CypherParser::SP);
        }
        setState(697);
        kU_DefaultArg(); 
      }
      setState(702);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx);
    }
    setState(704);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(703);
      match(CypherParser::SP);
    }
    setState(706);
    match(CypherParser::T__2);
    setState(707);
    match(CypherParser::SP);
    setState(708);
    match(CypherParser::AS);
    setState(709);
    match(CypherParser::SP);
    setState(710);
    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, 36, 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(712);
    oC_SymbolicName();
    setState(723);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(714);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(713);
          match(CypherParser::SP);
        }
        setState(716);
        match(CypherParser::T__3);
        setState(718);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(717);
          match(CypherParser::SP);
        }
        setState(720);
        oC_SymbolicName(); 
      }
      setState(725);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _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, 38, 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(726);
    oC_SymbolicName();
    setState(728);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(727);
      match(CypherParser::SP);
    }
    setState(730);
    match(CypherParser::COLON);
    setState(731);
    match(CypherParser::T__5);
    setState(733);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(732);
      match(CypherParser::SP);
    }
    setState(735);
    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, 40, CypherParser::RuleKU_FilePaths);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(738);
          match(CypherParser::SP);
        }
        setState(741);
        match(CypherParser::StringLiteral);
        setState(752);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__3 || _la == CypherParser::SP) {
          setState(743);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(742);
            match(CypherParser::SP);
          }
          setState(745);
          match(CypherParser::T__3);
          setState(747);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(746);
            match(CypherParser::SP);
          }
          setState(749);
          match(CypherParser::StringLiteral);
          setState(754);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(755);
        match(CypherParser::T__7);
        break;
      }

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

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(758);
          match(CypherParser::SP);
        }
        setState(761);
        match(CypherParser::T__1);
        setState(763);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(762);
          match(CypherParser::SP);
        }
        setState(765);
        match(CypherParser::StringLiteral);
        setState(767);
        _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- KU_IfNotExistsContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_IfNotExistsContext::IF() {
  return getToken(CypherParser::IF, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_IfNotExistsContext::NOT() {
  return getToken(CypherParser::NOT, 0);
}

tree::TerminalNode* CypherParser::KU_IfNotExistsContext::EXISTS() {
  return getToken(CypherParser::EXISTS, 0);
}


size_t CypherParser::KU_IfNotExistsContext::getRuleIndex() const {
  return CypherParser::RuleKU_IfNotExists;
}


CypherParser::KU_IfNotExistsContext* CypherParser::kU_IfNotExists() {
  KU_IfNotExistsContext *_localctx = _tracker.createInstance<KU_IfNotExistsContext>(_ctx, getState());
  enterRule(_localctx, 42, CypherParser::RuleKU_IfNotExists);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(772);
    match(CypherParser::IF);
    setState(773);
    match(CypherParser::SP);
    setState(774);
    match(CypherParser::NOT);
    setState(775);
    match(CypherParser::SP);
    setState(776);
    match(CypherParser::EXISTS);
   
  }
  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);
}

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

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

CypherParser::KU_IfNotExistsContext* CypherParser::KU_CreateNodeTableContext::kU_IfNotExists() {
  return getRuleContext<CypherParser::KU_IfNotExistsContext>(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, 44, 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(778);
    match(CypherParser::CREATE);
    setState(779);
    match(CypherParser::SP);
    setState(780);
    match(CypherParser::NODE);
    setState(781);
    match(CypherParser::SP);
    setState(782);
    match(CypherParser::TABLE);
    setState(783);
    match(CypherParser::SP);
    setState(787);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(789);
    oC_SchemaName();
    setState(817);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      setState(791);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(790);
        match(CypherParser::SP);
      }
      setState(793);
      match(CypherParser::T__1);
      setState(795);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(794);
        match(CypherParser::SP);
      }
      setState(797);
      kU_PropertyDefinitions();
      setState(799);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::T__3) {
        setState(801);
        match(CypherParser::T__3);
        setState(803);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(802);
          match(CypherParser::SP);
        }
        setState(805);
        kU_CreateNodeConstraint();
      }
      setState(809);
      _errHandler->sync(this);

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

    case 2: {
      setState(813);
      match(CypherParser::SP);
      setState(814);
      match(CypherParser::AS);
      setState(815);
      match(CypherParser::SP);
      setState(816);
      oC_Query();
      break;
    }

    default:
      break;
    }
   
  }
  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_FromToConnectionsContext* CypherParser::KU_CreateRelTableContext::kU_FromToConnections() {
  return getRuleContext<CypherParser::KU_FromToConnectionsContext>(0);
}

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

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

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

CypherParser::KU_IfNotExistsContext* CypherParser::KU_CreateRelTableContext::kU_IfNotExists() {
  return getRuleContext<CypherParser::KU_IfNotExistsContext>(0);
}

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

CypherParser::KU_OptionsContext* CypherParser::KU_CreateRelTableContext::kU_Options() {
  return getRuleContext<CypherParser::KU_OptionsContext>(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, 46, 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(819);
    match(CypherParser::CREATE);
    setState(820);
    match(CypherParser::SP);
    setState(821);
    match(CypherParser::REL);
    setState(822);
    match(CypherParser::SP);
    setState(823);
    match(CypherParser::TABLE);
    setState(826);
    _errHandler->sync(this);

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

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

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

    default:
      break;
    }
    setState(832);
    match(CypherParser::SP);
    setState(833);
    oC_SchemaName();
    setState(835);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(834);
      match(CypherParser::SP);
    }
    setState(837);
    match(CypherParser::T__1);
    setState(839);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(838);
      match(CypherParser::SP);
    }
    setState(841);
    kU_FromToConnections();
    setState(843);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(842);
      match(CypherParser::SP);
    }
    setState(871);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx)) {
    case 1: {
      setState(853);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx)) {
      case 1: {
        setState(845);
        match(CypherParser::T__3);
        setState(847);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(846);
          match(CypherParser::SP);
        }
        setState(849);
        kU_PropertyDefinitions();
        setState(851);
        _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::T__3) {
        setState(855);
        match(CypherParser::T__3);
        setState(857);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(856);
          match(CypherParser::SP);
        }
        setState(859);
        oC_SymbolicName();
        setState(861);
        _errHandler->sync(this);

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

    case 2: {
      setState(866);
      match(CypherParser::T__2);
      setState(867);
      match(CypherParser::SP);
      setState(868);
      match(CypherParser::AS);
      setState(869);
      match(CypherParser::SP);
      setState(870);
      oC_Query();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 101, _ctx)) {
    case 1: {
      setState(873);
      match(CypherParser::SP);
      setState(874);
      match(CypherParser::WITH);
      setState(876);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(875);
        match(CypherParser::SP);
      }
      setState(878);
      match(CypherParser::T__1);
      setState(880);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(879);
        match(CypherParser::SP);
      }
      setState(882);
      kU_Options();
      setState(884);
      _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- KU_FromToConnectionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::KU_FromToConnectionContext *> CypherParser::KU_FromToConnectionsContext::kU_FromToConnection() {
  return getRuleContexts<CypherParser::KU_FromToConnectionContext>();
}

CypherParser::KU_FromToConnectionContext* CypherParser::KU_FromToConnectionsContext::kU_FromToConnection(size_t i) {
  return getRuleContext<CypherParser::KU_FromToConnectionContext>(i);
}

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

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


size_t CypherParser::KU_FromToConnectionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_FromToConnections;
}


CypherParser::KU_FromToConnectionsContext* CypherParser::kU_FromToConnections() {
  KU_FromToConnectionsContext *_localctx = _tracker.createInstance<KU_FromToConnectionsContext>(_ctx, getState());
  enterRule(_localctx, 48, CypherParser::RuleKU_FromToConnections);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(890);
    kU_FromToConnection();
    setState(901);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(892);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(891);
          match(CypherParser::SP);
        }
        setState(894);
        match(CypherParser::T__3);
        setState(896);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(895);
          match(CypherParser::SP);
        }
        setState(898);
        kU_FromToConnection(); 
      }
      setState(903);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_FromToConnectionContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::KU_FromToConnectionContext::getRuleIndex() const {
  return CypherParser::RuleKU_FromToConnection;
}


CypherParser::KU_FromToConnectionContext* CypherParser::kU_FromToConnection() {
  KU_FromToConnectionContext *_localctx = _tracker.createInstance<KU_FromToConnectionContext>(_ctx, getState());
  enterRule(_localctx, 50, CypherParser::RuleKU_FromToConnection);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(904);
    match(CypherParser::FROM);
    setState(905);
    match(CypherParser::SP);
    setState(906);
    oC_SchemaName();
    setState(907);
    match(CypherParser::SP);
    setState(908);
    match(CypherParser::TO);
    setState(909);
    match(CypherParser::SP);
    setState(910);
    oC_SchemaName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateSequenceContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::KU_CreateSequenceContext::SEQUENCE() {
  return getToken(CypherParser::SEQUENCE, 0);
}

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

CypherParser::KU_IfNotExistsContext* CypherParser::KU_CreateSequenceContext::kU_IfNotExists() {
  return getRuleContext<CypherParser::KU_IfNotExistsContext>(0);
}

std::vector<CypherParser::KU_SequenceOptionsContext *> CypherParser::KU_CreateSequenceContext::kU_SequenceOptions() {
  return getRuleContexts<CypherParser::KU_SequenceOptionsContext>();
}

CypherParser::KU_SequenceOptionsContext* CypherParser::KU_CreateSequenceContext::kU_SequenceOptions(size_t i) {
  return getRuleContext<CypherParser::KU_SequenceOptionsContext>(i);
}


size_t CypherParser::KU_CreateSequenceContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateSequence;
}


CypherParser::KU_CreateSequenceContext* CypherParser::kU_CreateSequence() {
  KU_CreateSequenceContext *_localctx = _tracker.createInstance<KU_CreateSequenceContext>(_ctx, getState());
  enterRule(_localctx, 52, CypherParser::RuleKU_CreateSequence);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(912);
    match(CypherParser::CREATE);
    setState(913);
    match(CypherParser::SP);
    setState(914);
    match(CypherParser::SEQUENCE);
    setState(915);
    match(CypherParser::SP);
    setState(919);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(921);
    oC_SchemaName();
    setState(926);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(922);
        match(CypherParser::SP);
        setState(923);
        kU_SequenceOptions(); 
      }
      setState(928);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_CreateTypeContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::KU_CreateTypeContext::TYPE() {
  return getToken(CypherParser::TYPE, 0);
}

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

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

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


size_t CypherParser::KU_CreateTypeContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateType;
}


CypherParser::KU_CreateTypeContext* CypherParser::kU_CreateType() {
  KU_CreateTypeContext *_localctx = _tracker.createInstance<KU_CreateTypeContext>(_ctx, getState());
  enterRule(_localctx, 54, CypherParser::RuleKU_CreateType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(929);
    match(CypherParser::CREATE);
    setState(930);
    match(CypherParser::SP);
    setState(931);
    match(CypherParser::TYPE);
    setState(932);
    match(CypherParser::SP);
    setState(933);
    oC_SchemaName();
    setState(934);
    match(CypherParser::SP);
    setState(935);
    match(CypherParser::AS);
    setState(936);
    match(CypherParser::SP);
    setState(937);
    kU_DataType(0);
    setState(939);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- KU_SequenceOptionsContext ------------------------------------------------------------------

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

CypherParser::KU_IncrementByContext* CypherParser::KU_SequenceOptionsContext::kU_IncrementBy() {
  return getRuleContext<CypherParser::KU_IncrementByContext>(0);
}

CypherParser::KU_MinValueContext* CypherParser::KU_SequenceOptionsContext::kU_MinValue() {
  return getRuleContext<CypherParser::KU_MinValueContext>(0);
}

CypherParser::KU_MaxValueContext* CypherParser::KU_SequenceOptionsContext::kU_MaxValue() {
  return getRuleContext<CypherParser::KU_MaxValueContext>(0);
}

CypherParser::KU_StartWithContext* CypherParser::KU_SequenceOptionsContext::kU_StartWith() {
  return getRuleContext<CypherParser::KU_StartWithContext>(0);
}

CypherParser::KU_CycleContext* CypherParser::KU_SequenceOptionsContext::kU_Cycle() {
  return getRuleContext<CypherParser::KU_CycleContext>(0);
}


size_t CypherParser::KU_SequenceOptionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_SequenceOptions;
}


CypherParser::KU_SequenceOptionsContext* CypherParser::kU_SequenceOptions() {
  KU_SequenceOptionsContext *_localctx = _tracker.createInstance<KU_SequenceOptionsContext>(_ctx, getState());
  enterRule(_localctx, 56, CypherParser::RuleKU_SequenceOptions);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(942);
      kU_MinValue();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(943);
      kU_MaxValue();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(944);
      kU_StartWith();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(945);
      kU_Cycle();
      break;
    }

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

  return _localctx;
}

//----------------- KU_CreateUserContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::KU_CreateUserContext::USER() {
  return getToken(CypherParser::USER, 0);
}

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

CypherParser::KU_IfNotExistsContext* CypherParser::KU_CreateUserContext::kU_IfNotExists() {
  return getRuleContext<CypherParser::KU_IfNotExistsContext>(0);
}


size_t CypherParser::KU_CreateUserContext::getRuleIndex() const {
  return CypherParser::RuleKU_CreateUser;
}


CypherParser::KU_CreateUserContext* CypherParser::kU_CreateUser() {
  KU_CreateUserContext *_localctx = _tracker.createInstance<KU_CreateUserContext>(_ctx, getState());
  enterRule(_localctx, 58, CypherParser::RuleKU_CreateUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(948);
    match(CypherParser::CREATE);
    setState(949);
    match(CypherParser::SP);
    setState(950);
    match(CypherParser::USER);
    setState(951);
    match(CypherParser::SP);
    setState(955);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- KU_IncrementByContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_IncrementByContext::INCREMENT() {
  return getToken(CypherParser::INCREMENT, 0);
}

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

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

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

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

tree::TerminalNode* CypherParser::KU_IncrementByContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}


size_t CypherParser::KU_IncrementByContext::getRuleIndex() const {
  return CypherParser::RuleKU_IncrementBy;
}


CypherParser::KU_IncrementByContext* CypherParser::kU_IncrementBy() {
  KU_IncrementByContext *_localctx = _tracker.createInstance<KU_IncrementByContext>(_ctx, getState());
  enterRule(_localctx, 60, CypherParser::RuleKU_IncrementBy);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::BY) {
      setState(961);
      match(CypherParser::BY);
      setState(962);
      match(CypherParser::SP);
    }
    setState(966);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- KU_MinValueContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_MinValueContext::NO() {
  return getToken(CypherParser::NO, 0);
}

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

tree::TerminalNode* CypherParser::KU_MinValueContext::MINVALUE() {
  return getToken(CypherParser::MINVALUE, 0);
}

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

tree::TerminalNode* CypherParser::KU_MinValueContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}


size_t CypherParser::KU_MinValueContext::getRuleIndex() const {
  return CypherParser::RuleKU_MinValue;
}


CypherParser::KU_MinValueContext* CypherParser::kU_MinValue() {
  KU_MinValueContext *_localctx = _tracker.createInstance<KU_MinValueContext>(_ctx, getState());
  enterRule(_localctx, 62, CypherParser::RuleKU_MinValue);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(979);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::NO: {
        enterOuterAlt(_localctx, 1);
        setState(970);
        match(CypherParser::NO);
        setState(971);
        match(CypherParser::SP);
        setState(972);
        match(CypherParser::MINVALUE);
        break;
      }

      case CypherParser::MINVALUE: {
        enterOuterAlt(_localctx, 2);
        setState(973);
        match(CypherParser::MINVALUE);
        setState(974);
        match(CypherParser::SP);
        setState(976);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::MINUS) {
          setState(975);
          match(CypherParser::MINUS);
        }
        setState(978);
        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;
}

//----------------- KU_MaxValueContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_MaxValueContext::NO() {
  return getToken(CypherParser::NO, 0);
}

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

tree::TerminalNode* CypherParser::KU_MaxValueContext::MAXVALUE() {
  return getToken(CypherParser::MAXVALUE, 0);
}

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

tree::TerminalNode* CypherParser::KU_MaxValueContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}


size_t CypherParser::KU_MaxValueContext::getRuleIndex() const {
  return CypherParser::RuleKU_MaxValue;
}


CypherParser::KU_MaxValueContext* CypherParser::kU_MaxValue() {
  KU_MaxValueContext *_localctx = _tracker.createInstance<KU_MaxValueContext>(_ctx, getState());
  enterRule(_localctx, 64, CypherParser::RuleKU_MaxValue);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(990);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::NO: {
        enterOuterAlt(_localctx, 1);
        setState(981);
        match(CypherParser::NO);
        setState(982);
        match(CypherParser::SP);
        setState(983);
        match(CypherParser::MAXVALUE);
        break;
      }

      case CypherParser::MAXVALUE: {
        enterOuterAlt(_localctx, 2);
        setState(984);
        match(CypherParser::MAXVALUE);
        setState(985);
        match(CypherParser::SP);
        setState(987);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::MINUS) {
          setState(986);
          match(CypherParser::MINUS);
        }
        setState(989);
        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;
}

//----------------- KU_StartWithContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_StartWithContext::START() {
  return getToken(CypherParser::START, 0);
}

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

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

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

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

tree::TerminalNode* CypherParser::KU_StartWithContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}


size_t CypherParser::KU_StartWithContext::getRuleIndex() const {
  return CypherParser::RuleKU_StartWith;
}


CypherParser::KU_StartWithContext* CypherParser::kU_StartWith() {
  KU_StartWithContext *_localctx = _tracker.createInstance<KU_StartWithContext>(_ctx, getState());
  enterRule(_localctx, 66, CypherParser::RuleKU_StartWith);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::WITH) {
      setState(994);
      match(CypherParser::WITH);
      setState(995);
      match(CypherParser::SP);
    }
    setState(999);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- KU_CycleContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_CycleContext::CYCLE() {
  return getToken(CypherParser::CYCLE, 0);
}

tree::TerminalNode* CypherParser::KU_CycleContext::NO() {
  return getToken(CypherParser::NO, 0);
}

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


size_t CypherParser::KU_CycleContext::getRuleIndex() const {
  return CypherParser::RuleKU_Cycle;
}


CypherParser::KU_CycleContext* CypherParser::kU_Cycle() {
  KU_CycleContext *_localctx = _tracker.createInstance<KU_CycleContext>(_ctx, getState());
  enterRule(_localctx, 68, CypherParser::RuleKU_Cycle);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::NO) {
      setState(1003);
      match(CypherParser::NO);
      setState(1004);
      match(CypherParser::SP);
    }
    setState(1007);
    match(CypherParser::CYCLE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_IfExistsContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_IfExistsContext::IF() {
  return getToken(CypherParser::IF, 0);
}

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

tree::TerminalNode* CypherParser::KU_IfExistsContext::EXISTS() {
  return getToken(CypherParser::EXISTS, 0);
}


size_t CypherParser::KU_IfExistsContext::getRuleIndex() const {
  return CypherParser::RuleKU_IfExists;
}


CypherParser::KU_IfExistsContext* CypherParser::kU_IfExists() {
  KU_IfExistsContext *_localctx = _tracker.createInstance<KU_IfExistsContext>(_ctx, getState());
  enterRule(_localctx, 70, CypherParser::RuleKU_IfExists);

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

  return _localctx;
}

//----------------- KU_DropContext ------------------------------------------------------------------

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

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

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

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

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

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

tree::TerminalNode* CypherParser::KU_DropContext::SEQUENCE() {
  return getToken(CypherParser::SEQUENCE, 0);
}

CypherParser::KU_IfExistsContext* CypherParser::KU_DropContext::kU_IfExists() {
  return getRuleContext<CypherParser::KU_IfExistsContext>(0);
}


size_t CypherParser::KU_DropContext::getRuleIndex() const {
  return CypherParser::RuleKU_Drop;
}


CypherParser::KU_DropContext* CypherParser::kU_Drop() {
  KU_DropContext *_localctx = _tracker.createInstance<KU_DropContext>(_ctx, getState());
  enterRule(_localctx, 72, CypherParser::RuleKU_Drop);
  size_t _la = 0;

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

    || _la == CypherParser::TABLE)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1016);
    match(CypherParser::SP);
    setState(1020);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(1022);
    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, 74, CypherParser::RuleKU_AlterTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1024);
    match(CypherParser::ALTER);
    setState(1025);
    match(CypherParser::SP);
    setState(1026);
    match(CypherParser::TABLE);
    setState(1027);
    match(CypherParser::SP);
    setState(1028);
    oC_SchemaName();
    setState(1029);
    match(CypherParser::SP);
    setState(1030);
    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);
}

CypherParser::KU_AddFromToConnectionContext* CypherParser::KU_AlterOptionsContext::kU_AddFromToConnection() {
  return getRuleContext<CypherParser::KU_AddFromToConnectionContext>(0);
}

CypherParser::KU_DropFromToConnectionContext* CypherParser::KU_AlterOptionsContext::kU_DropFromToConnection() {
  return getRuleContext<CypherParser::KU_DropFromToConnectionContext>(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, 76, CypherParser::RuleKU_AlterOptions);

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

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

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

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

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1036);
      kU_AddFromToConnection();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1037);
      kU_DropFromToConnection();
      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);
}

CypherParser::KU_IfNotExistsContext* CypherParser::KU_AddPropertyContext::kU_IfNotExists() {
  return getRuleContext<CypherParser::KU_IfNotExistsContext>(0);
}

CypherParser::KU_DefaultContext* CypherParser::KU_AddPropertyContext::kU_Default() {
  return getRuleContext<CypherParser::KU_DefaultContext>(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, 78, CypherParser::RuleKU_AddProperty);

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

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

    default:
      break;
    }
    setState(1047);
    oC_PropertyKeyName();
    setState(1048);
    match(CypherParser::SP);
    setState(1049);
    kU_DataType(0);
    setState(1052);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- KU_DefaultContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::KU_DefaultContext::getRuleIndex() const {
  return CypherParser::RuleKU_Default;
}


CypherParser::KU_DefaultContext* CypherParser::kU_Default() {
  KU_DefaultContext *_localctx = _tracker.createInstance<KU_DefaultContext>(_ctx, getState());
  enterRule(_localctx, 80, CypherParser::RuleKU_Default);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1054);
    match(CypherParser::DEFAULT);
    setState(1055);
    match(CypherParser::SP);
    setState(1056);
    oC_Expression();
   
  }
  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);
}

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

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

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

CypherParser::KU_IfExistsContext* CypherParser::KU_DropPropertyContext::kU_IfExists() {
  return getRuleContext<CypherParser::KU_IfExistsContext>(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, 82, CypherParser::RuleKU_DropProperty);

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

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

    default:
      break;
    }
    setState(1065);
    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, 84, CypherParser::RuleKU_RenameTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1067);
    match(CypherParser::RENAME);
    setState(1068);
    match(CypherParser::SP);
    setState(1069);
    match(CypherParser::TO);
    setState(1070);
    match(CypherParser::SP);
    setState(1071);
    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, 86, CypherParser::RuleKU_RenameProperty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1073);
    match(CypherParser::RENAME);
    setState(1074);
    match(CypherParser::SP);
    setState(1075);
    oC_PropertyKeyName();
    setState(1076);
    match(CypherParser::SP);
    setState(1077);
    match(CypherParser::TO);
    setState(1078);
    match(CypherParser::SP);
    setState(1079);
    oC_PropertyKeyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_AddFromToConnectionContext ------------------------------------------------------------------

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

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

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

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

CypherParser::KU_FromToConnectionContext* CypherParser::KU_AddFromToConnectionContext::kU_FromToConnection() {
  return getRuleContext<CypherParser::KU_FromToConnectionContext>(0);
}

CypherParser::KU_IfNotExistsContext* CypherParser::KU_AddFromToConnectionContext::kU_IfNotExists() {
  return getRuleContext<CypherParser::KU_IfNotExistsContext>(0);
}


size_t CypherParser::KU_AddFromToConnectionContext::getRuleIndex() const {
  return CypherParser::RuleKU_AddFromToConnection;
}


CypherParser::KU_AddFromToConnectionContext* CypherParser::kU_AddFromToConnection() {
  KU_AddFromToConnectionContext *_localctx = _tracker.createInstance<KU_AddFromToConnectionContext>(_ctx, getState());
  enterRule(_localctx, 88, CypherParser::RuleKU_AddFromToConnection);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::IF) {
      setState(1083);
      kU_IfNotExists();
      setState(1084);
      match(CypherParser::SP);
    }
    setState(1088);
    kU_FromToConnection();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_DropFromToConnectionContext ------------------------------------------------------------------

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

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

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

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

CypherParser::KU_FromToConnectionContext* CypherParser::KU_DropFromToConnectionContext::kU_FromToConnection() {
  return getRuleContext<CypherParser::KU_FromToConnectionContext>(0);
}

CypherParser::KU_IfExistsContext* CypherParser::KU_DropFromToConnectionContext::kU_IfExists() {
  return getRuleContext<CypherParser::KU_IfExistsContext>(0);
}


size_t CypherParser::KU_DropFromToConnectionContext::getRuleIndex() const {
  return CypherParser::RuleKU_DropFromToConnection;
}


CypherParser::KU_DropFromToConnectionContext* CypherParser::kU_DropFromToConnection() {
  KU_DropFromToConnectionContext *_localctx = _tracker.createInstance<KU_DropFromToConnectionContext>(_ctx, getState());
  enterRule(_localctx, 90, CypherParser::RuleKU_DropFromToConnection);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::IF) {
      setState(1092);
      kU_IfExists();
      setState(1093);
      match(CypherParser::SP);
    }
    setState(1097);
    kU_FromToConnection();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ColumnDefinitionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::KU_ColumnDefinitionContext *> CypherParser::KU_ColumnDefinitionsContext::kU_ColumnDefinition() {
  return getRuleContexts<CypherParser::KU_ColumnDefinitionContext>();
}

CypherParser::KU_ColumnDefinitionContext* CypherParser::KU_ColumnDefinitionsContext::kU_ColumnDefinition(size_t i) {
  return getRuleContext<CypherParser::KU_ColumnDefinitionContext>(i);
}

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

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


size_t CypherParser::KU_ColumnDefinitionsContext::getRuleIndex() const {
  return CypherParser::RuleKU_ColumnDefinitions;
}


CypherParser::KU_ColumnDefinitionsContext* CypherParser::kU_ColumnDefinitions() {
  KU_ColumnDefinitionsContext *_localctx = _tracker.createInstance<KU_ColumnDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 92, CypherParser::RuleKU_ColumnDefinitions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1099);
    kU_ColumnDefinition();
    setState(1110);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1101);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1100);
          match(CypherParser::SP);
        }
        setState(1103);
        match(CypherParser::T__3);
        setState(1105);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1104);
          match(CypherParser::SP);
        }
        setState(1107);
        kU_ColumnDefinition(); 
      }
      setState(1112);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KU_ColumnDefinitionContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::KU_ColumnDefinitionContext::getRuleIndex() const {
  return CypherParser::RuleKU_ColumnDefinition;
}


CypherParser::KU_ColumnDefinitionContext* CypherParser::kU_ColumnDefinition() {
  KU_ColumnDefinitionContext *_localctx = _tracker.createInstance<KU_ColumnDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 94, CypherParser::RuleKU_ColumnDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1113);
    oC_PropertyKeyName();
    setState(1114);
    match(CypherParser::SP);
    setState(1115);
    kU_DataType(0);
   
  }
  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, 96, 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(1117);
    kU_PropertyDefinition();
    setState(1128);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1119);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1118);
          match(CypherParser::SP);
        }
        setState(1121);
        match(CypherParser::T__3);
        setState(1123);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1122);
          match(CypherParser::SP);
        }
        setState(1125);
        kU_PropertyDefinition(); 
      }
      setState(1130);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _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::KU_ColumnDefinitionContext* CypherParser::KU_PropertyDefinitionContext::kU_ColumnDefinition() {
  return getRuleContext<CypherParser::KU_ColumnDefinitionContext>(0);
}

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

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

CypherParser::KU_DefaultContext* CypherParser::KU_PropertyDefinitionContext::kU_Default() {
  return getRuleContext<CypherParser::KU_DefaultContext>(0);
}

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

tree::TerminalNode* CypherParser::KU_PropertyDefinitionContext::KEY() {
  return getToken(CypherParser::KEY, 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, 98, CypherParser::RuleKU_PropertyDefinition);

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx)) {
    case 1: {
      setState(1136);
      match(CypherParser::SP);
      setState(1137);
      match(CypherParser::PRIMARY);
      setState(1138);
      match(CypherParser::SP);
      setState(1139);
      match(CypherParser::KEY);
      break;
    }

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

  return _localctx;
}

//----------------- 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, 100, 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(1142);
    match(CypherParser::PRIMARY);
    setState(1143);
    match(CypherParser::SP);
    setState(1144);
    match(CypherParser::KEY);
    setState(1146);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1149);
      match(CypherParser::SP);
    }
    setState(1152);
    oC_PropertyKeyName();
    setState(1154);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1153);
      match(CypherParser::SP);
    }
    setState(1156);
    match(CypherParser::T__2);
   
  }
  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_ColumnDefinitionsContext* CypherParser::KU_DataTypeContext::kU_ColumnDefinitions() {
  return getRuleContext<CypherParser::KU_ColumnDefinitionsContext>(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);
}

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

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

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

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

CypherParser::OC_IntegerLiteralContext* CypherParser::KU_DataTypeContext::oC_IntegerLiteral(size_t i) {
  return getRuleContext<CypherParser::OC_IntegerLiteralContext>(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 = 102;
  enterRecursionRule(_localctx, 102, 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(1246);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx)) {
    case 1: {
      setState(1159);
      oC_SymbolicName();
      break;
    }

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1161);
        match(CypherParser::SP);
      }
      setState(1164);
      match(CypherParser::T__1);
      setState(1166);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1165);
        match(CypherParser::SP);
      }
      setState(1168);
      kU_ColumnDefinitions();
      setState(1170);
      _errHandler->sync(this);

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

    case 3: {
      setState(1174);
      match(CypherParser::STRUCT);
      setState(1176);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1175);
        match(CypherParser::SP);
      }
      setState(1178);
      match(CypherParser::T__1);
      setState(1180);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1179);
        match(CypherParser::SP);
      }
      setState(1182);
      kU_ColumnDefinitions();
      setState(1184);
      _errHandler->sync(this);

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

    case 4: {
      setState(1188);
      oC_SymbolicName();
      setState(1190);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1189);
        match(CypherParser::SP);
      }
      setState(1192);
      match(CypherParser::T__1);
      setState(1194);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1193);
        match(CypherParser::SP);
      }
      setState(1196);
      kU_ColumnDefinitions();
      setState(1198);
      _errHandler->sync(this);

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

    case 5: {
      setState(1202);
      oC_SymbolicName();
      setState(1204);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1203);
        match(CypherParser::SP);
      }
      setState(1206);
      match(CypherParser::T__1);
      setState(1208);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1207);
        match(CypherParser::SP);
      }
      setState(1210);
      kU_DataType(0);
      setState(1212);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1211);
        match(CypherParser::SP);
      }
      setState(1214);
      match(CypherParser::T__3);
      setState(1216);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1215);
        match(CypherParser::SP);
      }
      setState(1218);
      kU_DataType(0);
      setState(1220);
      _errHandler->sync(this);

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

    case 6: {
      setState(1224);
      match(CypherParser::DECIMAL);
      setState(1226);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1225);
        match(CypherParser::SP);
      }
      setState(1228);
      match(CypherParser::T__1);
      setState(1230);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1229);
        match(CypherParser::SP);
      }
      setState(1232);
      oC_IntegerLiteral();
      setState(1234);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1233);
        match(CypherParser::SP);
      }
      setState(1236);
      match(CypherParser::T__3);
      setState(1238);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1237);
        match(CypherParser::SP);
      }
      setState(1240);
      oC_IntegerLiteral();
      setState(1242);
      _errHandler->sync(this);

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

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(1252);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 157, _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(1248);

        if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
        setState(1249);
        kU_ListIdentifiers(); 
      }
      setState(1254);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 157, _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, 104, CypherParser::RuleKU_ListIdentifiers);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1255);
    kU_ListIdentifier();
    setState(1259);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1256);
        kU_ListIdentifier(); 
      }
      setState(1261);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _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, 106, 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(1262);
    match(CypherParser::T__6);
    setState(1264);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::DecimalInteger) {
      setState(1263);
      oC_IntegerLiteral();
    }
    setState(1266);
    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, 108, CypherParser::RuleOC_AnyCypherOption);

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

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

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

tree::TerminalNode* CypherParser::OC_ExplainContext::LOGICAL() {
  return getToken(CypherParser::LOGICAL, 0);
}


size_t CypherParser::OC_ExplainContext::getRuleIndex() const {
  return CypherParser::RuleOC_Explain;
}


CypherParser::OC_ExplainContext* CypherParser::oC_Explain() {
  OC_ExplainContext *_localctx = _tracker.createInstance<OC_ExplainContext>(_ctx, getState());
  enterRule(_localctx, 110, CypherParser::RuleOC_Explain);

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

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

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

  return _localctx;
}

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1277);
    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::ROLLBACK() {
  return getToken(CypherParser::ROLLBACK, 0);
}

tree::TerminalNode* CypherParser::KU_TransactionContext::CHECKPOINT() {
  return getToken(CypherParser::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, 114, CypherParser::RuleKU_Transaction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1292);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 162, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1279);
      match(CypherParser::BEGIN);
      setState(1280);
      match(CypherParser::SP);
      setState(1281);
      match(CypherParser::TRANSACTION);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1282);
      match(CypherParser::BEGIN);
      setState(1283);
      match(CypherParser::SP);
      setState(1284);
      match(CypherParser::TRANSACTION);
      setState(1285);
      match(CypherParser::SP);
      setState(1286);
      match(CypherParser::READ);
      setState(1287);
      match(CypherParser::SP);
      setState(1288);
      match(CypherParser::ONLY);
      break;
    }

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

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1290);
      match(CypherParser::ROLLBACK);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1291);
      match(CypherParser::CHECKPOINT);
      break;
    }

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

  return _localctx;
}

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

CypherParser::KU_UninstallExtensionContext* CypherParser::KU_ExtensionContext::kU_UninstallExtension() {
  return getRuleContext<CypherParser::KU_UninstallExtensionContext>(0);
}

CypherParser::KU_UpdateExtensionContext* CypherParser::KU_ExtensionContext::kU_UpdateExtension() {
  return getRuleContext<CypherParser::KU_UpdateExtensionContext>(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, 116, CypherParser::RuleKU_Extension);

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

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

      case CypherParser::UNINSTALL: {
        enterOuterAlt(_localctx, 3);
        setState(1296);
        kU_UninstallExtension();
        break;
      }

      case CypherParser::UPDATE: {
        enterOuterAlt(_localctx, 4);
        setState(1297);
        kU_UpdateExtension();
        break;
      }

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

  return _localctx;
}

//----------------- 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::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}

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

tree::TerminalNode* CypherParser::KU_LoadExtensionContext::EXTENSION() {
  return getToken(CypherParser::EXTENSION, 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, 118, CypherParser::RuleKU_LoadExtension);

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

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

    default:
      break;
    }
    setState(1308);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::StringLiteral: {
        setState(1306);
        match(CypherParser::StringLiteral);
        break;
      }

      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(1307);
        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);
}

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

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

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

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

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

tree::TerminalNode* CypherParser::KU_InstallExtensionContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 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, 120, CypherParser::RuleKU_InstallExtension);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::FORCE) {
      setState(1310);
      match(CypherParser::FORCE);
      setState(1311);
      match(CypherParser::SP);
    }
    setState(1314);
    match(CypherParser::INSTALL);
    setState(1315);
    match(CypherParser::SP);
    setState(1316);
    oC_Variable();
    setState(1321);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 167, _ctx)) {
    case 1: {
      setState(1317);
      match(CypherParser::SP);
      setState(1318);
      match(CypherParser::FROM);
      setState(1319);
      match(CypherParser::SP);
      setState(1320);
      match(CypherParser::StringLiteral);
      break;
    }

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

  return _localctx;
}

//----------------- KU_UninstallExtensionContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_UninstallExtensionContext::UNINSTALL() {
  return getToken(CypherParser::UNINSTALL, 0);
}

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

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


size_t CypherParser::KU_UninstallExtensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_UninstallExtension;
}


CypherParser::KU_UninstallExtensionContext* CypherParser::kU_UninstallExtension() {
  KU_UninstallExtensionContext *_localctx = _tracker.createInstance<KU_UninstallExtensionContext>(_ctx, getState());
  enterRule(_localctx, 122, CypherParser::RuleKU_UninstallExtension);

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

  return _localctx;
}

//----------------- KU_UpdateExtensionContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_UpdateExtensionContext::UPDATE() {
  return getToken(CypherParser::UPDATE, 0);
}

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

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


size_t CypherParser::KU_UpdateExtensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_UpdateExtension;
}


CypherParser::KU_UpdateExtensionContext* CypherParser::kU_UpdateExtension() {
  KU_UpdateExtensionContext *_localctx = _tracker.createInstance<KU_UpdateExtensionContext>(_ctx, getState());
  enterRule(_localctx, 124, CypherParser::RuleKU_UpdateExtension);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1327);
    match(CypherParser::UPDATE);
    setState(1328);
    match(CypherParser::SP);
    setState(1329);
    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, 126, CypherParser::RuleOC_Query);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1331);
    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, 128, 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(1354);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1333);
      oC_SingleQuery();
      setState(1340);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 169, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1335);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1334);
            match(CypherParser::SP);
          }
          setState(1337);
          oC_Union(); 
        }
        setState(1342);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 169, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1347); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1343);
                oC_Return();
                setState(1345);
                _errHandler->sync(this);

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

        default:
          throw NoViableAltException(this);
        }
        setState(1349); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      setState(1351);
      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, 130, CypherParser::RuleOC_Union);
  size_t _la = 0;

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1364);
        match(CypherParser::SP);
      }
      setState(1367);
      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, 132, CypherParser::RuleOC_SingleQuery);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1371);
      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, 134, 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(1409);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 185, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1380);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::CALL || ((((_la - 104) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 104)) & 2199023288329) != 0)) {
        setState(1374);
        oC_ReadingClause();
        setState(1376);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1375);
          match(CypherParser::SP);
        }
        setState(1382);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1383);
      oC_Return();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1390);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::CALL || ((((_la - 104) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 104)) & 2199023288329) != 0)) {
        setState(1384);
        oC_ReadingClause();
        setState(1386);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1385);
          match(CypherParser::SP);
        }
        setState(1392);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1393);
      oC_UpdatingClause();
      setState(1400);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 182, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1395);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1394);
            match(CypherParser::SP);
          }
          setState(1397);
          oC_UpdatingClause(); 
        }
        setState(1402);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 182, _ctx);
      }
      setState(1407);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

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

  return _localctx;
}

//----------------- 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, 136, 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(1415); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1411);
              kU_QueryPart();
              setState(1413);
              _errHandler->sync(this);

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

      default:
        throw NoViableAltException(this);
      }
      setState(1417); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 187, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
    setState(1419);
    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, 138, 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(1427);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::CALL || ((((_la - 104) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 104)) & 2199023288329) != 0)) {
      setState(1421);
      oC_ReadingClause();
      setState(1423);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1422);
        match(CypherParser::SP);
      }
      setState(1429);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1436);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 69) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 69)) & -9223370937343147743) != 0)) {
      setState(1430);
      oC_UpdatingClause();
      setState(1432);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1431);
        match(CypherParser::SP);
      }
      setState(1438);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1439);
    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, 140, CypherParser::RuleOC_UpdatingClause);

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

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

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

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

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

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

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

      case CypherParser::LOAD: {
        enterOuterAlt(_localctx, 4);
        setState(1450);
        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_ColumnDefinitionsContext* CypherParser::KU_LoadFromContext::kU_ColumnDefinitions() {
  return getRuleContext<CypherParser::KU_ColumnDefinitionsContext>(0);
}

CypherParser::KU_OptionsContext* CypherParser::KU_LoadFromContext::kU_Options() {
  return getRuleContext<CypherParser::KU_OptionsContext>(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, 144, 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(1453);
    match(CypherParser::LOAD);
    setState(1471);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 197, _ctx)) {
    case 1: {
      setState(1454);
      match(CypherParser::SP);
      setState(1455);
      match(CypherParser::WITH);
      setState(1456);
      match(CypherParser::SP);
      setState(1457);
      match(CypherParser::HEADERS);
      setState(1459);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1458);
        match(CypherParser::SP);
      }
      setState(1461);
      match(CypherParser::T__1);
      setState(1463);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1462);
        match(CypherParser::SP);
      }
      setState(1465);
      kU_ColumnDefinitions();
      setState(1467);
      _errHandler->sync(this);

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

    default:
      break;
    }
    setState(1473);
    match(CypherParser::SP);
    setState(1474);
    match(CypherParser::FROM);
    setState(1475);
    match(CypherParser::SP);
    setState(1476);
    kU_ScanSource();
    setState(1490);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1477);
        match(CypherParser::SP);
      }
      setState(1480);
      match(CypherParser::T__1);
      setState(1482);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1481);
        match(CypherParser::SP);
      }
      setState(1484);
      kU_Options();
      setState(1486);
      _errHandler->sync(this);

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

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

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

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

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

std::vector<CypherParser::OC_VariableContext *> CypherParser::OC_YieldItemContext::oC_Variable() {
  return getRuleContexts<CypherParser::OC_VariableContext>();
}

CypherParser::OC_VariableContext* CypherParser::OC_YieldItemContext::oC_Variable(size_t i) {
  return getRuleContext<CypherParser::OC_VariableContext>(i);
}

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

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

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


size_t CypherParser::OC_YieldItemContext::getRuleIndex() const {
  return CypherParser::RuleOC_YieldItem;
}


CypherParser::OC_YieldItemContext* CypherParser::oC_YieldItem() {
  OC_YieldItemContext *_localctx = _tracker.createInstance<OC_YieldItemContext>(_ctx, getState());
  enterRule(_localctx, 146, CypherParser::RuleOC_YieldItem);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 204, _ctx)) {
    case 1: {
      setState(1498);
      oC_Variable();
      setState(1499);
      match(CypherParser::SP);
      setState(1500);
      match(CypherParser::AS);
      setState(1501);
      match(CypherParser::SP);
      break;
    }

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

  return _localctx;
}

//----------------- OC_YieldItemsContext ------------------------------------------------------------------

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

std::vector<CypherParser::OC_YieldItemContext *> CypherParser::OC_YieldItemsContext::oC_YieldItem() {
  return getRuleContexts<CypherParser::OC_YieldItemContext>();
}

CypherParser::OC_YieldItemContext* CypherParser::OC_YieldItemsContext::oC_YieldItem(size_t i) {
  return getRuleContext<CypherParser::OC_YieldItemContext>(i);
}

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

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


size_t CypherParser::OC_YieldItemsContext::getRuleIndex() const {
  return CypherParser::RuleOC_YieldItems;
}


CypherParser::OC_YieldItemsContext* CypherParser::oC_YieldItems() {
  OC_YieldItemsContext *_localctx = _tracker.createInstance<OC_YieldItemsContext>(_ctx, getState());
  enterRule(_localctx, 148, CypherParser::RuleOC_YieldItems);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1507);
    oC_YieldItem();
    setState(1518);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1509);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1508);
          match(CypherParser::SP);
        }
        setState(1511);
        match(CypherParser::T__3);
        setState(1513);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1512);
          match(CypherParser::SP);
        }
        setState(1515);
        oC_YieldItem(); 
      }
      setState(1520);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx);
    }
   
  }
  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);
}

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

CypherParser::OC_YieldItemsContext* CypherParser::KU_InQueryCallContext::oC_YieldItems() {
  return getRuleContext<CypherParser::OC_YieldItemsContext>(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, 150, 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(1521);
    match(CypherParser::CALL);
    setState(1522);
    match(CypherParser::SP);
    setState(1523);
    oC_FunctionInvocation();
    setState(1528);
    _errHandler->sync(this);

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

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1530);
        match(CypherParser::SP);
      }
      setState(1533);
      match(CypherParser::YIELD);
      setState(1534);
      match(CypherParser::SP);
      setState(1535);
      oC_YieldItems();
      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);
}

CypherParser::KU_HintContext* CypherParser::OC_MatchContext::kU_Hint() {
  return getRuleContext<CypherParser::KU_HintContext>(0);
}


size_t CypherParser::OC_MatchContext::getRuleIndex() const {
  return CypherParser::RuleOC_Match;
}


CypherParser::OC_MatchContext* CypherParser::oC_Match() {
  OC_MatchContext *_localctx = _tracker.createInstance<OC_MatchContext>(_ctx, getState());
  enterRule(_localctx, 152, 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(1540);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::OPTIONAL) {
      setState(1538);
      match(CypherParser::OPTIONAL);
      setState(1539);
      match(CypherParser::SP);
    }
    setState(1542);
    match(CypherParser::MATCH);
    setState(1544);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1543);
      match(CypherParser::SP);
    }
    setState(1546);
    oC_Pattern();
    setState(1549);
    _errHandler->sync(this);

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

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

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

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

  return _localctx;
}

//----------------- KU_HintContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_HintContext::HINT() {
  return getToken(CypherParser::HINT, 0);
}

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

CypherParser::KU_JoinNodeContext* CypherParser::KU_HintContext::kU_JoinNode() {
  return getRuleContext<CypherParser::KU_JoinNodeContext>(0);
}


size_t CypherParser::KU_HintContext::getRuleIndex() const {
  return CypherParser::RuleKU_Hint;
}


CypherParser::KU_HintContext* CypherParser::kU_Hint() {
  KU_HintContext *_localctx = _tracker.createInstance<KU_HintContext>(_ctx, getState());
  enterRule(_localctx, 154, CypherParser::RuleKU_Hint);

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

  return _localctx;
}

//----------------- KU_JoinNodeContext ------------------------------------------------------------------

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

std::vector<CypherParser::KU_JoinNodeContext *> CypherParser::KU_JoinNodeContext::kU_JoinNode() {
  return getRuleContexts<CypherParser::KU_JoinNodeContext>();
}

CypherParser::KU_JoinNodeContext* CypherParser::KU_JoinNodeContext::kU_JoinNode(size_t i) {
  return getRuleContext<CypherParser::KU_JoinNodeContext>(i);
}

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

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

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

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

tree::TerminalNode* CypherParser::KU_JoinNodeContext::JOIN() {
  return getToken(CypherParser::JOIN, 0);
}

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

tree::TerminalNode* CypherParser::KU_JoinNodeContext::MULTI_JOIN(size_t i) {
  return getToken(CypherParser::MULTI_JOIN, i);
}


size_t CypherParser::KU_JoinNodeContext::getRuleIndex() const {
  return CypherParser::RuleKU_JoinNode;
}



CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode() {
   return kU_JoinNode(0);
}

CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  CypherParser::KU_JoinNodeContext *_localctx = _tracker.createInstance<KU_JoinNodeContext>(_ctx, parentState);
  CypherParser::KU_JoinNodeContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 156;
  enterRecursionRule(_localctx, 156, CypherParser::RuleKU_JoinNode, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1571);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::T__1: {
        setState(1560);
        match(CypherParser::T__1);
        setState(1562);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1561);
          match(CypherParser::SP);
        }
        setState(1564);
        kU_JoinNode(0);
        setState(1566);
        _errHandler->sync(this);

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

      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(1570);
        oC_SchemaName();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(1589);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 221, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(1587);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 220, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<KU_JoinNodeContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleKU_JoinNode);
          setState(1573);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(1574);
          match(CypherParser::SP);
          setState(1575);
          match(CypherParser::JOIN);
          setState(1576);
          match(CypherParser::SP);
          setState(1577);
          kU_JoinNode(5);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<KU_JoinNodeContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleKU_JoinNode);
          setState(1578);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(1583); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(1579);
                    match(CypherParser::SP);
                    setState(1580);
                    match(CypherParser::MULTI_JOIN);
                    setState(1581);
                    match(CypherParser::SP);
                    setState(1582);
                    oC_SchemaName();
                    break;
                  }

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

        default:
          break;
        } 
      }
      setState(1591);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 221, _ctx);
    }
  }
  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, 158, 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(1592);
    match(CypherParser::UNWIND);
    setState(1594);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1593);
      match(CypherParser::SP);
    }
    setState(1596);
    oC_Expression();
    setState(1597);
    match(CypherParser::SP);
    setState(1598);
    match(CypherParser::AS);
    setState(1599);
    match(CypherParser::SP);
    setState(1600);
    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, 160, 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(1602);
    match(CypherParser::CREATE);
    setState(1604);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1603);
      match(CypherParser::SP);
    }
    setState(1606);
    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, 162, 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(1608);
    match(CypherParser::MERGE);
    setState(1610);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1609);
      match(CypherParser::SP);
    }
    setState(1612);
    oC_Pattern();
    setState(1617);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1613);
        match(CypherParser::SP);
        setState(1614);
        oC_MergeAction(); 
      }
      setState(1619);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1630);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 226, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1620);
      match(CypherParser::ON);
      setState(1621);
      match(CypherParser::SP);
      setState(1622);
      match(CypherParser::MATCH);
      setState(1623);
      match(CypherParser::SP);
      setState(1624);
      oC_Set();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1625);
      match(CypherParser::ON);
      setState(1626);
      match(CypherParser::SP);
      setState(1627);
      match(CypherParser::CREATE);
      setState(1628);
      match(CypherParser::SP);
      setState(1629);
      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, 166, 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(1632);
    match(CypherParser::SET);
    setState(1634);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1633);
      match(CypherParser::SP);
    }
    setState(1636);
    oC_SetItem();
    setState(1647);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1638);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1637);
          match(CypherParser::SP);
        }
        setState(1640);
        match(CypherParser::T__3);
        setState(1642);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1641);
          match(CypherParser::SP);
        }
        setState(1644);
        oC_SetItem(); 
      }
      setState(1649);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _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, 168, 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(1650);
    oC_PropertyExpression();
    setState(1652);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1651);
      match(CypherParser::SP);
    }
    setState(1654);
    match(CypherParser::T__5);
    setState(1656);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1655);
      match(CypherParser::SP);
    }
    setState(1658);
    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, 170, 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(1662);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::DETACH) {
      setState(1660);
      match(CypherParser::DETACH);
      setState(1661);
      match(CypherParser::SP);
    }
    setState(1664);
    match(CypherParser::DELETE);
    setState(1666);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1665);
      match(CypherParser::SP);
    }
    setState(1668);
    oC_Expression();
    setState(1679);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 237, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1670);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1669);
          match(CypherParser::SP);
        }
        setState(1672);
        match(CypherParser::T__3);
        setState(1674);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1673);
          match(CypherParser::SP);
        }
        setState(1676);
        oC_Expression(); 
      }
      setState(1681);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 237, _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, 172, 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(1682);
    match(CypherParser::WITH);
    setState(1683);
    oC_ProjectionBody();
    setState(1688);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1684);
        match(CypherParser::SP);
      }
      setState(1687);
      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, 174, CypherParser::RuleOC_Return);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1690);
    match(CypherParser::RETURN);
    setState(1691);
    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, 176, 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(1697);
    _errHandler->sync(this);

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

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

    default:
      break;
    }
    setState(1699);
    match(CypherParser::SP);
    setState(1700);
    oC_ProjectionItems();
    setState(1703);
    _errHandler->sync(this);

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

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 244, _ctx)) {
    case 1: {
      setState(1709);
      match(CypherParser::SP);
      setState(1710);
      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, 178, 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(1741);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::STAR: {
        enterOuterAlt(_localctx, 1);
        setState(1713);
        match(CypherParser::STAR);
        setState(1724);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(1715);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1714);
              match(CypherParser::SP);
            }
            setState(1717);
            match(CypherParser::T__3);
            setState(1719);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1718);
              match(CypherParser::SP);
            }
            setState(1721);
            oC_ProjectionItem(); 
          }
          setState(1726);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _ctx);
        }
        break;
      }

      case CypherParser::T__1:
      case CypherParser::T__6:
      case CypherParser::T__8:
      case CypherParser::T__25:
      case CypherParser::ANY:
      case CypherParser::ADD:
      case CypherParser::ALL:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CASE:
      case CypherParser::CAST:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXISTS:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FALSE:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::NOT:
      case CypherParser::NONE:
      case CypherParser::NULL_:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TRUE:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::SINGLE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::MINUS:
      case CypherParser::StringLiteral:
      case CypherParser::DecimalInteger:
      case CypherParser::HexLetter:
      case CypherParser::ExponentDecimalReal:
      case CypherParser::RegularDecimalReal:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 2);
        setState(1727);
        oC_ProjectionItem();
        setState(1738);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 250, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(1729);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1728);
              match(CypherParser::SP);
            }
            setState(1731);
            match(CypherParser::T__3);
            setState(1733);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1732);
              match(CypherParser::SP);
            }
            setState(1735);
            oC_ProjectionItem(); 
          }
          setState(1740);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 250, _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, 180, CypherParser::RuleOC_ProjectionItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1750);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1743);
      oC_Expression();
      setState(1744);
      match(CypherParser::SP);
      setState(1745);
      match(CypherParser::AS);
      setState(1746);
      match(CypherParser::SP);
      setState(1747);
      oC_Variable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1749);
      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, 182, 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(1752);
    match(CypherParser::ORDER);
    setState(1753);
    match(CypherParser::SP);
    setState(1754);
    match(CypherParser::BY);
    setState(1755);
    match(CypherParser::SP);
    setState(1756);
    oC_SortItem();
    setState(1764);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__3) {
      setState(1757);
      match(CypherParser::T__3);
      setState(1759);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1758);
        match(CypherParser::SP);
      }
      setState(1761);
      oC_SortItem();
      setState(1766);
      _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, 184, CypherParser::RuleOC_Skip);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1767);
    match(CypherParser::L_SKIP);
    setState(1768);
    match(CypherParser::SP);
    setState(1769);
    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, 186, CypherParser::RuleOC_Limit);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1771);
    match(CypherParser::LIMIT);
    setState(1772);
    match(CypherParser::SP);
    setState(1773);
    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, 188, 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(1775);
    oC_Expression();
    setState(1780);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1776);
        match(CypherParser::SP);
      }
      setState(1779);
      _la = _input->LA(1);
      if (!(((((_la - 53) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 53)) & 12582915) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

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

  return _localctx;
}

//----------------- 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, 190, CypherParser::RuleOC_Where);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1782);
    match(CypherParser::WHERE);
    setState(1783);
    match(CypherParser::SP);
    setState(1784);
    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, 192, 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(1786);
    oC_PatternPart();
    setState(1797);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 259, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1788);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1787);
          match(CypherParser::SP);
        }
        setState(1790);
        match(CypherParser::T__3);
        setState(1792);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1791);
          match(CypherParser::SP);
        }
        setState(1794);
        oC_PatternPart(); 
      }
      setState(1799);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 259, _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, 194, CypherParser::RuleOC_PatternPart);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1811);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(1800);
        oC_Variable();
        setState(1802);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1801);
          match(CypherParser::SP);
        }
        setState(1804);
        match(CypherParser::T__5);
        setState(1806);
        _errHandler->sync(this);

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

      case CypherParser::T__1: {
        enterOuterAlt(_localctx, 2);
        setState(1810);
        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, 196, CypherParser::RuleOC_AnonymousPatternPart);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1813);
    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, 198, 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(1829);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 265, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1815);
      oC_NodePattern();
      setState(1822);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 264, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1817);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1816);
            match(CypherParser::SP);
          }
          setState(1819);
          oC_PatternElementChain(); 
        }
        setState(1824);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 264, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1825);
      match(CypherParser::T__1);
      setState(1826);
      oC_PatternElement();
      setState(1827);
      match(CypherParser::T__2);
      break;
    }

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

  return _localctx;
}

//----------------- 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, 200, 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(1831);
    match(CypherParser::T__1);
    setState(1833);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -6371186097845698560) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1151940922579049251) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2534380494694747) != 0)) {
      setState(1835);
      oC_Variable();
      setState(1837);
      _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::COLON) {
      setState(1841);
      oC_NodeLabels();
      setState(1843);
      _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__8) {
      setState(1847);
      kU_Properties();
      setState(1849);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1848);
        match(CypherParser::SP);
      }
    }
    setState(1853);
    match(CypherParser::T__2);
   
  }
  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, 202, 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(1855);
    oC_RelationshipPattern();
    setState(1857);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1856);
      match(CypherParser::SP);
    }
    setState(1859);
    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, 204, CypherParser::RuleOC_RelationshipPattern);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1862);
        match(CypherParser::SP);
      }
      setState(1865);
      oC_Dash();
      setState(1867);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::T__6) {
        setState(1869);
        oC_RelationshipDetail();
      }
      setState(1873);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1877);
      oC_Dash();
      setState(1879);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::T__6) {
        setState(1881);
        oC_RelationshipDetail();
      }
      setState(1885);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1884);
        match(CypherParser::SP);
      }
      setState(1887);
      oC_Dash();
      setState(1889);
      _errHandler->sync(this);

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

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1893);
      oC_Dash();
      setState(1895);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::T__6) {
        setState(1897);
        oC_RelationshipDetail();
      }
      setState(1901);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1900);
        match(CypherParser::SP);
      }
      setState(1903);
      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::KU_RecursiveDetailContext* CypherParser::OC_RelationshipDetailContext::kU_RecursiveDetail() {
  return getRuleContext<CypherParser::KU_RecursiveDetailContext>(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, 206, 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(1907);
    match(CypherParser::T__6);
    setState(1909);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -6371186097845698560) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1151940922579049251) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2534380494694747) != 0)) {
      setState(1911);
      oC_Variable();
      setState(1913);
      _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::COLON) {
      setState(1917);
      oC_RelationshipTypes();
      setState(1919);
      _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::STAR) {
      setState(1923);
      kU_RecursiveDetail();
      setState(1925);
      _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__8) {
      setState(1929);
      kU_Properties();
      setState(1931);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1930);
        match(CypherParser::SP);
      }
    }
    setState(1935);
    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, 208, 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(1937);
    match(CypherParser::T__8);
    setState(1939);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -6371186097845698560) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1151940922579049251) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2534380494694747) != 0)) {
      setState(1941);
      oC_PropertyKeyName();
      setState(1943);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1942);
        match(CypherParser::SP);
      }
      setState(1945);
      match(CypherParser::COLON);
      setState(1947);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1946);
        match(CypherParser::SP);
      }
      setState(1949);
      oC_Expression();
      setState(1951);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1950);
        match(CypherParser::SP);
      }
      setState(1971);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::T__3) {
        setState(1953);
        match(CypherParser::T__3);
        setState(1955);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1954);
          match(CypherParser::SP);
        }
        setState(1957);
        oC_PropertyKeyName();
        setState(1959);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1958);
          match(CypherParser::SP);
        }
        setState(1961);
        match(CypherParser::COLON);
        setState(1963);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1962);
          match(CypherParser::SP);
        }
        setState(1965);
        oC_Expression();
        setState(1967);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1966);
          match(CypherParser::SP);
        }
        setState(1973);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(1976);
    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, 210, 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(1978);
    match(CypherParser::COLON);
    setState(1980);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1979);
      match(CypherParser::SP);
    }
    setState(1982);
    oC_RelTypeName();
    setState(1996);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 309, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1984);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1983);
          match(CypherParser::SP);
        }
        setState(1986);
        match(CypherParser::T__10);
        setState(1988);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::COLON) {
          setState(1987);
          match(CypherParser::COLON);
        }
        setState(1991);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1990);
          match(CypherParser::SP);
        }
        setState(1993);
        oC_RelTypeName(); 
      }
      setState(1998);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 309, _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, 212, 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(1999);
    oC_NodeLabel();
    setState(2006);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2001);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2000);
          match(CypherParser::SP);
        }
        setState(2003);
        oC_NodeLabel(); 
      }
      setState(2008);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _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, 214, 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(2009);
    match(CypherParser::COLON);
    setState(2011);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- KU_RecursiveDetailContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_RecursiveDetailContext::STAR() {
  return getToken(CypherParser::STAR, 0);
}

CypherParser::KU_RecursiveTypeContext* CypherParser::KU_RecursiveDetailContext::kU_RecursiveType() {
  return getRuleContext<CypherParser::KU_RecursiveTypeContext>(0);
}

CypherParser::OC_RangeLiteralContext* CypherParser::KU_RecursiveDetailContext::oC_RangeLiteral() {
  return getRuleContext<CypherParser::OC_RangeLiteralContext>(0);
}

CypherParser::KU_RecursiveComprehensionContext* CypherParser::KU_RecursiveDetailContext::kU_RecursiveComprehension() {
  return getRuleContext<CypherParser::KU_RecursiveComprehensionContext>(0);
}

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

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


size_t CypherParser::KU_RecursiveDetailContext::getRuleIndex() const {
  return CypherParser::RuleKU_RecursiveDetail;
}


CypherParser::KU_RecursiveDetailContext* CypherParser::kU_RecursiveDetail() {
  KU_RecursiveDetailContext *_localctx = _tracker.createInstance<KU_RecursiveDetailContext>(_ctx, getState());
  enterRule(_localctx, 216, CypherParser::RuleKU_RecursiveDetail);
  size_t _la = 0;

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

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

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

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

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

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

      default:
        break;
      }
      setState(2025);
      oC_RangeLiteral();
      break;
    }

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

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

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

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

  return _localctx;
}

//----------------- KU_RecursiveTypeContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::KU_RecursiveTypeContext::WSHORTEST() {
  return getToken(CypherParser::WSHORTEST, 0);
}

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

tree::TerminalNode* CypherParser::KU_RecursiveTypeContext::ALL() {
  return getToken(CypherParser::ALL, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_RecursiveTypeContext::SHORTEST() {
  return getToken(CypherParser::SHORTEST, 0);
}

tree::TerminalNode* CypherParser::KU_RecursiveTypeContext::TRAIL() {
  return getToken(CypherParser::TRAIL, 0);
}

tree::TerminalNode* CypherParser::KU_RecursiveTypeContext::ACYCLIC() {
  return getToken(CypherParser::ACYCLIC, 0);
}


size_t CypherParser::KU_RecursiveTypeContext::getRuleIndex() const {
  return CypherParser::RuleKU_RecursiveType;
}


CypherParser::KU_RecursiveTypeContext* CypherParser::kU_RecursiveType() {
  KU_RecursiveTypeContext *_localctx = _tracker.createInstance<KU_RecursiveTypeContext>(_ctx, getState());
  enterRule(_localctx, 218, CypherParser::RuleKU_RecursiveType);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == CypherParser::ALL) {
        setState(2034);
        match(CypherParser::ALL);
        setState(2035);
        match(CypherParser::SP);
      }
      setState(2038);
      match(CypherParser::WSHORTEST);
      setState(2040);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2039);
        match(CypherParser::SP);
      }
      setState(2042);
      match(CypherParser::T__1);
      setState(2044);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2043);
        match(CypherParser::SP);
      }
      setState(2046);
      oC_PropertyKeyName();
      setState(2048);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2052);
      match(CypherParser::SHORTEST);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2053);
      match(CypherParser::ALL);
      setState(2054);
      match(CypherParser::SP);
      setState(2055);
      match(CypherParser::SHORTEST);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2056);
      match(CypherParser::TRAIL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2057);
      match(CypherParser::ACYCLIC);
      break;
    }

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

  return _localctx;
}

//----------------- OC_RangeLiteralContext ------------------------------------------------------------------

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

CypherParser::OC_LowerBoundContext* CypherParser::OC_RangeLiteralContext::oC_LowerBound() {
  return getRuleContext<CypherParser::OC_LowerBoundContext>(0);
}

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

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

CypherParser::OC_UpperBoundContext* CypherParser::OC_RangeLiteralContext::oC_UpperBound() {
  return getRuleContext<CypherParser::OC_UpperBoundContext>(0);
}

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


size_t CypherParser::OC_RangeLiteralContext::getRuleIndex() const {
  return CypherParser::RuleOC_RangeLiteral;
}


CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() {
  OC_RangeLiteralContext *_localctx = _tracker.createInstance<OC_RangeLiteralContext>(_ctx, getState());
  enterRule(_localctx, 220, CypherParser::RuleOC_RangeLiteral);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == CypherParser::DecimalInteger) {
        setState(2060);
        oC_LowerBound();
      }
      setState(2064);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2063);
        match(CypherParser::SP);
      }
      setState(2066);
      match(CypherParser::T__11);
      setState(2068);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::DecimalInteger) {
        setState(2070);
        oC_UpperBound();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2073);
      oC_IntegerLiteral();
      break;
    }

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

  return _localctx;
}

//----------------- KU_RecursiveComprehensionContext ------------------------------------------------------------------

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

std::vector<CypherParser::OC_VariableContext *> CypherParser::KU_RecursiveComprehensionContext::oC_Variable() {
  return getRuleContexts<CypherParser::OC_VariableContext>();
}

CypherParser::OC_VariableContext* CypherParser::KU_RecursiveComprehensionContext::oC_Variable(size_t i) {
  return getRuleContext<CypherParser::OC_VariableContext>(i);
}

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

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

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

std::vector<CypherParser::KU_RecursiveProjectionItemsContext *> CypherParser::KU_RecursiveComprehensionContext::kU_RecursiveProjectionItems() {
  return getRuleContexts<CypherParser::KU_RecursiveProjectionItemsContext>();
}

CypherParser::KU_RecursiveProjectionItemsContext* CypherParser::KU_RecursiveComprehensionContext::kU_RecursiveProjectionItems(size_t i) {
  return getRuleContext<CypherParser::KU_RecursiveProjectionItemsContext>(i);
}


size_t CypherParser::KU_RecursiveComprehensionContext::getRuleIndex() const {
  return CypherParser::RuleKU_RecursiveComprehension;
}


CypherParser::KU_RecursiveComprehensionContext* CypherParser::kU_RecursiveComprehension() {
  KU_RecursiveComprehensionContext *_localctx = _tracker.createInstance<KU_RecursiveComprehensionContext>(_ctx, getState());
  enterRule(_localctx, 222, CypherParser::RuleKU_RecursiveComprehension);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2077);
      match(CypherParser::SP);
    }
    setState(2080);
    oC_Variable();
    setState(2082);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2081);
      match(CypherParser::SP);
    }
    setState(2084);
    match(CypherParser::T__3);
    setState(2086);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2085);
      match(CypherParser::SP);
    }
    setState(2088);
    oC_Variable();
    setState(2100);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2089);
        match(CypherParser::SP);
      }
      setState(2092);
      match(CypherParser::T__10);
      setState(2094);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2093);
        match(CypherParser::SP);
      }
      setState(2096);
      oC_Where();
      setState(2098);
      _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__10 || _la == CypherParser::SP) {
      setState(2103);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2102);
        match(CypherParser::SP);
      }
      setState(2105);
      match(CypherParser::T__10);
      setState(2107);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2106);
        match(CypherParser::SP);
      }
      setState(2109);
      kU_RecursiveProjectionItems();
      setState(2111);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2110);
        match(CypherParser::SP);
      }
      setState(2113);
      match(CypherParser::T__3);
      setState(2115);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2114);
        match(CypherParser::SP);
      }
      setState(2117);
      kU_RecursiveProjectionItems();
      setState(2119);
      _errHandler->sync(this);

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

  return _localctx;
}

//----------------- KU_RecursiveProjectionItemsContext ------------------------------------------------------------------

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

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

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

CypherParser::OC_ProjectionItemsContext* CypherParser::KU_RecursiveProjectionItemsContext::oC_ProjectionItems() {
  return getRuleContext<CypherParser::OC_ProjectionItemsContext>(0);
}


size_t CypherParser::KU_RecursiveProjectionItemsContext::getRuleIndex() const {
  return CypherParser::RuleKU_RecursiveProjectionItems;
}


CypherParser::KU_RecursiveProjectionItemsContext* CypherParser::kU_RecursiveProjectionItems() {
  KU_RecursiveProjectionItemsContext *_localctx = _tracker.createInstance<KU_RecursiveProjectionItemsContext>(_ctx, getState());
  enterRule(_localctx, 224, CypherParser::RuleKU_RecursiveProjectionItems);
  size_t _la = 0;

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

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -4641100153426541948) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1144059623222237987) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2746210563451227) != 0)) {
      setState(2129);
      oC_ProjectionItems();
    }
    setState(2133);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2132);
      match(CypherParser::SP);
    }
    setState(2135);
    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, 226, CypherParser::RuleOC_LowerBound);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2137);
    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, 228, CypherParser::RuleOC_UpperBound);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2139);
    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, 230, CypherParser::RuleOC_LabelName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2141);
    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, 232, CypherParser::RuleOC_RelTypeName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2143);
    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, 234, CypherParser::RuleOC_Expression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2145);
    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, 236, CypherParser::RuleOC_OrExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2147);
    oC_XorExpression();
    setState(2154);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 345, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2148);
        match(CypherParser::SP);
        setState(2149);
        match(CypherParser::OR);
        setState(2150);
        match(CypherParser::SP);
        setState(2151);
        oC_XorExpression(); 
      }
      setState(2156);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 345, _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, 238, CypherParser::RuleOC_XorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2157);
    oC_AndExpression();
    setState(2164);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 346, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2158);
        match(CypherParser::SP);
        setState(2159);
        match(CypherParser::XOR);
        setState(2160);
        match(CypherParser::SP);
        setState(2161);
        oC_AndExpression(); 
      }
      setState(2166);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 346, _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, 240, CypherParser::RuleOC_AndExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2167);
    oC_NotExpression();
    setState(2174);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 347, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2168);
        match(CypherParser::SP);
        setState(2169);
        match(CypherParser::AND);
        setState(2170);
        match(CypherParser::SP);
        setState(2171);
        oC_NotExpression(); 
      }
      setState(2176);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 347, _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, 242, 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(2183);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::NOT) {
      setState(2177);
      match(CypherParser::NOT);
      setState(2179);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2178);
        match(CypherParser::SP);
      }
      setState(2185);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2186);
    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, 244, 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(2236);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 360, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2188);
      kU_BitwiseOrOperatorExpression();
      setState(2198);
      _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2189);
          match(CypherParser::SP);
        }
        setState(2192);
        kU_ComparisonOperator();
        setState(2194);
        _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2200);
      kU_BitwiseOrOperatorExpression();

      setState(2202);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2201);
        match(CypherParser::SP);
      }
      setState(2204);
      antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken = match(CypherParser::INVALID_NOT_EQUAL);
      setState(2206);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2205);
        match(CypherParser::SP);
      }
      setState(2208);
      kU_BitwiseOrOperatorExpression();
       notifyInvalidNotEqualOperator(antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken); 
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2212);
      kU_BitwiseOrOperatorExpression();
      setState(2214);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2213);
        match(CypherParser::SP);
      }
      setState(2216);
      kU_ComparisonOperator();
      setState(2218);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2217);
        match(CypherParser::SP);
      }
      setState(2220);
      kU_BitwiseOrOperatorExpression();
      setState(2230); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2222);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(2221);
                  match(CypherParser::SP);
                }
                setState(2224);
                kU_ComparisonOperator();
                setState(2226);
                _errHandler->sync(this);

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

        default:
          throw NoViableAltException(this);
        }
        setState(2232); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 359, _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, 246, 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(2238);
    _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, 248, 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(2240);
    kU_BitwiseAndOperatorExpression();
    setState(2251);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 363, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2242);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2241);
          match(CypherParser::SP);
        }
        setState(2244);
        match(CypherParser::T__10);
        setState(2246);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2245);
          match(CypherParser::SP);
        }
        setState(2248);
        kU_BitwiseAndOperatorExpression(); 
      }
      setState(2253);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 363, _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, 250, 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(2254);
    kU_BitShiftOperatorExpression();
    setState(2265);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2256);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2255);
          match(CypherParser::SP);
        }
        setState(2258);
        match(CypherParser::T__17);
        setState(2260);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2259);
          match(CypherParser::SP);
        }
        setState(2262);
        kU_BitShiftOperatorExpression(); 
      }
      setState(2267);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _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, 252, 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(2268);
    oC_AddOrSubtractExpression();
    setState(2280);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2270);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2269);
          match(CypherParser::SP);
        }
        setState(2272);
        kU_BitShiftOperator();
        setState(2274);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2273);
          match(CypherParser::SP);
        }
        setState(2276);
        oC_AddOrSubtractExpression(); 
      }
      setState(2282);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _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, 254, 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(2283);
    _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, 256, 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(2285);
    oC_MultiplyDivideModuloExpression();
    setState(2297);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2287);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2286);
          match(CypherParser::SP);
        }
        setState(2289);
        kU_AddOrSubtractOperator();
        setState(2291);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2290);
          match(CypherParser::SP);
        }
        setState(2293);
        oC_MultiplyDivideModuloExpression(); 
      }
      setState(2299);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _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, 258, 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(2300);
    _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, 260, 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(2302);
    oC_PowerOfExpression();
    setState(2314);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2304);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2303);
          match(CypherParser::SP);
        }
        setState(2306);
        kU_MultiplyDivideModuloOperator();
        setState(2308);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2307);
          match(CypherParser::SP);
        }
        setState(2310);
        oC_PowerOfExpression(); 
      }
      setState(2316);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 262, 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(2317);
    _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_StringListNullOperatorExpressionContext *> CypherParser::OC_PowerOfExpressionContext::oC_StringListNullOperatorExpression() {
  return getRuleContexts<CypherParser::OC_StringListNullOperatorExpressionContext>();
}

CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::OC_PowerOfExpressionContext::oC_StringListNullOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::OC_StringListNullOperatorExpressionContext>(i);
}

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

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


size_t CypherParser::OC_PowerOfExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_PowerOfExpression;
}


CypherParser::OC_PowerOfExpressionContext* CypherParser::oC_PowerOfExpression() {
  OC_PowerOfExpressionContext *_localctx = _tracker.createInstance<OC_PowerOfExpressionContext>(_ctx, getState());
  enterRule(_localctx, 264, 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(2319);
    oC_StringListNullOperatorExpression();
    setState(2330);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 378, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2321);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2320);
          match(CypherParser::SP);
        }
        setState(2323);
        match(CypherParser::T__23);
        setState(2325);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2324);
          match(CypherParser::SP);
        }
        setState(2327);
        oC_StringListNullOperatorExpression(); 
      }
      setState(2332);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 378, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OC_StringListNullOperatorExpressionContext ------------------------------------------------------------------

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

CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_UnaryAddSubtractOrFactorialExpression() {
  return getRuleContext<CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext>(0);
}

CypherParser::OC_StringOperatorExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_StringOperatorExpression() {
  return getRuleContext<CypherParser::OC_StringOperatorExpressionContext>(0);
}

CypherParser::OC_NullOperatorExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_NullOperatorExpression() {
  return getRuleContext<CypherParser::OC_NullOperatorExpressionContext>(0);
}

std::vector<CypherParser::OC_ListOperatorExpressionContext *> CypherParser::OC_StringListNullOperatorExpressionContext::oC_ListOperatorExpression() {
  return getRuleContexts<CypherParser::OC_ListOperatorExpressionContext>();
}

CypherParser::OC_ListOperatorExpressionContext* CypherParser::OC_StringListNullOperatorExpressionContext::oC_ListOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::OC_ListOperatorExpressionContext>(i);
}


size_t CypherParser::OC_StringListNullOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_StringListNullOperatorExpression;
}


CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_StringListNullOperatorExpression() {
  OC_StringListNullOperatorExpressionContext *_localctx = _tracker.createInstance<OC_StringListNullOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 266, CypherParser::RuleOC_StringListNullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2333);
    oC_UnaryAddSubtractOrFactorialExpression();
    setState(2341);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 380, _ctx)) {
    case 1: {
      setState(2334);
      oC_StringOperatorExpression();
      break;
    }

    case 2: {
      setState(2336); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2335);
                oC_ListOperatorExpression();
                break;
              }

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

    case 3: {
      setState(2340);
      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, 268, CypherParser::RuleOC_ListOperatorExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2362);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 384, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2343);
      match(CypherParser::SP);
      setState(2344);
      match(CypherParser::IN);
      setState(2346);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2349);
      match(CypherParser::T__6);
      setState(2350);
      oC_Expression();
      setState(2351);
      match(CypherParser::T__7);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2353);
      match(CypherParser::T__6);
      setState(2355);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -4641100153426541948) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & -1144059623222237987) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & 2746208415967579) != 0)) {
        setState(2354);
        oC_Expression();
      }
      setState(2357);
      match(CypherParser::COLON);
      setState(2359);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -4641100153426541948) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & -1144059623222237987) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & 2746208415967579) != 0)) {
        setState(2358);
        oC_Expression();
      }
      setState(2361);
      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, 270, 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(2375);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 385, _ctx)) {
    case 1: {
      setState(2364);
      oC_RegularExpression();
      break;
    }

    case 2: {
      setState(2365);
      match(CypherParser::SP);
      setState(2366);
      match(CypherParser::STARTS);
      setState(2367);
      match(CypherParser::SP);
      setState(2368);
      match(CypherParser::WITH);
      break;
    }

    case 3: {
      setState(2369);
      match(CypherParser::SP);
      setState(2370);
      match(CypherParser::ENDS);
      setState(2371);
      match(CypherParser::SP);
      setState(2372);
      match(CypherParser::WITH);
      break;
    }

    case 4: {
      setState(2373);
      match(CypherParser::SP);
      setState(2374);
      match(CypherParser::CONTAINS);
      break;
    }

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2377);
      match(CypherParser::SP);
    }
    setState(2380);
    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, 272, 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(2383);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2382);
      match(CypherParser::SP);
    }
    setState(2385);
    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, 274, CypherParser::RuleOC_NullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2397);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 388, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2387);
      match(CypherParser::SP);
      setState(2388);
      match(CypherParser::IS);
      setState(2389);
      match(CypherParser::SP);
      setState(2390);
      match(CypherParser::NULL_);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2391);
      match(CypherParser::SP);
      setState(2392);
      match(CypherParser::IS);
      setState(2393);
      match(CypherParser::SP);
      setState(2394);
      match(CypherParser::NOT);
      setState(2395);
      match(CypherParser::SP);
      setState(2396);
      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_UnaryAddSubtractOrFactorialExpressionContext ------------------------------------------------------------------

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

CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::oC_PropertyOrLabelsExpression() {
  return getRuleContext<CypherParser::OC_PropertyOrLabelsExpressionContext>(0);
}

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

tree::TerminalNode* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::MINUS(size_t i) {
  return getToken(CypherParser::MINUS, i);
}

tree::TerminalNode* CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::FACTORIAL() {
  return getToken(CypherParser::FACTORIAL, 0);
}

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

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


size_t CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression;
}


CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::oC_UnaryAddSubtractOrFactorialExpression() {
  OC_UnaryAddSubtractOrFactorialExpressionContext *_localctx = _tracker.createInstance<OC_UnaryAddSubtractOrFactorialExpressionContext>(_ctx, getState());
  enterRule(_localctx, 276, 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(2405);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::MINUS) {
      setState(2399);
      match(CypherParser::MINUS);
      setState(2401);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2400);
        match(CypherParser::SP);
      }
      setState(2407);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2408);
    oC_PropertyOrLabelsExpression();
    setState(2413);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2409);
        match(CypherParser::SP);
      }
      setState(2412);
      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_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, 278, 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(2415);
    oC_Atom();
    setState(2422);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 394, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2417);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2416);
          match(CypherParser::SP);
        }
        setState(2419);
        oC_PropertyLookup(); 
      }
      setState(2424);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 394, _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_ExistCountSubqueryContext* CypherParser::OC_AtomContext::oC_ExistCountSubquery() {
  return getRuleContext<CypherParser::OC_ExistCountSubqueryContext>(0);
}

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

CypherParser::OC_QuantifierContext* CypherParser::OC_AtomContext::oC_Quantifier() {
  return getRuleContext<CypherParser::OC_QuantifierContext>(0);
}


size_t CypherParser::OC_AtomContext::getRuleIndex() const {
  return CypherParser::RuleOC_Atom;
}


CypherParser::OC_AtomContext* CypherParser::oC_Atom() {
  OC_AtomContext *_localctx = _tracker.createInstance<OC_AtomContext>(_ctx, getState());
  enterRule(_localctx, 280, CypherParser::RuleOC_Atom);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2426);
      oC_Parameter();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2427);
      oC_CaseExpression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2428);
      oC_ParenthesizedExpression();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2429);
      oC_FunctionInvocation();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2430);
      oC_PathPatterns();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2431);
      oC_ExistCountSubquery();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2432);
      oC_Variable();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2433);
      oC_Quantifier();
      break;
    }

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

  return _localctx;
}

//----------------- OC_QuantifierContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::OC_QuantifierContext::ALL() {
  return getToken(CypherParser::ALL, 0);
}

CypherParser::OC_FilterExpressionContext* CypherParser::OC_QuantifierContext::oC_FilterExpression() {
  return getRuleContext<CypherParser::OC_FilterExpressionContext>(0);
}

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

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

tree::TerminalNode* CypherParser::OC_QuantifierContext::ANY() {
  return getToken(CypherParser::ANY, 0);
}

tree::TerminalNode* CypherParser::OC_QuantifierContext::NONE() {
  return getToken(CypherParser::NONE, 0);
}

tree::TerminalNode* CypherParser::OC_QuantifierContext::SINGLE() {
  return getToken(CypherParser::SINGLE, 0);
}


size_t CypherParser::OC_QuantifierContext::getRuleIndex() const {
  return CypherParser::RuleOC_Quantifier;
}


CypherParser::OC_QuantifierContext* CypherParser::oC_Quantifier() {
  OC_QuantifierContext *_localctx = _tracker.createInstance<OC_QuantifierContext>(_ctx, getState());
  enterRule(_localctx, 282, CypherParser::RuleOC_Quantifier);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2437);
          match(CypherParser::SP);
        }
        setState(2440);
        match(CypherParser::T__1);
        setState(2442);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2441);
          match(CypherParser::SP);
        }
        setState(2444);
        oC_FilterExpression();
        setState(2446);
        _errHandler->sync(this);

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

      case CypherParser::ANY: {
        enterOuterAlt(_localctx, 2);
        setState(2450);
        match(CypherParser::ANY);
        setState(2452);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2451);
          match(CypherParser::SP);
        }
        setState(2454);
        match(CypherParser::T__1);
        setState(2456);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2455);
          match(CypherParser::SP);
        }
        setState(2458);
        oC_FilterExpression();
        setState(2460);
        _errHandler->sync(this);

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

      case CypherParser::NONE: {
        enterOuterAlt(_localctx, 3);
        setState(2464);
        match(CypherParser::NONE);
        setState(2466);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2465);
          match(CypherParser::SP);
        }
        setState(2468);
        match(CypherParser::T__1);
        setState(2470);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2469);
          match(CypherParser::SP);
        }
        setState(2472);
        oC_FilterExpression();
        setState(2474);
        _errHandler->sync(this);

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

      case CypherParser::SINGLE: {
        enterOuterAlt(_localctx, 4);
        setState(2478);
        match(CypherParser::SINGLE);
        setState(2480);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2479);
          match(CypherParser::SP);
        }
        setState(2482);
        match(CypherParser::T__1);
        setState(2484);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2483);
          match(CypherParser::SP);
        }
        setState(2486);
        oC_FilterExpression();
        setState(2488);
        _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- OC_FilterExpressionContext ------------------------------------------------------------------

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

CypherParser::OC_IdInCollContext* CypherParser::OC_FilterExpressionContext::oC_IdInColl() {
  return getRuleContext<CypherParser::OC_IdInCollContext>(0);
}

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

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


size_t CypherParser::OC_FilterExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_FilterExpression;
}


CypherParser::OC_FilterExpressionContext* CypherParser::oC_FilterExpression() {
  OC_FilterExpressionContext *_localctx = _tracker.createInstance<OC_FilterExpressionContext>(_ctx, getState());
  enterRule(_localctx, 284, CypherParser::RuleOC_FilterExpression);

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

  return _localctx;
}

//----------------- OC_IdInCollContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::OC_IdInCollContext::IN() {
  return getToken(CypherParser::IN, 0);
}

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


size_t CypherParser::OC_IdInCollContext::getRuleIndex() const {
  return CypherParser::RuleOC_IdInColl;
}


CypherParser::OC_IdInCollContext* CypherParser::oC_IdInColl() {
  OC_IdInCollContext *_localctx = _tracker.createInstance<OC_IdInCollContext>(_ctx, getState());
  enterRule(_localctx, 286, CypherParser::RuleOC_IdInColl);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2498);
    oC_Variable();
    setState(2499);
    match(CypherParser::SP);
    setState(2500);
    match(CypherParser::IN);
    setState(2501);
    match(CypherParser::SP);
    setState(2502);
    oC_Expression();
   
  }
  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, 288, CypherParser::RuleOC_Literal);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2510);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::DecimalInteger:
      case CypherParser::ExponentDecimalReal:
      case CypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(2504);
        oC_NumberLiteral();
        break;
      }

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

      case CypherParser::FALSE:
      case CypherParser::TRUE: {
        enterOuterAlt(_localctx, 3);
        setState(2506);
        oC_BooleanLiteral();
        break;
      }

      case CypherParser::NULL_: {
        enterOuterAlt(_localctx, 4);
        setState(2507);
        match(CypherParser::NULL_);
        break;
      }

      case CypherParser::T__6: {
        enterOuterAlt(_localctx, 5);
        setState(2508);
        oC_ListLiteral();
        break;
      }

      case CypherParser::T__8: {
        enterOuterAlt(_localctx, 6);
        setState(2509);
        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, 290, 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(2512);
    _la = _input->LA(1);
    if (!(_la == CypherParser::FALSE

    || _la == CypherParser::TRUE)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 292, 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(2514);
    match(CypherParser::T__6);
    setState(2516);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -4641100153426541948) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1144059623222237987) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2746208415967579) != 0)) {
      setState(2518);
      oC_Expression();
      setState(2520);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2519);
        match(CypherParser::SP);
      }
      setState(2528);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::T__3) {
        setState(2522);
        kU_ListEntry();
        setState(2524);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2523);
          match(CypherParser::SP);
        }
        setState(2530);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(2533);
    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, 294, 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(2535);
    match(CypherParser::T__3);
    setState(2537);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -4641100153426541948) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1144059623222237987) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & 2746208415967579) != 0)) {
      setState(2539);
      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, 296, 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(2542);
    match(CypherParser::T__8);
    setState(2544);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2543);
      match(CypherParser::SP);
    }
    setState(2546);
    kU_StructField();
    setState(2548);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2547);
      match(CypherParser::SP);
    }
    setState(2560);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__3) {
      setState(2550);
      match(CypherParser::T__3);
      setState(2552);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2551);
        match(CypherParser::SP);
      }
      setState(2554);
      kU_StructField();
      setState(2556);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2555);
        match(CypherParser::SP);
      }
      setState(2562);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2563);
    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, 298, 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(2567);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2565);
        oC_SymbolicName();
        break;
      }

      case CypherParser::StringLiteral: {
        setState(2566);
        match(CypherParser::StringLiteral);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2570);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2569);
      match(CypherParser::SP);
    }
    setState(2572);
    match(CypherParser::COLON);
    setState(2574);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2573);
      match(CypherParser::SP);
    }
    setState(2576);
    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, 300, 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(2578);
    match(CypherParser::T__1);
    setState(2580);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2579);
      match(CypherParser::SP);
    }
    setState(2582);
    oC_Expression();
    setState(2584);
    _errHandler->sync(this);

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

tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::CAST() {
  return getToken(CypherParser::CAST, 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);
}

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

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

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

tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::DISTINCT() {
  return getToken(CypherParser::DISTINCT, 0);
}


size_t CypherParser::OC_FunctionInvocationContext::getRuleIndex() const {
  return CypherParser::RuleOC_FunctionInvocation;
}


CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation() {
  OC_FunctionInvocationContext *_localctx = _tracker.createInstance<OC_FunctionInvocationContext>(_ctx, getState());
  enterRule(_localctx, 302, CypherParser::RuleOC_FunctionInvocation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2665);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 446, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2588);
      match(CypherParser::COUNT);
      setState(2590);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2589);
        match(CypherParser::SP);
      }
      setState(2592);
      match(CypherParser::T__1);
      setState(2594);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2593);
        match(CypherParser::SP);
      }
      setState(2596);
      match(CypherParser::STAR);
      setState(2598);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2601);
      match(CypherParser::CAST);
      setState(2603);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2602);
        match(CypherParser::SP);
      }
      setState(2605);
      match(CypherParser::T__1);
      setState(2607);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2606);
        match(CypherParser::SP);
      }
      setState(2609);
      kU_FunctionParameter();
      setState(2611);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2610);
        match(CypherParser::SP);
      }
      setState(2623);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CypherParser::AS: {
          setState(2613);
          match(CypherParser::AS);
          setState(2615);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2614);
            match(CypherParser::SP);
          }
          setState(2617);
          kU_DataType(0);
          break;
        }

        case CypherParser::T__3: {
          setState(2618);
          match(CypherParser::T__3);
          setState(2620);
          _errHandler->sync(this);

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

      default:
        throw NoViableAltException(this);
      }
      setState(2626);
      _errHandler->sync(this);

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

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2630);
      oC_FunctionName();
      setState(2632);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2631);
        match(CypherParser::SP);
      }
      setState(2634);
      match(CypherParser::T__1);
      setState(2636);
      _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::DISTINCT) {
        setState(2638);
        match(CypherParser::DISTINCT);
        setState(2640);
        _errHandler->sync(this);

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

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -4641100153426541948) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & -1144059623222237987) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & 2746208415967579) != 0)) {
        setState(2644);
        kU_FunctionParameter();
        setState(2646);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2645);
          match(CypherParser::SP);
        }
        setState(2658);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__3) {
          setState(2648);
          match(CypherParser::T__3);
          setState(2650);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2649);
            match(CypherParser::SP);
          }
          setState(2652);
          kU_FunctionParameter();
          setState(2654);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2653);
            match(CypherParser::SP);
          }
          setState(2660);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(2663);
      match(CypherParser::T__2);
      break;
    }

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

  return _localctx;
}

//----------------- 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, 304, CypherParser::RuleOC_FunctionName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2667);
    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);
}

CypherParser::KU_LambdaParameterContext* CypherParser::KU_FunctionParameterContext::kU_LambdaParameter() {
  return getRuleContext<CypherParser::KU_LambdaParameterContext>(0);
}


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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 449, _ctx)) {
      case 1: {
        setState(2669);
        oC_SymbolicName();
        setState(2671);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2670);
          match(CypherParser::SP);
        }
        setState(2673);
        match(CypherParser::COLON);
        setState(2674);
        match(CypherParser::T__5);
        setState(2676);
        _errHandler->sync(this);

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

      default:
        break;
      }
      setState(2680);
      oC_Expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2681);
      kU_LambdaParameter();
      break;
    }

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

  return _localctx;
}

//----------------- KU_LambdaParameterContext ------------------------------------------------------------------

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

CypherParser::KU_LambdaVarsContext* CypherParser::KU_LambdaParameterContext::kU_LambdaVars() {
  return getRuleContext<CypherParser::KU_LambdaVarsContext>(0);
}

tree::TerminalNode* CypherParser::KU_LambdaParameterContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}

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

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

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


size_t CypherParser::KU_LambdaParameterContext::getRuleIndex() const {
  return CypherParser::RuleKU_LambdaParameter;
}


CypherParser::KU_LambdaParameterContext* CypherParser::kU_LambdaParameter() {
  KU_LambdaParameterContext *_localctx = _tracker.createInstance<KU_LambdaParameterContext>(_ctx, getState());
  enterRule(_localctx, 308, CypherParser::RuleKU_LambdaParameter);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2685);
      match(CypherParser::SP);
    }
    setState(2688);
    match(CypherParser::MINUS);
    setState(2689);
    match(CypherParser::T__15);
    setState(2691);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2690);
      match(CypherParser::SP);
    }
    setState(2693);
    oC_Expression();
    setState(2695);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- KU_LambdaVarsContext ------------------------------------------------------------------

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

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

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

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

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


size_t CypherParser::KU_LambdaVarsContext::getRuleIndex() const {
  return CypherParser::RuleKU_LambdaVars;
}


CypherParser::KU_LambdaVarsContext* CypherParser::kU_LambdaVars() {
  KU_LambdaVarsContext *_localctx = _tracker.createInstance<KU_LambdaVarsContext>(_ctx, getState());
  enterRule(_localctx, 310, CypherParser::RuleKU_LambdaVars);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2721);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(2697);
        oC_SymbolicName();
        break;
      }

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2699);
          match(CypherParser::SP);
        }
        setState(2702);
        oC_SymbolicName();
        setState(2704);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2703);
          match(CypherParser::SP);
        }
        setState(2716);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__3) {
          setState(2706);
          match(CypherParser::T__3);
          setState(2708);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2707);
            match(CypherParser::SP);
          }
          setState(2710);
          oC_SymbolicName();
          setState(2712);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2711);
            match(CypherParser::SP);
          }
          setState(2718);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2719);
        match(CypherParser::T__2);
        break;
      }

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

  return _localctx;
}

//----------------- 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, 312, 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(2723);
    oC_NodePattern();
    setState(2728); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2725);
              _errHandler->sync(this);

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

      default:
        throw NoViableAltException(this);
      }
      setState(2730); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 461, _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_ExistCountSubqueryContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::MATCH() {
  return getToken(CypherParser::MATCH, 0);
}

CypherParser::OC_PatternContext* CypherParser::OC_ExistCountSubqueryContext::oC_Pattern() {
  return getRuleContext<CypherParser::OC_PatternContext>(0);
}

tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::EXISTS() {
  return getToken(CypherParser::EXISTS, 0);
}

tree::TerminalNode* CypherParser::OC_ExistCountSubqueryContext::COUNT() {
  return getToken(CypherParser::COUNT, 0);
}

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

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

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

CypherParser::KU_HintContext* CypherParser::OC_ExistCountSubqueryContext::kU_Hint() {
  return getRuleContext<CypherParser::KU_HintContext>(0);
}


size_t CypherParser::OC_ExistCountSubqueryContext::getRuleIndex() const {
  return CypherParser::RuleOC_ExistCountSubquery;
}


CypherParser::OC_ExistCountSubqueryContext* CypherParser::oC_ExistCountSubquery() {
  OC_ExistCountSubqueryContext *_localctx = _tracker.createInstance<OC_ExistCountSubqueryContext>(_ctx, getState());
  enterRule(_localctx, 314, CypherParser::RuleOC_ExistCountSubquery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2732);
    _la = _input->LA(1);
    if (!(_la == CypherParser::COUNT

    || _la == CypherParser::EXISTS)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2734);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2733);
      match(CypherParser::SP);
    }
    setState(2736);
    match(CypherParser::T__8);
    setState(2738);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2737);
      match(CypherParser::SP);
    }
    setState(2740);
    match(CypherParser::MATCH);
    setState(2742);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2741);
      match(CypherParser::SP);
    }
    setState(2744);
    oC_Pattern();
    setState(2749);
    _errHandler->sync(this);

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

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

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

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

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

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2757);
      match(CypherParser::SP);
    }
    setState(2760);
    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, 316, 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(2762);
    match(CypherParser::T__4);
    setState(2764);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2763);
      match(CypherParser::SP);
    }
    setState(2768);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2766);
        oC_PropertyKeyName();
        break;
      }

      case CypherParser::STAR: {
        setState(2767);
        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, 318, 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(2792);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 477, _ctx)) {
    case 1: {
      setState(2770);
      match(CypherParser::CASE);
      setState(2775); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2772);
                _errHandler->sync(this);

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

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

    case 2: {
      setState(2779);
      match(CypherParser::CASE);
      setState(2781);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2780);
        match(CypherParser::SP);
      }
      setState(2783);
      oC_Expression();
      setState(2788); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2785);
                _errHandler->sync(this);

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

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2794);
        match(CypherParser::SP);
      }
      setState(2797);
      match(CypherParser::ELSE);
      setState(2799);
      _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2804);
      match(CypherParser::SP);
    }
    setState(2807);
    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, 320, 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(2809);
    match(CypherParser::WHEN);
    setState(2811);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2810);
      match(CypherParser::SP);
    }
    setState(2813);
    oC_Expression();
    setState(2815);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2814);
      match(CypherParser::SP);
    }
    setState(2817);
    match(CypherParser::THEN);
    setState(2819);
    _errHandler->sync(this);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2823);
    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, 324, CypherParser::RuleOC_NumberLiteral);

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

      case CypherParser::DecimalInteger: {
        enterOuterAlt(_localctx, 2);
        setState(2826);
        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, 326, CypherParser::RuleOC_Parameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2829);
    match(CypherParser::T__25);
    setState(2832);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2830);
        oC_SymbolicName();
        break;
      }

      case CypherParser::DecimalInteger: {
        setState(2831);
        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, 328, 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(2834);
    oC_Atom();
    setState(2836);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2835);
      match(CypherParser::SP);
    }
    setState(2838);
    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, 330, CypherParser::RuleOC_PropertyKeyName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2840);
    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, 332, CypherParser::RuleOC_IntegerLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2842);
    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::ExponentDecimalReal() {
  return getToken(CypherParser::ExponentDecimalReal, 0);
}

tree::TerminalNode* CypherParser::OC_DoubleLiteralContext::RegularDecimalReal() {
  return getToken(CypherParser::RegularDecimalReal, 0);
}


size_t CypherParser::OC_DoubleLiteralContext::getRuleIndex() const {
  return CypherParser::RuleOC_DoubleLiteral;
}


CypherParser::OC_DoubleLiteralContext* CypherParser::oC_DoubleLiteral() {
  OC_DoubleLiteralContext *_localctx = _tracker.createInstance<OC_DoubleLiteralContext>(_ctx, getState());
  enterRule(_localctx, 334, CypherParser::RuleOC_DoubleLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2844);
    _la = _input->LA(1);
    if (!(_la == CypherParser::ExponentDecimalReal

    || _la == CypherParser::RegularDecimalReal)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 336, CypherParser::RuleOC_SchemaName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2846);
    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, 338, CypherParser::RuleOC_SymbolicName);

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

      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 2);
        setState(2849);
        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(2851);
        match(CypherParser::HexLetter);
        break;
      }

      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP: {
        enterOuterAlt(_localctx, 4);
        setState(2852);
        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::ADD() {
  return getToken(CypherParser::ADD, 0);
}

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

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

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

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

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::CHECKPOINT() {
  return getToken(CypherParser::CHECKPOINT, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::CONTAINS() {
  return getToken(CypherParser::CONTAINS, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::COUNT() {
  return getToken(CypherParser::COUNT, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::CYCLE() {
  return getToken(CypherParser::CYCLE, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::DECIMAL() {
  return getToken(CypherParser::DECIMAL, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::DELETE() {
  return getToken(CypherParser::DELETE, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::EXPLAIN() {
  return getToken(CypherParser::EXPLAIN, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::FORCE() {
  return getToken(CypherParser::FORCE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::GRAPH() {
  return getToken(CypherParser::GRAPH, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::IF() {
  return getToken(CypherParser::IF, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::INCREMENT() {
  return getToken(CypherParser::INCREMENT, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::LOGICAL() {
  return getToken(CypherParser::LOGICAL, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::MATCH() {
  return getToken(CypherParser::MATCH, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::MAXVALUE() {
  return getToken(CypherParser::MAXVALUE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::MERGE() {
  return getToken(CypherParser::MERGE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::MINVALUE() {
  return getToken(CypherParser::MINVALUE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::NO() {
  return getToken(CypherParser::NO, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::PROJECT() {
  return getToken(CypherParser::PROJECT, 0);
}

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

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::RETURN() {
  return getToken(CypherParser::RETURN, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::SEQUENCE() {
  return getToken(CypherParser::SEQUENCE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::SET() {
  return getToken(CypherParser::SET, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::START() {
  return getToken(CypherParser::START, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::STRUCT() {
  return getToken(CypherParser::STRUCT, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::L_SKIP() {
  return getToken(CypherParser::L_SKIP, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::LIMIT() {
  return getToken(CypherParser::LIMIT, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::TYPE() {
  return getToken(CypherParser::TYPE, 0);
}

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::UNINSTALL() {
  return getToken(CypherParser::UNINSTALL, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::UPDATE() {
  return getToken(CypherParser::UPDATE, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::WRITE() {
  return getToken(CypherParser::WRITE, 0);
}

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

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

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::YIELD() {
  return getToken(CypherParser::YIELD, 0);
}

tree::TerminalNode* CypherParser::KU_NonReservedKeywordsContext::USER() {
  return getToken(CypherParser::USER, 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, 340, 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(2855);
    _la = _input->LA(1);
    if (!(((((_la - 48) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 48)) & 8923191552623093653) != 0) || ((((_la - 112) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 112)) & 405842891108355) != 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, 342, 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(2857);
    _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, 344, 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(2859);
    _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, 346, 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(2861);
    _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 51: return kU_DataTypeSempred(antlrcpp::downCast<KU_DataTypeContext *>(context), predicateIndex);
    case 78: return kU_JoinNodeSempred(antlrcpp::downCast<KU_JoinNodeContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool CypherParser::kU_DataTypeSempred(KU_DataTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 6);

  default:
    break;
  }
  return true;
}

bool CypherParser::kU_JoinNodeSempred(KU_JoinNodeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 1: return precpred(_ctx, 4);
    case 2: return precpred(_ctx, 3);

  default:
    break;
  }
  return true;
}

void CypherParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  cypherParserInitialize();
#else
  ::antlr4::internal::call_once(cypherParserOnceFlag, cypherParserInitialize);
#endif
}
