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


//----------------- IC_StatementsContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_StatementsContext::getRuleIndex() const {
  return CypherParser::RuleIC_Statements;
}


CypherParser::IC_StatementsContext* CypherParser::iC_Statements() {
  IC_StatementsContext *_localctx = _tracker.createInstance<IC_StatementsContext>(_ctx, getState());
  enterRule(_localctx, 0, CypherParser::RuleIC_Statements);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(373);
          match(CypherParser::SP);
        }
        setState(376);
        match(CypherParser::T__0);
        setState(378);
        _errHandler->sync(this);

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

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

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

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

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

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

    setState(397);
    oC_Statement();
    setState(402);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(398);
        match(CypherParser::SP);
      }
      setState(401);
      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::IC_CreateUserContext* CypherParser::OC_StatementContext::iC_CreateUser() {
  return getRuleContext<CypherParser::IC_CreateUserContext>(0);
}

CypherParser::IC_CreateRoleContext* CypherParser::OC_StatementContext::iC_CreateRole() {
  return getRuleContext<CypherParser::IC_CreateRoleContext>(0);
}

CypherParser::IC_CreateNodeTableContext* CypherParser::OC_StatementContext::iC_CreateNodeTable() {
  return getRuleContext<CypherParser::IC_CreateNodeTableContext>(0);
}

CypherParser::IC_CreateRelTableContext* CypherParser::OC_StatementContext::iC_CreateRelTable() {
  return getRuleContext<CypherParser::IC_CreateRelTableContext>(0);
}

CypherParser::IC_CreateIndexContext* CypherParser::OC_StatementContext::iC_CreateIndex() {
  return getRuleContext<CypherParser::IC_CreateIndexContext>(0);
}

CypherParser::IC_CreateSequenceContext* CypherParser::OC_StatementContext::iC_CreateSequence() {
  return getRuleContext<CypherParser::IC_CreateSequenceContext>(0);
}

CypherParser::IC_CreateTypeContext* CypherParser::OC_StatementContext::iC_CreateType() {
  return getRuleContext<CypherParser::IC_CreateTypeContext>(0);
}

CypherParser::IC_DropContext* CypherParser::OC_StatementContext::iC_Drop() {
  return getRuleContext<CypherParser::IC_DropContext>(0);
}

CypherParser::IC_AlterTableContext* CypherParser::OC_StatementContext::iC_AlterTable() {
  return getRuleContext<CypherParser::IC_AlterTableContext>(0);
}

CypherParser::IC_CopyFromContext* CypherParser::OC_StatementContext::iC_CopyFrom() {
  return getRuleContext<CypherParser::IC_CopyFromContext>(0);
}

CypherParser::IC_CopyFromByColumnContext* CypherParser::OC_StatementContext::iC_CopyFromByColumn() {
  return getRuleContext<CypherParser::IC_CopyFromByColumnContext>(0);
}

CypherParser::IC_CopyTOContext* CypherParser::OC_StatementContext::iC_CopyTO() {
  return getRuleContext<CypherParser::IC_CopyTOContext>(0);
}

CypherParser::IC_StandaloneCallContext* CypherParser::OC_StatementContext::iC_StandaloneCall() {
  return getRuleContext<CypherParser::IC_StandaloneCallContext>(0);
}

CypherParser::IC_CreateMacroContext* CypherParser::OC_StatementContext::iC_CreateMacro() {
  return getRuleContext<CypherParser::IC_CreateMacroContext>(0);
}

CypherParser::IC_CommentOnContext* CypherParser::OC_StatementContext::iC_CommentOn() {
  return getRuleContext<CypherParser::IC_CommentOnContext>(0);
}

CypherParser::IC_TransactionContext* CypherParser::OC_StatementContext::iC_Transaction() {
  return getRuleContext<CypherParser::IC_TransactionContext>(0);
}

CypherParser::IC_ExtensionContext* CypherParser::OC_StatementContext::iC_Extension() {
  return getRuleContext<CypherParser::IC_ExtensionContext>(0);
}

CypherParser::IC_ExportDatabaseContext* CypherParser::OC_StatementContext::iC_ExportDatabase() {
  return getRuleContext<CypherParser::IC_ExportDatabaseContext>(0);
}

CypherParser::IC_ImportDatabaseContext* CypherParser::OC_StatementContext::iC_ImportDatabase() {
  return getRuleContext<CypherParser::IC_ImportDatabaseContext>(0);
}

CypherParser::IC_AttachDatabaseContext* CypherParser::OC_StatementContext::iC_AttachDatabase() {
  return getRuleContext<CypherParser::IC_AttachDatabaseContext>(0);
}

CypherParser::IC_DetachDatabaseContext* CypherParser::OC_StatementContext::iC_DetachDatabase() {
  return getRuleContext<CypherParser::IC_DetachDatabaseContext>(0);
}

CypherParser::IC_UseDatabaseContext* CypherParser::OC_StatementContext::iC_UseDatabase() {
  return getRuleContext<CypherParser::IC_UseDatabaseContext>(0);
}

CypherParser::IC_CreateGraphContext* CypherParser::OC_StatementContext::iC_CreateGraph() {
  return getRuleContext<CypherParser::IC_CreateGraphContext>(0);
}

CypherParser::IC_UseGraphContext* CypherParser::OC_StatementContext::iC_UseGraph() {
  return getRuleContext<CypherParser::IC_UseGraphContext>(0);
}


size_t CypherParser::OC_StatementContext::getRuleIndex() const {
  return CypherParser::RuleOC_Statement;
}


CypherParser::OC_StatementContext* CypherParser::oC_Statement() {
  OC_StatementContext *_localctx = _tracker.createInstance<OC_StatementContext>(_ctx, getState());
  enterRule(_localctx, 4, CypherParser::RuleOC_Statement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(405);
      iC_CreateUser();
      break;
    }

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

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(407);
      iC_CreateNodeTable();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(408);
      iC_CreateRelTable();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(409);
      iC_CreateIndex();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(410);
      iC_CreateSequence();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(411);
      iC_CreateType();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(412);
      iC_Drop();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(413);
      iC_AlterTable();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(414);
      iC_CopyFrom();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(415);
      iC_CopyFromByColumn();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(416);
      iC_CopyTO();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(417);
      iC_StandaloneCall();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(418);
      iC_CreateMacro();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(419);
      iC_CommentOn();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(420);
      iC_Transaction();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(421);
      iC_Extension();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(422);
      iC_ExportDatabase();
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(423);
      iC_ImportDatabase();
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(424);
      iC_AttachDatabase();
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(425);
      iC_DetachDatabase();
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(426);
      iC_UseDatabase();
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(427);
      iC_CreateGraph();
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(428);
      iC_UseGraph();
      break;
    }

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

  return _localctx;
}

//----------------- IC_CopyFromContext ------------------------------------------------------------------

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

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

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

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

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

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

CypherParser::IC_ScanSourceContext* CypherParser::IC_CopyFromContext::iC_ScanSource() {
  return getRuleContext<CypherParser::IC_ScanSourceContext>(0);
}

CypherParser::IC_ColumnNamesContext* CypherParser::IC_CopyFromContext::iC_ColumnNames() {
  return getRuleContext<CypherParser::IC_ColumnNamesContext>(0);
}

CypherParser::IC_OptionsContext* CypherParser::IC_CopyFromContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}


size_t CypherParser::IC_CopyFromContext::getRuleIndex() const {
  return CypherParser::RuleIC_CopyFrom;
}


CypherParser::IC_CopyFromContext* CypherParser::iC_CopyFrom() {
  IC_CopyFromContext *_localctx = _tracker.createInstance<IC_CopyFromContext>(_ctx, getState());
  enterRule(_localctx, 6, CypherParser::RuleIC_CopyFrom);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(431);
    match(CypherParser::COPY);
    setState(432);
    match(CypherParser::SP);
    setState(433);
    oC_SchemaName();
    setState(435);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(437);
    match(CypherParser::SP);
    setState(438);
    match(CypherParser::FROM);
    setState(439);
    match(CypherParser::SP);
    setState(440);
    iC_ScanSource();
    setState(454);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(441);
        match(CypherParser::SP);
      }
      setState(444);
      match(CypherParser::T__1);
      setState(446);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(445);
        match(CypherParser::SP);
      }
      setState(448);
      iC_Options();
      setState(450);
      _errHandler->sync(this);

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

//----------------- IC_ColumnNamesContext ------------------------------------------------------------------

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

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

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

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

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


size_t CypherParser::IC_ColumnNamesContext::getRuleIndex() const {
  return CypherParser::RuleIC_ColumnNames;
}


CypherParser::IC_ColumnNamesContext* CypherParser::iC_ColumnNames() {
  IC_ColumnNamesContext *_localctx = _tracker.createInstance<IC_ColumnNamesContext>(_ctx, getState());
  enterRule(_localctx, 8, CypherParser::RuleIC_ColumnNames);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(456);
      match(CypherParser::SP);
    }
    setState(459);
    match(CypherParser::T__1);
    setState(461);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
      setState(463);
      oC_SchemaName();
      setState(474);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(465);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(464);
            match(CypherParser::SP);
          }
          setState(467);
          match(CypherParser::T__3);
          setState(469);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(468);
            match(CypherParser::SP);
          }
          setState(471);
          oC_SchemaName(); 
        }
        setState(476);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx);
      }
      setState(478);
      _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_ScanSourceContext ------------------------------------------------------------------

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

CypherParser::IC_FilePathsContext* CypherParser::IC_ScanSourceContext::iC_FilePaths() {
  return getRuleContext<CypherParser::IC_FilePathsContext>(0);
}

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

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

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

CypherParser::OC_ParameterContext* CypherParser::IC_ScanSourceContext::oC_Parameter() {
  return getRuleContext<CypherParser::OC_ParameterContext>(0);
}

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

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

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


size_t CypherParser::IC_ScanSourceContext::getRuleIndex() const {
  return CypherParser::RuleIC_ScanSource;
}


CypherParser::IC_ScanSourceContext* CypherParser::iC_ScanSource() {
  IC_ScanSourceContext *_localctx = _tracker.createInstance<IC_ScanSourceContext>(_ctx, getState());
  enterRule(_localctx, 10, CypherParser::RuleIC_ScanSource);
  size_t _la = 0;

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      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);
      oC_Query();
      setState(491);
      _errHandler->sync(this);

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

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

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

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(497);
      oC_Variable();
      setState(498);
      match(CypherParser::T__4);
      setState(500);
      _errHandler->sync(this);

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

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(504);
      oC_FunctionInvocation();
      break;
    }

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

  return _localctx;
}

//----------------- IC_CopyFromByColumnContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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


size_t CypherParser::IC_CopyFromByColumnContext::getRuleIndex() const {
  return CypherParser::RuleIC_CopyFromByColumn;
}


CypherParser::IC_CopyFromByColumnContext* CypherParser::iC_CopyFromByColumn() {
  IC_CopyFromByColumnContext *_localctx = _tracker.createInstance<IC_CopyFromByColumnContext>(_ctx, getState());
  enterRule(_localctx, 12, CypherParser::RuleIC_CopyFromByColumn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(507);
    match(CypherParser::COPY);
    setState(508);
    match(CypherParser::SP);
    setState(509);
    oC_SchemaName();
    setState(510);
    match(CypherParser::SP);
    setState(511);
    match(CypherParser::FROM);
    setState(512);
    match(CypherParser::SP);
    setState(513);
    match(CypherParser::T__1);
    setState(515);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(514);
      match(CypherParser::SP);
    }
    setState(517);
    match(CypherParser::StringLiteral);
    setState(528);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__3 || _la == CypherParser::SP) {
      setState(519);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(518);
        match(CypherParser::SP);
      }
      setState(521);
      match(CypherParser::T__3);
      setState(523);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(522);
        match(CypherParser::SP);
      }
      setState(525);
      match(CypherParser::StringLiteral);
      setState(530);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(531);
    match(CypherParser::T__2);
    setState(532);
    match(CypherParser::SP);
    setState(533);
    match(CypherParser::BY);
    setState(534);
    match(CypherParser::SP);
    setState(535);
    match(CypherParser::COLUMN);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_CopyTOContext ------------------------------------------------------------------

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

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

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

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

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

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

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

CypherParser::IC_OptionsContext* CypherParser::IC_CopyTOContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}


size_t CypherParser::IC_CopyTOContext::getRuleIndex() const {
  return CypherParser::RuleIC_CopyTO;
}


CypherParser::IC_CopyTOContext* CypherParser::iC_CopyTO() {
  IC_CopyTOContext *_localctx = _tracker.createInstance<IC_CopyTOContext>(_ctx, getState());
  enterRule(_localctx, 14, CypherParser::RuleIC_CopyTO);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(537);
    match(CypherParser::COPY);
    setState(538);
    match(CypherParser::SP);
    setState(539);
    match(CypherParser::T__1);
    setState(541);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(540);
      match(CypherParser::SP);
    }
    setState(543);
    oC_Query();
    setState(545);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(544);
      match(CypherParser::SP);
    }
    setState(547);
    match(CypherParser::T__2);
    setState(548);
    match(CypherParser::SP);
    setState(549);
    match(CypherParser::TO);
    setState(550);
    match(CypherParser::SP);
    setState(551);
    match(CypherParser::StringLiteral);
    setState(565);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(552);
        match(CypherParser::SP);
      }
      setState(555);
      match(CypherParser::T__1);
      setState(557);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(556);
        match(CypherParser::SP);
      }
      setState(559);
      iC_Options();
      setState(561);
      _errHandler->sync(this);

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

//----------------- IC_ExportDatabaseContext ------------------------------------------------------------------

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

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

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

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

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

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

CypherParser::IC_OptionsContext* CypherParser::IC_ExportDatabaseContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}


size_t CypherParser::IC_ExportDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleIC_ExportDatabase;
}


CypherParser::IC_ExportDatabaseContext* CypherParser::iC_ExportDatabase() {
  IC_ExportDatabaseContext *_localctx = _tracker.createInstance<IC_ExportDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 16, CypherParser::RuleIC_ExportDatabase);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(567);
    match(CypherParser::EXPORT);
    setState(568);
    match(CypherParser::SP);
    setState(569);
    match(CypherParser::DATABASE);
    setState(570);
    match(CypherParser::SP);
    setState(571);
    match(CypherParser::StringLiteral);
    setState(585);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(572);
        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);
      iC_Options();
      setState(581);
      _errHandler->sync(this);

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

//----------------- IC_ImportDatabaseContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_ImportDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleIC_ImportDatabase;
}


CypherParser::IC_ImportDatabaseContext* CypherParser::iC_ImportDatabase() {
  IC_ImportDatabaseContext *_localctx = _tracker.createInstance<IC_ImportDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 18, CypherParser::RuleIC_ImportDatabase);

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

  return _localctx;
}

//----------------- IC_AttachDatabaseContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

CypherParser::IC_OptionsContext* CypherParser::IC_AttachDatabaseContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}


size_t CypherParser::IC_AttachDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleIC_AttachDatabase;
}


CypherParser::IC_AttachDatabaseContext* CypherParser::iC_AttachDatabase() {
  IC_AttachDatabaseContext *_localctx = _tracker.createInstance<IC_AttachDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 20, CypherParser::RuleIC_AttachDatabase);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
    case 1: {
      setState(596);
      match(CypherParser::SP);
      setState(597);
      match(CypherParser::AS);
      setState(598);
      match(CypherParser::SP);
      setState(599);
      oC_SchemaName();
      break;
    }

    default:
      break;
    }
    setState(602);
    match(CypherParser::SP);
    setState(603);
    match(CypherParser::T__1);
    setState(605);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(604);
      match(CypherParser::SP);
    }
    setState(607);
    match(CypherParser::DBTYPE);
    setState(608);
    match(CypherParser::SP);
    setState(609);
    oC_SymbolicName();
    setState(618);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(610);
        match(CypherParser::SP);
      }
      setState(613);
      match(CypherParser::T__3);
      setState(615);
      _errHandler->sync(this);

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

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

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

  return _localctx;
}

//----------------- IC_OptionContext ------------------------------------------------------------------

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

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

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

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

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


size_t CypherParser::IC_OptionContext::getRuleIndex() const {
  return CypherParser::RuleIC_Option;
}


CypherParser::IC_OptionContext* CypherParser::iC_Option() {
  IC_OptionContext *_localctx = _tracker.createInstance<IC_OptionContext>(_ctx, getState());
  enterRule(_localctx, 22, CypherParser::RuleIC_Option);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(626);
          match(CypherParser::SP);
        }
        setState(629);
        match(CypherParser::T__5);
        setState(631);
        _errHandler->sync(this);

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

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

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

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

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

  return _localctx;
}

//----------------- IC_OptionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_OptionContext *> CypherParser::IC_OptionsContext::iC_Option() {
  return getRuleContexts<CypherParser::IC_OptionContext>();
}

CypherParser::IC_OptionContext* CypherParser::IC_OptionsContext::iC_Option(size_t i) {
  return getRuleContext<CypherParser::IC_OptionContext>(i);
}

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

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


size_t CypherParser::IC_OptionsContext::getRuleIndex() const {
  return CypherParser::RuleIC_Options;
}


CypherParser::IC_OptionsContext* CypherParser::iC_Options() {
  IC_OptionsContext *_localctx = _tracker.createInstance<IC_OptionsContext>(_ctx, getState());
  enterRule(_localctx, 24, CypherParser::RuleIC_Options);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(647);
          match(CypherParser::SP);
        }
        setState(650);
        match(CypherParser::T__3);
        setState(652);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(651);
          match(CypherParser::SP);
        }
        setState(654);
        iC_Option(); 
      }
      setState(659);
      _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;
}

//----------------- IC_DetachDatabaseContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_DetachDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleIC_DetachDatabase;
}


CypherParser::IC_DetachDatabaseContext* CypherParser::iC_DetachDatabase() {
  IC_DetachDatabaseContext *_localctx = _tracker.createInstance<IC_DetachDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 26, CypherParser::RuleIC_DetachDatabase);

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

  return _localctx;
}

//----------------- IC_UseDatabaseContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_UseDatabaseContext::getRuleIndex() const {
  return CypherParser::RuleIC_UseDatabase;
}


CypherParser::IC_UseDatabaseContext* CypherParser::iC_UseDatabase() {
  IC_UseDatabaseContext *_localctx = _tracker.createInstance<IC_UseDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 28, CypherParser::RuleIC_UseDatabase);

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

  return _localctx;
}

//----------------- IC_CreateGraphContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::IC_CreateGraphContext::GRAPH() {
  return getToken(CypherParser::GRAPH, 0);
}

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

tree::TerminalNode* CypherParser::IC_CreateGraphContext::ANY() {
  return getToken(CypherParser::ANY, 0);
}


size_t CypherParser::IC_CreateGraphContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateGraph;
}


CypherParser::IC_CreateGraphContext* CypherParser::iC_CreateGraph() {
  IC_CreateGraphContext *_localctx = _tracker.createInstance<IC_CreateGraphContext>(_ctx, getState());
  enterRule(_localctx, 30, CypherParser::RuleIC_CreateGraph);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(668);
    match(CypherParser::CREATE);
    setState(669);
    match(CypherParser::SP);
    setState(670);
    match(CypherParser::GRAPH);
    setState(671);
    match(CypherParser::SP);
    setState(672);
    oC_SchemaName();
    setState(675);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- IC_UseGraphContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::IC_UseGraphContext::GRAPH() {
  return getToken(CypherParser::GRAPH, 0);
}

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


size_t CypherParser::IC_UseGraphContext::getRuleIndex() const {
  return CypherParser::RuleIC_UseGraph;
}


CypherParser::IC_UseGraphContext* CypherParser::iC_UseGraph() {
  IC_UseGraphContext *_localctx = _tracker.createInstance<IC_UseGraphContext>(_ctx, getState());
  enterRule(_localctx, 32, CypherParser::RuleIC_UseGraph);

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

  return _localctx;
}

//----------------- IC_StandaloneCallContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::IC_StandaloneCallContext::getRuleIndex() const {
  return CypherParser::RuleIC_StandaloneCall;
}


CypherParser::IC_StandaloneCallContext* CypherParser::iC_StandaloneCall() {
  IC_StandaloneCallContext *_localctx = _tracker.createInstance<IC_StandaloneCallContext>(_ctx, getState());
  enterRule(_localctx, 34, CypherParser::RuleIC_StandaloneCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(698);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(683);
      match(CypherParser::CALL);
      setState(684);
      match(CypherParser::SP);
      setState(685);
      oC_SymbolicName();
      setState(687);
      _errHandler->sync(this);

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

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(695);
      match(CypherParser::CALL);
      setState(696);
      match(CypherParser::SP);
      setState(697);
      oC_FunctionInvocation();
      break;
    }

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

  return _localctx;
}

//----------------- IC_CommentOnContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::IC_CommentOnContext::COMMENT() {
  return getToken(CypherParser::COMMENT, 0);
}

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

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

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

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

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

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

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


size_t CypherParser::IC_CommentOnContext::getRuleIndex() const {
  return CypherParser::RuleIC_CommentOn;
}


CypherParser::IC_CommentOnContext* CypherParser::iC_CommentOn() {
  IC_CommentOnContext *_localctx = _tracker.createInstance<IC_CommentOnContext>(_ctx, getState());
  enterRule(_localctx, 36, CypherParser::RuleIC_CommentOn);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(700);
    match(CypherParser::COMMENT);
    setState(701);
    match(CypherParser::SP);
    setState(702);
    match(CypherParser::ON);
    setState(703);
    match(CypherParser::SP);
    setState(704);
    match(CypherParser::TABLE);
    setState(705);
    match(CypherParser::SP);
    setState(706);
    oC_SchemaName();
    setState(707);
    match(CypherParser::SP);
    setState(708);
    match(CypherParser::IS);
    setState(709);
    match(CypherParser::SP);
    setState(710);
    match(CypherParser::StringLiteral);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_CreateMacroContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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

CypherParser::IC_PositionalArgsContext* CypherParser::IC_CreateMacroContext::iC_PositionalArgs() {
  return getRuleContext<CypherParser::IC_PositionalArgsContext>(0);
}

std::vector<CypherParser::IC_DefaultArgContext *> CypherParser::IC_CreateMacroContext::iC_DefaultArg() {
  return getRuleContexts<CypherParser::IC_DefaultArgContext>();
}

CypherParser::IC_DefaultArgContext* CypherParser::IC_CreateMacroContext::iC_DefaultArg(size_t i) {
  return getRuleContext<CypherParser::IC_DefaultArgContext>(i);
}


size_t CypherParser::IC_CreateMacroContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateMacro;
}


CypherParser::IC_CreateMacroContext* CypherParser::iC_CreateMacro() {
  IC_CreateMacroContext *_localctx = _tracker.createInstance<IC_CreateMacroContext>(_ctx, getState());
  enterRule(_localctx, 38, CypherParser::RuleIC_CreateMacro);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(712);
    match(CypherParser::CREATE);
    setState(713);
    match(CypherParser::SP);
    setState(714);
    match(CypherParser::MACRO);
    setState(715);
    match(CypherParser::SP);
    setState(716);
    oC_FunctionName();
    setState(718);
    _errHandler->sync(this);

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx)) {
    case 1: {
      setState(724);
      iC_PositionalArgs();
      break;
    }

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

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
      setState(730);
      iC_DefaultArg();
    }
    setState(743);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(734);
        _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(737);
          match(CypherParser::SP);
        }
        setState(740);
        iC_DefaultArg(); 
      }
      setState(745);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx);
    }
    setState(747);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(746);
      match(CypherParser::SP);
    }
    setState(749);
    match(CypherParser::T__2);
    setState(750);
    match(CypherParser::SP);
    setState(751);
    match(CypherParser::AS);
    setState(752);
    match(CypherParser::SP);
    setState(753);
    oC_Expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_PositionalArgsContext ------------------------------------------------------------------

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

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

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

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

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


size_t CypherParser::IC_PositionalArgsContext::getRuleIndex() const {
  return CypherParser::RuleIC_PositionalArgs;
}


CypherParser::IC_PositionalArgsContext* CypherParser::iC_PositionalArgs() {
  IC_PositionalArgsContext *_localctx = _tracker.createInstance<IC_PositionalArgsContext>(_ctx, getState());
  enterRule(_localctx, 40, CypherParser::RuleIC_PositionalArgs);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(756);
          match(CypherParser::SP);
        }
        setState(759);
        match(CypherParser::T__3);
        setState(761);
        _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_DefaultArgContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_DefaultArgContext::getRuleIndex() const {
  return CypherParser::RuleIC_DefaultArg;
}


CypherParser::IC_DefaultArgContext* CypherParser::iC_DefaultArg() {
  IC_DefaultArgContext *_localctx = _tracker.createInstance<IC_DefaultArgContext>(_ctx, getState());
  enterRule(_localctx, 42, CypherParser::RuleIC_DefaultArg);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(770);
      match(CypherParser::SP);
    }
    setState(773);
    match(CypherParser::COLON);
    setState(774);
    match(CypherParser::T__5);
    setState(776);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_FilePathsContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_FilePathsContext::getRuleIndex() const {
  return CypherParser::RuleIC_FilePaths;
}


CypherParser::IC_FilePathsContext* CypherParser::iC_FilePaths() {
  IC_FilePathsContext *_localctx = _tracker.createInstance<IC_FilePathsContext>(_ctx, getState());
  enterRule(_localctx, 44, CypherParser::RuleIC_FilePaths);
  size_t _la = 0;

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

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

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

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(789);
            match(CypherParser::SP);
          }
          setState(792);
          match(CypherParser::StringLiteral);
          setState(797);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(798);
        match(CypherParser::T__7);
        break;
      }

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

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(801);
          match(CypherParser::SP);
        }
        setState(804);
        match(CypherParser::T__1);
        setState(806);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(805);
          match(CypherParser::SP);
        }
        setState(808);
        match(CypherParser::StringLiteral);
        setState(810);
        _errHandler->sync(this);

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

//----------------- IC_IfNotExistsContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_IfNotExistsContext::getRuleIndex() const {
  return CypherParser::RuleIC_IfNotExists;
}


CypherParser::IC_IfNotExistsContext* CypherParser::iC_IfNotExists() {
  IC_IfNotExistsContext *_localctx = _tracker.createInstance<IC_IfNotExistsContext>(_ctx, getState());
  enterRule(_localctx, 46, CypherParser::RuleIC_IfNotExists);

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

  return _localctx;
}

//----------------- IC_CreateNodeTableContext ------------------------------------------------------------------

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

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

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

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

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

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

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

CypherParser::IC_PropertyDefinitionsContext* CypherParser::IC_CreateNodeTableContext::iC_PropertyDefinitions() {
  return getRuleContext<CypherParser::IC_PropertyDefinitionsContext>(0);
}

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

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

CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateNodeTableContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}

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

CypherParser::IC_OptionsContext* CypherParser::IC_CreateNodeTableContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}

CypherParser::IC_CreateNodeConstraintContext* CypherParser::IC_CreateNodeTableContext::iC_CreateNodeConstraint() {
  return getRuleContext<CypherParser::IC_CreateNodeConstraintContext>(0);
}


size_t CypherParser::IC_CreateNodeTableContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateNodeTable;
}


CypherParser::IC_CreateNodeTableContext* CypherParser::iC_CreateNodeTable() {
  IC_CreateNodeTableContext *_localctx = _tracker.createInstance<IC_CreateNodeTableContext>(_ctx, getState());
  enterRule(_localctx, 48, CypherParser::RuleIC_CreateNodeTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(821);
    match(CypherParser::CREATE);
    setState(822);
    match(CypherParser::SP);
    setState(823);
    match(CypherParser::NODE);
    setState(824);
    match(CypherParser::SP);
    setState(825);
    match(CypherParser::TABLE);
    setState(826);
    match(CypherParser::SP);
    setState(830);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(832);
    oC_SchemaName();
    setState(860);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
    case 1: {
      setState(834);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(833);
        match(CypherParser::SP);
      }
      setState(836);
      match(CypherParser::T__1);
      setState(838);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(837);
        match(CypherParser::SP);
      }
      setState(840);
      iC_PropertyDefinitions();
      setState(842);
      _errHandler->sync(this);

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

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

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(845);
          match(CypherParser::SP);
        }
        setState(848);
        iC_CreateNodeConstraint();
      }
      setState(852);
      _errHandler->sync(this);

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

    case 2: {
      setState(856);
      match(CypherParser::SP);
      setState(857);
      match(CypherParser::AS);
      setState(858);
      match(CypherParser::SP);
      setState(859);
      oC_Query();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
    case 1: {
      setState(862);
      match(CypherParser::SP);
      setState(863);
      match(CypherParser::WITH);
      setState(865);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(864);
        match(CypherParser::SP);
      }
      setState(867);
      match(CypherParser::T__1);
      setState(869);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(868);
        match(CypherParser::SP);
      }
      setState(871);
      iC_Options();
      setState(873);
      _errHandler->sync(this);

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

//----------------- IC_CreateRelTableContext ------------------------------------------------------------------

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

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

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

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

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

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

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

CypherParser::IC_FromToConnectionsContext* CypherParser::IC_CreateRelTableContext::iC_FromToConnections() {
  return getRuleContext<CypherParser::IC_FromToConnectionsContext>(0);
}

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

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

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

CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateRelTableContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}

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

CypherParser::IC_OptionsContext* CypherParser::IC_CreateRelTableContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}

CypherParser::IC_PropertyDefinitionsContext* CypherParser::IC_CreateRelTableContext::iC_PropertyDefinitions() {
  return getRuleContext<CypherParser::IC_PropertyDefinitionsContext>(0);
}

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


size_t CypherParser::IC_CreateRelTableContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateRelTable;
}


CypherParser::IC_CreateRelTableContext* CypherParser::iC_CreateRelTable() {
  IC_CreateRelTableContext *_localctx = _tracker.createInstance<IC_CreateRelTableContext>(_ctx, getState());
  enterRule(_localctx, 50, CypherParser::RuleIC_CreateRelTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(879);
    match(CypherParser::CREATE);
    setState(880);
    match(CypherParser::SP);
    setState(881);
    match(CypherParser::REL);
    setState(882);
    match(CypherParser::SP);
    setState(883);
    match(CypherParser::TABLE);
    setState(886);
    _errHandler->sync(this);

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

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

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

    default:
      break;
    }
    setState(892);
    match(CypherParser::SP);
    setState(893);
    oC_SchemaName();
    setState(895);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(894);
      match(CypherParser::SP);
    }
    setState(897);
    match(CypherParser::T__1);
    setState(899);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(898);
      match(CypherParser::SP);
    }
    setState(901);
    iC_FromToConnections();
    setState(903);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(902);
      match(CypherParser::SP);
    }
    setState(931);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx)) {
    case 1: {
      setState(913);
      _errHandler->sync(this);

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

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

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

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

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

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

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

    case 2: {
      setState(926);
      match(CypherParser::T__2);
      setState(927);
      match(CypherParser::SP);
      setState(928);
      match(CypherParser::AS);
      setState(929);
      match(CypherParser::SP);
      setState(930);
      oC_Query();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx)) {
    case 1: {
      setState(933);
      match(CypherParser::SP);
      setState(934);
      match(CypherParser::WITH);
      setState(936);
      _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(939);
        match(CypherParser::SP);
      }
      setState(942);
      iC_Options();
      setState(944);
      _errHandler->sync(this);

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

//----------------- IC_CreateIndexContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::IC_CreateIndexContext::INDEX() {
  return getToken(CypherParser::INDEX, 0);
}

tree::TerminalNode* CypherParser::IC_CreateIndexContext::FOR() {
  return getToken(CypherParser::FOR, 0);
}

CypherParser::IC_IndexPatternContext* CypherParser::IC_CreateIndexContext::iC_IndexPattern() {
  return getRuleContext<CypherParser::IC_IndexPatternContext>(0);
}

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

CypherParser::IC_IndexPropertyPatternContext* CypherParser::IC_CreateIndexContext::iC_IndexPropertyPattern() {
  return getRuleContext<CypherParser::IC_IndexPropertyPatternContext>(0);
}

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

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

CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateIndexContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}

tree::TerminalNode* CypherParser::IC_CreateIndexContext::OPTIONS() {
  return getToken(CypherParser::OPTIONS, 0);
}

CypherParser::IC_OptionsContext* CypherParser::IC_CreateIndexContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}


size_t CypherParser::IC_CreateIndexContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateIndex;
}


CypherParser::IC_CreateIndexContext* CypherParser::iC_CreateIndex() {
  IC_CreateIndexContext *_localctx = _tracker.createInstance<IC_CreateIndexContext>(_ctx, getState());
  enterRule(_localctx, 52, CypherParser::RuleIC_CreateIndex);
  size_t _la = 0;

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

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

    default:
      break;
    }
    setState(955);
    match(CypherParser::SP);
    setState(956);
    match(CypherParser::INDEX);
    setState(959);
    _errHandler->sync(this);

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

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

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

    default:
      break;
    }
    setState(965);
    match(CypherParser::SP);
    setState(966);
    match(CypherParser::FOR);
    setState(967);
    match(CypherParser::SP);
    setState(968);
    iC_IndexPattern();
    setState(969);
    match(CypherParser::SP);
    setState(970);
    match(CypherParser::ON);
    setState(971);
    match(CypherParser::SP);
    setState(972);
    iC_IndexPropertyPattern();
    setState(989);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
    case 1: {
      setState(973);
      match(CypherParser::SP);
      setState(974);
      match(CypherParser::OPTIONS);
      setState(976);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(975);
        match(CypherParser::SP);
      }
      setState(978);
      match(CypherParser::T__8);
      setState(980);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
        setState(982);
        iC_Options();
      }
      setState(986);
      _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- IC_IndexPatternContext ------------------------------------------------------------------

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

CypherParser::IC_IndexNodePatternContext* CypherParser::IC_IndexPatternContext::iC_IndexNodePattern() {
  return getRuleContext<CypherParser::IC_IndexNodePatternContext>(0);
}

CypherParser::IC_IndexRelationshipPatternContext* CypherParser::IC_IndexPatternContext::iC_IndexRelationshipPattern() {
  return getRuleContext<CypherParser::IC_IndexRelationshipPatternContext>(0);
}


size_t CypherParser::IC_IndexPatternContext::getRuleIndex() const {
  return CypherParser::RuleIC_IndexPattern;
}


CypherParser::IC_IndexPatternContext* CypherParser::iC_IndexPattern() {
  IC_IndexPatternContext *_localctx = _tracker.createInstance<IC_IndexPatternContext>(_ctx, getState());
  enterRule(_localctx, 54, CypherParser::RuleIC_IndexPattern);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(992);
      iC_IndexRelationshipPattern();
      break;
    }

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

  return _localctx;
}

//----------------- IC_IndexNodePatternContext ------------------------------------------------------------------

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

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

CypherParser::OC_LabelNameContext* CypherParser::IC_IndexNodePatternContext::oC_LabelName() {
  return getRuleContext<CypherParser::OC_LabelNameContext>(0);
}

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

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

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


size_t CypherParser::IC_IndexNodePatternContext::getRuleIndex() const {
  return CypherParser::RuleIC_IndexNodePattern;
}


CypherParser::IC_IndexNodePatternContext* CypherParser::iC_IndexNodePattern() {
  IC_IndexNodePatternContext *_localctx = _tracker.createInstance<IC_IndexNodePatternContext>(_ctx, getState());
  enterRule(_localctx, 56, CypherParser::RuleIC_IndexNodePattern);
  size_t _la = 0;

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

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
      setState(999);
      oC_Variable();
    }
    setState(1003);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1002);
      match(CypherParser::SP);
    }
    setState(1005);
    match(CypherParser::COLON);
    setState(1007);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1006);
      match(CypherParser::SP);
    }
    setState(1009);
    oC_LabelName();
    setState(1011);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_IndexRelationshipPatternContext ------------------------------------------------------------------

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

CypherParser::OC_RelationshipPatternContext* CypherParser::IC_IndexRelationshipPatternContext::oC_RelationshipPattern() {
  return getRuleContext<CypherParser::OC_RelationshipPatternContext>(0);
}

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

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


size_t CypherParser::IC_IndexRelationshipPatternContext::getRuleIndex() const {
  return CypherParser::RuleIC_IndexRelationshipPattern;
}


CypherParser::IC_IndexRelationshipPatternContext* CypherParser::iC_IndexRelationshipPattern() {
  IC_IndexRelationshipPatternContext *_localctx = _tracker.createInstance<IC_IndexRelationshipPatternContext>(_ctx, getState());
  enterRule(_localctx, 58, CypherParser::RuleIC_IndexRelationshipPattern);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1016);
      match(CypherParser::SP);
    }
    setState(1019);
    match(CypherParser::T__2);
    setState(1021);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1020);
      match(CypherParser::SP);
    }
    setState(1023);
    oC_RelationshipPattern();
    setState(1025);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1024);
      match(CypherParser::SP);
    }
    setState(1027);
    match(CypherParser::T__1);
    setState(1029);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_IndexPropertyPatternContext ------------------------------------------------------------------

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

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

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

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

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


size_t CypherParser::IC_IndexPropertyPatternContext::getRuleIndex() const {
  return CypherParser::RuleIC_IndexPropertyPattern;
}


CypherParser::IC_IndexPropertyPatternContext* CypherParser::iC_IndexPropertyPattern() {
  IC_IndexPropertyPatternContext *_localctx = _tracker.createInstance<IC_IndexPropertyPatternContext>(_ctx, getState());
  enterRule(_localctx, 60, CypherParser::RuleIC_IndexPropertyPattern);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1034);
      match(CypherParser::SP);
    }
    setState(1037);
    oC_Variable();
    setState(1039);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1038);
      match(CypherParser::SP);
    }
    setState(1041);
    match(CypherParser::T__4);
    setState(1043);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1042);
      match(CypherParser::SP);
    }
    setState(1045);
    oC_PropertyKeyName();
    setState(1047);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_FromToConnectionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_FromToConnectionContext *> CypherParser::IC_FromToConnectionsContext::iC_FromToConnection() {
  return getRuleContexts<CypherParser::IC_FromToConnectionContext>();
}

CypherParser::IC_FromToConnectionContext* CypherParser::IC_FromToConnectionsContext::iC_FromToConnection(size_t i) {
  return getRuleContext<CypherParser::IC_FromToConnectionContext>(i);
}

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

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


size_t CypherParser::IC_FromToConnectionsContext::getRuleIndex() const {
  return CypherParser::RuleIC_FromToConnections;
}


CypherParser::IC_FromToConnectionsContext* CypherParser::iC_FromToConnections() {
  IC_FromToConnectionsContext *_localctx = _tracker.createInstance<IC_FromToConnectionsContext>(_ctx, getState());
  enterRule(_localctx, 62, CypherParser::RuleIC_FromToConnections);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1052);
          match(CypherParser::SP);
        }
        setState(1055);
        match(CypherParser::T__3);
        setState(1057);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1056);
          match(CypherParser::SP);
        }
        setState(1059);
        iC_FromToConnection(); 
      }
      setState(1064);
      _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;
}

//----------------- IC_FromToConnectionContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::IC_FromToConnectionContext::getRuleIndex() const {
  return CypherParser::RuleIC_FromToConnection;
}


CypherParser::IC_FromToConnectionContext* CypherParser::iC_FromToConnection() {
  IC_FromToConnectionContext *_localctx = _tracker.createInstance<IC_FromToConnectionContext>(_ctx, getState());
  enterRule(_localctx, 64, CypherParser::RuleIC_FromToConnection);

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

//----------------- IC_CreateSequenceContext ------------------------------------------------------------------

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

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

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

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

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

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

CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateSequenceContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}

std::vector<CypherParser::IC_SequenceOptionsContext *> CypherParser::IC_CreateSequenceContext::iC_SequenceOptions() {
  return getRuleContexts<CypherParser::IC_SequenceOptionsContext>();
}

CypherParser::IC_SequenceOptionsContext* CypherParser::IC_CreateSequenceContext::iC_SequenceOptions(size_t i) {
  return getRuleContext<CypherParser::IC_SequenceOptionsContext>(i);
}


size_t CypherParser::IC_CreateSequenceContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateSequence;
}


CypherParser::IC_CreateSequenceContext* CypherParser::iC_CreateSequence() {
  IC_CreateSequenceContext *_localctx = _tracker.createInstance<IC_CreateSequenceContext>(_ctx, getState());
  enterRule(_localctx, 66, CypherParser::RuleIC_CreateSequence);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1073);
    match(CypherParser::CREATE);
    setState(1074);
    match(CypherParser::SP);
    setState(1075);
    match(CypherParser::SEQUENCE);
    setState(1076);
    match(CypherParser::SP);
    setState(1080);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(1082);
    oC_SchemaName();
    setState(1087);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1083);
        match(CypherParser::SP);
        setState(1084);
        iC_SequenceOptions(); 
      }
      setState(1089);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_CreateTypeContext ------------------------------------------------------------------

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

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

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

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

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

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

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

CypherParser::IC_DataTypeContext* CypherParser::IC_CreateTypeContext::iC_DataType() {
  return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}


size_t CypherParser::IC_CreateTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateType;
}


CypherParser::IC_CreateTypeContext* CypherParser::iC_CreateType() {
  IC_CreateTypeContext *_localctx = _tracker.createInstance<IC_CreateTypeContext>(_ctx, getState());
  enterRule(_localctx, 68, CypherParser::RuleIC_CreateType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1090);
    match(CypherParser::CREATE);
    setState(1091);
    match(CypherParser::SP);
    setState(1092);
    match(CypherParser::TYPE);
    setState(1093);
    match(CypherParser::SP);
    setState(1094);
    oC_SchemaName();
    setState(1095);
    match(CypherParser::SP);
    setState(1096);
    match(CypherParser::AS);
    setState(1097);
    match(CypherParser::SP);
    setState(1098);
    iC_DataType(0);
    setState(1100);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx)) {
    case 1: {
      setState(1099);
      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;
}

//----------------- IC_SequenceOptionsContext ------------------------------------------------------------------

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

CypherParser::IC_IncrementByContext* CypherParser::IC_SequenceOptionsContext::iC_IncrementBy() {
  return getRuleContext<CypherParser::IC_IncrementByContext>(0);
}

CypherParser::IC_MinValueContext* CypherParser::IC_SequenceOptionsContext::iC_MinValue() {
  return getRuleContext<CypherParser::IC_MinValueContext>(0);
}

CypherParser::IC_MaxValueContext* CypherParser::IC_SequenceOptionsContext::iC_MaxValue() {
  return getRuleContext<CypherParser::IC_MaxValueContext>(0);
}

CypherParser::IC_StartWithContext* CypherParser::IC_SequenceOptionsContext::iC_StartWith() {
  return getRuleContext<CypherParser::IC_StartWithContext>(0);
}

CypherParser::IC_CycleContext* CypherParser::IC_SequenceOptionsContext::iC_Cycle() {
  return getRuleContext<CypherParser::IC_CycleContext>(0);
}


size_t CypherParser::IC_SequenceOptionsContext::getRuleIndex() const {
  return CypherParser::RuleIC_SequenceOptions;
}


CypherParser::IC_SequenceOptionsContext* CypherParser::iC_SequenceOptions() {
  IC_SequenceOptionsContext *_localctx = _tracker.createInstance<IC_SequenceOptionsContext>(_ctx, getState());
  enterRule(_localctx, 70, CypherParser::RuleIC_SequenceOptions);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1103);
      iC_MinValue();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1104);
      iC_MaxValue();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1105);
      iC_StartWith();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1106);
      iC_Cycle();
      break;
    }

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

  return _localctx;
}

//----------------- IC_WithPasswdContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::IC_WithPasswdContext::PASSWORD() {
  return getToken(CypherParser::PASSWORD, 0);
}

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


size_t CypherParser::IC_WithPasswdContext::getRuleIndex() const {
  return CypherParser::RuleIC_WithPasswd;
}


CypherParser::IC_WithPasswdContext* CypherParser::iC_WithPasswd() {
  IC_WithPasswdContext *_localctx = _tracker.createInstance<IC_WithPasswdContext>(_ctx, getState());
  enterRule(_localctx, 72, CypherParser::RuleIC_WithPasswd);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1109);
    match(CypherParser::SP);
    setState(1110);
    match(CypherParser::WITH);
    setState(1111);
    match(CypherParser::SP);
    setState(1112);
    match(CypherParser::PASSWORD);
    setState(1113);
    match(CypherParser::SP);
    setState(1114);
    match(CypherParser::StringLiteral);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_CreateUserContext ------------------------------------------------------------------

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

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

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

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

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

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

CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateUserContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}

CypherParser::IC_WithPasswdContext* CypherParser::IC_CreateUserContext::iC_WithPasswd() {
  return getRuleContext<CypherParser::IC_WithPasswdContext>(0);
}


size_t CypherParser::IC_CreateUserContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateUser;
}


CypherParser::IC_CreateUserContext* CypherParser::iC_CreateUser() {
  IC_CreateUserContext *_localctx = _tracker.createInstance<IC_CreateUserContext>(_ctx, getState());
  enterRule(_localctx, 74, CypherParser::RuleIC_CreateUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1116);
    match(CypherParser::CREATE);
    setState(1117);
    match(CypherParser::SP);
    setState(1118);
    match(CypherParser::USER);
    setState(1119);
    match(CypherParser::SP);
    setState(1123);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(1125);
    oC_Variable();
    setState(1127);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 137, _ctx)) {
    case 1: {
      setState(1126);
      iC_WithPasswd();
      break;
    }

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

  return _localctx;
}

//----------------- IC_CreateRoleContext ------------------------------------------------------------------

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

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

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

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

tree::TerminalNode* CypherParser::IC_CreateRoleContext::ROLE() {
  return getToken(CypherParser::ROLE, 0);
}

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

CypherParser::IC_IfNotExistsContext* CypherParser::IC_CreateRoleContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}


size_t CypherParser::IC_CreateRoleContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateRole;
}


CypherParser::IC_CreateRoleContext* CypherParser::iC_CreateRole() {
  IC_CreateRoleContext *_localctx = _tracker.createInstance<IC_CreateRoleContext>(_ctx, getState());
  enterRule(_localctx, 76, CypherParser::RuleIC_CreateRole);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1129);
    match(CypherParser::CREATE);
    setState(1130);
    match(CypherParser::SP);
    setState(1131);
    match(CypherParser::ROLE);
    setState(1132);
    match(CypherParser::SP);
    setState(1136);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- IC_IncrementByContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::IC_IncrementByContext::getRuleIndex() const {
  return CypherParser::RuleIC_IncrementBy;
}


CypherParser::IC_IncrementByContext* CypherParser::iC_IncrementBy() {
  IC_IncrementByContext *_localctx = _tracker.createInstance<IC_IncrementByContext>(_ctx, getState());
  enterRule(_localctx, 78, CypherParser::RuleIC_IncrementBy);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::BY) {
      setState(1142);
      match(CypherParser::BY);
      setState(1143);
      match(CypherParser::SP);
    }
    setState(1147);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_MinValueContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_MinValueContext::getRuleIndex() const {
  return CypherParser::RuleIC_MinValue;
}


CypherParser::IC_MinValueContext* CypherParser::iC_MinValue() {
  IC_MinValueContext *_localctx = _tracker.createInstance<IC_MinValueContext>(_ctx, getState());
  enterRule(_localctx, 80, CypherParser::RuleIC_MinValue);
  size_t _la = 0;

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

      case CypherParser::MINVALUE: {
        enterOuterAlt(_localctx, 2);
        setState(1154);
        match(CypherParser::MINVALUE);
        setState(1155);
        match(CypherParser::SP);
        setState(1157);
        _errHandler->sync(this);

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

//----------------- IC_MaxValueContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_MaxValueContext::getRuleIndex() const {
  return CypherParser::RuleIC_MaxValue;
}


CypherParser::IC_MaxValueContext* CypherParser::iC_MaxValue() {
  IC_MaxValueContext *_localctx = _tracker.createInstance<IC_MaxValueContext>(_ctx, getState());
  enterRule(_localctx, 82, CypherParser::RuleIC_MaxValue);
  size_t _la = 0;

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

      case CypherParser::MAXVALUE: {
        enterOuterAlt(_localctx, 2);
        setState(1165);
        match(CypherParser::MAXVALUE);
        setState(1166);
        match(CypherParser::SP);
        setState(1168);
        _errHandler->sync(this);

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

//----------------- IC_StartWithContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::IC_StartWithContext::getRuleIndex() const {
  return CypherParser::RuleIC_StartWith;
}


CypherParser::IC_StartWithContext* CypherParser::iC_StartWith() {
  IC_StartWithContext *_localctx = _tracker.createInstance<IC_StartWithContext>(_ctx, getState());
  enterRule(_localctx, 84, CypherParser::RuleIC_StartWith);
  size_t _la = 0;

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

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

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

  return _localctx;
}

//----------------- IC_CycleContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_CycleContext::getRuleIndex() const {
  return CypherParser::RuleIC_Cycle;
}


CypherParser::IC_CycleContext* CypherParser::iC_Cycle() {
  IC_CycleContext *_localctx = _tracker.createInstance<IC_CycleContext>(_ctx, getState());
  enterRule(_localctx, 86, CypherParser::RuleIC_Cycle);
  size_t _la = 0;

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

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

  return _localctx;
}

//----------------- IC_IfExistsContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_IfExistsContext::getRuleIndex() const {
  return CypherParser::RuleIC_IfExists;
}


CypherParser::IC_IfExistsContext* CypherParser::iC_IfExists() {
  IC_IfExistsContext *_localctx = _tracker.createInstance<IC_IfExistsContext>(_ctx, getState());
  enterRule(_localctx, 88, CypherParser::RuleIC_IfExists);

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

  return _localctx;
}

//----------------- IC_DropContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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

tree::TerminalNode* CypherParser::IC_DropContext::GRAPH() {
  return getToken(CypherParser::GRAPH, 0);
}

CypherParser::IC_IfExistsContext* CypherParser::IC_DropContext::iC_IfExists() {
  return getRuleContext<CypherParser::IC_IfExistsContext>(0);
}


size_t CypherParser::IC_DropContext::getRuleIndex() const {
  return CypherParser::RuleIC_Drop;
}


CypherParser::IC_DropContext* CypherParser::iC_Drop() {
  IC_DropContext *_localctx = _tracker.createInstance<IC_DropContext>(_ctx, getState());
  enterRule(_localctx, 90, CypherParser::RuleIC_Drop);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1194);
    match(CypherParser::DROP);
    setState(1195);
    match(CypherParser::SP);
    setState(1196);
    _la = _input->LA(1);
    if (!(((((_la - 91) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 91)) & 285873023287297) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1197);
    match(CypherParser::SP);
    setState(1201);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- IC_AlterTableContext ------------------------------------------------------------------

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

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

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

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

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

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

CypherParser::IC_AlterOptionsContext* CypherParser::IC_AlterTableContext::iC_AlterOptions() {
  return getRuleContext<CypherParser::IC_AlterOptionsContext>(0);
}


size_t CypherParser::IC_AlterTableContext::getRuleIndex() const {
  return CypherParser::RuleIC_AlterTable;
}


CypherParser::IC_AlterTableContext* CypherParser::iC_AlterTable() {
  IC_AlterTableContext *_localctx = _tracker.createInstance<IC_AlterTableContext>(_ctx, getState());
  enterRule(_localctx, 92, CypherParser::RuleIC_AlterTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1205);
    match(CypherParser::ALTER);
    setState(1206);
    match(CypherParser::SP);
    setState(1207);
    match(CypherParser::TABLE);
    setState(1208);
    match(CypherParser::SP);
    setState(1209);
    oC_SchemaName();
    setState(1210);
    match(CypherParser::SP);
    setState(1211);
    iC_AlterOptions();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_AlterOptionsContext ------------------------------------------------------------------

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

CypherParser::IC_AddPropertyContext* CypherParser::IC_AlterOptionsContext::iC_AddProperty() {
  return getRuleContext<CypherParser::IC_AddPropertyContext>(0);
}

CypherParser::IC_DropPropertyContext* CypherParser::IC_AlterOptionsContext::iC_DropProperty() {
  return getRuleContext<CypherParser::IC_DropPropertyContext>(0);
}

CypherParser::IC_RenameTableContext* CypherParser::IC_AlterOptionsContext::iC_RenameTable() {
  return getRuleContext<CypherParser::IC_RenameTableContext>(0);
}

CypherParser::IC_RenamePropertyContext* CypherParser::IC_AlterOptionsContext::iC_RenameProperty() {
  return getRuleContext<CypherParser::IC_RenamePropertyContext>(0);
}

CypherParser::IC_AddFromToConnectionContext* CypherParser::IC_AlterOptionsContext::iC_AddFromToConnection() {
  return getRuleContext<CypherParser::IC_AddFromToConnectionContext>(0);
}

CypherParser::IC_DropFromToConnectionContext* CypherParser::IC_AlterOptionsContext::iC_DropFromToConnection() {
  return getRuleContext<CypherParser::IC_DropFromToConnectionContext>(0);
}


size_t CypherParser::IC_AlterOptionsContext::getRuleIndex() const {
  return CypherParser::RuleIC_AlterOptions;
}


CypherParser::IC_AlterOptionsContext* CypherParser::iC_AlterOptions() {
  IC_AlterOptionsContext *_localctx = _tracker.createInstance<IC_AlterOptionsContext>(_ctx, getState());
  enterRule(_localctx, 94, CypherParser::RuleIC_AlterOptions);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1214);
      iC_DropProperty();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1215);
      iC_RenameTable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1216);
      iC_RenameProperty();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1217);
      iC_AddFromToConnection();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1218);
      iC_DropFromToConnection();
      break;
    }

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

  return _localctx;
}

//----------------- IC_AddPropertyContext ------------------------------------------------------------------

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

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

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

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

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

CypherParser::IC_DataTypeContext* CypherParser::IC_AddPropertyContext::iC_DataType() {
  return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}

CypherParser::IC_IfNotExistsContext* CypherParser::IC_AddPropertyContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}

CypherParser::IC_DefaultContext* CypherParser::IC_AddPropertyContext::iC_Default() {
  return getRuleContext<CypherParser::IC_DefaultContext>(0);
}


size_t CypherParser::IC_AddPropertyContext::getRuleIndex() const {
  return CypherParser::RuleIC_AddProperty;
}


CypherParser::IC_AddPropertyContext* CypherParser::iC_AddProperty() {
  IC_AddPropertyContext *_localctx = _tracker.createInstance<IC_AddPropertyContext>(_ctx, getState());
  enterRule(_localctx, 96, CypherParser::RuleIC_AddProperty);

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

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

    default:
      break;
    }
    setState(1228);
    oC_PropertyKeyName();
    setState(1229);
    match(CypherParser::SP);
    setState(1230);
    iC_DataType(0);
    setState(1233);
    _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- IC_DefaultContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_DefaultContext::getRuleIndex() const {
  return CypherParser::RuleIC_Default;
}


CypherParser::IC_DefaultContext* CypherParser::iC_Default() {
  IC_DefaultContext *_localctx = _tracker.createInstance<IC_DefaultContext>(_ctx, getState());
  enterRule(_localctx, 98, CypherParser::RuleIC_Default);

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

  return _localctx;
}

//----------------- IC_DropPropertyContext ------------------------------------------------------------------

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

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

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

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

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

CypherParser::IC_IfExistsContext* CypherParser::IC_DropPropertyContext::iC_IfExists() {
  return getRuleContext<CypherParser::IC_IfExistsContext>(0);
}


size_t CypherParser::IC_DropPropertyContext::getRuleIndex() const {
  return CypherParser::RuleIC_DropProperty;
}


CypherParser::IC_DropPropertyContext* CypherParser::iC_DropProperty() {
  IC_DropPropertyContext *_localctx = _tracker.createInstance<IC_DropPropertyContext>(_ctx, getState());
  enterRule(_localctx, 100, CypherParser::RuleIC_DropProperty);

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

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

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

  return _localctx;
}

//----------------- IC_RenameTableContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_RenameTableContext::getRuleIndex() const {
  return CypherParser::RuleIC_RenameTable;
}


CypherParser::IC_RenameTableContext* CypherParser::iC_RenameTable() {
  IC_RenameTableContext *_localctx = _tracker.createInstance<IC_RenameTableContext>(_ctx, getState());
  enterRule(_localctx, 102, CypherParser::RuleIC_RenameTable);

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

  return _localctx;
}

//----------------- IC_RenamePropertyContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::IC_RenamePropertyContext::getRuleIndex() const {
  return CypherParser::RuleIC_RenameProperty;
}


CypherParser::IC_RenamePropertyContext* CypherParser::iC_RenameProperty() {
  IC_RenamePropertyContext *_localctx = _tracker.createInstance<IC_RenamePropertyContext>(_ctx, getState());
  enterRule(_localctx, 104, CypherParser::RuleIC_RenameProperty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1254);
    match(CypherParser::RENAME);
    setState(1255);
    match(CypherParser::SP);
    setState(1256);
    oC_PropertyKeyName();
    setState(1257);
    match(CypherParser::SP);
    setState(1258);
    match(CypherParser::TO);
    setState(1259);
    match(CypherParser::SP);
    setState(1260);
    oC_PropertyKeyName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_AddFromToConnectionContext ------------------------------------------------------------------

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

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

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

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

CypherParser::IC_FromToConnectionContext* CypherParser::IC_AddFromToConnectionContext::iC_FromToConnection() {
  return getRuleContext<CypherParser::IC_FromToConnectionContext>(0);
}

CypherParser::IC_IfNotExistsContext* CypherParser::IC_AddFromToConnectionContext::iC_IfNotExists() {
  return getRuleContext<CypherParser::IC_IfNotExistsContext>(0);
}


size_t CypherParser::IC_AddFromToConnectionContext::getRuleIndex() const {
  return CypherParser::RuleIC_AddFromToConnection;
}


CypherParser::IC_AddFromToConnectionContext* CypherParser::iC_AddFromToConnection() {
  IC_AddFromToConnectionContext *_localctx = _tracker.createInstance<IC_AddFromToConnectionContext>(_ctx, getState());
  enterRule(_localctx, 106, CypherParser::RuleIC_AddFromToConnection);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::IF) {
      setState(1264);
      iC_IfNotExists();
      setState(1265);
      match(CypherParser::SP);
    }
    setState(1269);
    iC_FromToConnection();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_DropFromToConnectionContext ------------------------------------------------------------------

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

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

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

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

CypherParser::IC_FromToConnectionContext* CypherParser::IC_DropFromToConnectionContext::iC_FromToConnection() {
  return getRuleContext<CypherParser::IC_FromToConnectionContext>(0);
}

CypherParser::IC_IfExistsContext* CypherParser::IC_DropFromToConnectionContext::iC_IfExists() {
  return getRuleContext<CypherParser::IC_IfExistsContext>(0);
}


size_t CypherParser::IC_DropFromToConnectionContext::getRuleIndex() const {
  return CypherParser::RuleIC_DropFromToConnection;
}


CypherParser::IC_DropFromToConnectionContext* CypherParser::iC_DropFromToConnection() {
  IC_DropFromToConnectionContext *_localctx = _tracker.createInstance<IC_DropFromToConnectionContext>(_ctx, getState());
  enterRule(_localctx, 108, CypherParser::RuleIC_DropFromToConnection);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::IF) {
      setState(1273);
      iC_IfExists();
      setState(1274);
      match(CypherParser::SP);
    }
    setState(1278);
    iC_FromToConnection();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_ColumnDefinitionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_ColumnDefinitionContext *> CypherParser::IC_ColumnDefinitionsContext::iC_ColumnDefinition() {
  return getRuleContexts<CypherParser::IC_ColumnDefinitionContext>();
}

CypherParser::IC_ColumnDefinitionContext* CypherParser::IC_ColumnDefinitionsContext::iC_ColumnDefinition(size_t i) {
  return getRuleContext<CypherParser::IC_ColumnDefinitionContext>(i);
}

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

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


size_t CypherParser::IC_ColumnDefinitionsContext::getRuleIndex() const {
  return CypherParser::RuleIC_ColumnDefinitions;
}


CypherParser::IC_ColumnDefinitionsContext* CypherParser::iC_ColumnDefinitions() {
  IC_ColumnDefinitionsContext *_localctx = _tracker.createInstance<IC_ColumnDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 110, CypherParser::RuleIC_ColumnDefinitions);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1281);
          match(CypherParser::SP);
        }
        setState(1284);
        match(CypherParser::T__3);
        setState(1286);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1285);
          match(CypherParser::SP);
        }
        setState(1288);
        iC_ColumnDefinition(); 
      }
      setState(1293);
      _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;
}

//----------------- IC_ColumnDefinitionContext ------------------------------------------------------------------

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

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

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

CypherParser::IC_DataTypeContext* CypherParser::IC_ColumnDefinitionContext::iC_DataType() {
  return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}


size_t CypherParser::IC_ColumnDefinitionContext::getRuleIndex() const {
  return CypherParser::RuleIC_ColumnDefinition;
}


CypherParser::IC_ColumnDefinitionContext* CypherParser::iC_ColumnDefinition() {
  IC_ColumnDefinitionContext *_localctx = _tracker.createInstance<IC_ColumnDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 112, CypherParser::RuleIC_ColumnDefinition);

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

  return _localctx;
}

//----------------- IC_PropertyDefinitionsContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_PropertyDefinitionContext *> CypherParser::IC_PropertyDefinitionsContext::iC_PropertyDefinition() {
  return getRuleContexts<CypherParser::IC_PropertyDefinitionContext>();
}

CypherParser::IC_PropertyDefinitionContext* CypherParser::IC_PropertyDefinitionsContext::iC_PropertyDefinition(size_t i) {
  return getRuleContext<CypherParser::IC_PropertyDefinitionContext>(i);
}

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

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


size_t CypherParser::IC_PropertyDefinitionsContext::getRuleIndex() const {
  return CypherParser::RuleIC_PropertyDefinitions;
}


CypherParser::IC_PropertyDefinitionsContext* CypherParser::iC_PropertyDefinitions() {
  IC_PropertyDefinitionsContext *_localctx = _tracker.createInstance<IC_PropertyDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 114, CypherParser::RuleIC_PropertyDefinitions);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1299);
          match(CypherParser::SP);
        }
        setState(1302);
        match(CypherParser::T__3);
        setState(1304);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1303);
          match(CypherParser::SP);
        }
        setState(1306);
        iC_PropertyDefinition(); 
      }
      setState(1311);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_PropertyDefinitionContext ------------------------------------------------------------------

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

CypherParser::IC_ColumnDefinitionContext* CypherParser::IC_PropertyDefinitionContext::iC_ColumnDefinition() {
  return getRuleContext<CypherParser::IC_ColumnDefinitionContext>(0);
}

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

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

CypherParser::IC_DefaultContext* CypherParser::IC_PropertyDefinitionContext::iC_Default() {
  return getRuleContext<CypherParser::IC_DefaultContext>(0);
}

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

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


size_t CypherParser::IC_PropertyDefinitionContext::getRuleIndex() const {
  return CypherParser::RuleIC_PropertyDefinition;
}


CypherParser::IC_PropertyDefinitionContext* CypherParser::iC_PropertyDefinition() {
  IC_PropertyDefinitionContext *_localctx = _tracker.createInstance<IC_PropertyDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 116, CypherParser::RuleIC_PropertyDefinition);

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 162, _ctx)) {
    case 1: {
      setState(1317);
      match(CypherParser::SP);
      setState(1318);
      match(CypherParser::PRIMARY);
      setState(1319);
      match(CypherParser::SP);
      setState(1320);
      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;
}

//----------------- IC_CreateNodeConstraintContext ------------------------------------------------------------------

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

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

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

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

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

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


size_t CypherParser::IC_CreateNodeConstraintContext::getRuleIndex() const {
  return CypherParser::RuleIC_CreateNodeConstraint;
}


CypherParser::IC_CreateNodeConstraintContext* CypherParser::iC_CreateNodeConstraint() {
  IC_CreateNodeConstraintContext *_localctx = _tracker.createInstance<IC_CreateNodeConstraintContext>(_ctx, getState());
  enterRule(_localctx, 118, CypherParser::RuleIC_CreateNodeConstraint);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1326);
      match(CypherParser::SP);
    }
    setState(1329);
    match(CypherParser::T__1);
    setState(1331);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1330);
      match(CypherParser::SP);
    }
    setState(1333);
    oC_PropertyKeyName();
    setState(1335);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_UnionTypeContext ------------------------------------------------------------------

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

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

CypherParser::IC_ColumnDefinitionsContext* CypherParser::IC_UnionTypeContext::iC_ColumnDefinitions() {
  return getRuleContext<CypherParser::IC_ColumnDefinitionsContext>(0);
}

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

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


size_t CypherParser::IC_UnionTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_UnionType;
}


CypherParser::IC_UnionTypeContext* CypherParser::iC_UnionType() {
  IC_UnionTypeContext *_localctx = _tracker.createInstance<IC_UnionTypeContext>(_ctx, getState());
  enterRule(_localctx, 120, CypherParser::RuleIC_UnionType);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1340);
      match(CypherParser::SP);
    }
    setState(1343);
    match(CypherParser::T__1);
    setState(1345);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1344);
      match(CypherParser::SP);
    }
    setState(1347);
    iC_ColumnDefinitions();
    setState(1349);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_StructTypeContext ------------------------------------------------------------------

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

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

CypherParser::IC_ColumnDefinitionsContext* CypherParser::IC_StructTypeContext::iC_ColumnDefinitions() {
  return getRuleContext<CypherParser::IC_ColumnDefinitionsContext>(0);
}

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

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


size_t CypherParser::IC_StructTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_StructType;
}


CypherParser::IC_StructTypeContext* CypherParser::iC_StructType() {
  IC_StructTypeContext *_localctx = _tracker.createInstance<IC_StructTypeContext>(_ctx, getState());
  enterRule(_localctx, 122, CypherParser::RuleIC_StructType);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1354);
      match(CypherParser::SP);
    }
    setState(1357);
    match(CypherParser::T__1);
    setState(1359);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1358);
      match(CypherParser::SP);
    }
    setState(1361);
    iC_ColumnDefinitions();
    setState(1363);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_MapTypeContext ------------------------------------------------------------------

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

tree::TerminalNode* CypherParser::IC_MapTypeContext::MAP() {
  return getToken(CypherParser::MAP, 0);
}

std::vector<CypherParser::IC_DataTypeContext *> CypherParser::IC_MapTypeContext::iC_DataType() {
  return getRuleContexts<CypherParser::IC_DataTypeContext>();
}

CypherParser::IC_DataTypeContext* CypherParser::IC_MapTypeContext::iC_DataType(size_t i) {
  return getRuleContext<CypherParser::IC_DataTypeContext>(i);
}

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

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


size_t CypherParser::IC_MapTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_MapType;
}


CypherParser::IC_MapTypeContext* CypherParser::iC_MapType() {
  IC_MapTypeContext *_localctx = _tracker.createInstance<IC_MapTypeContext>(_ctx, getState());
  enterRule(_localctx, 124, CypherParser::RuleIC_MapType);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1368);
      match(CypherParser::SP);
    }
    setState(1371);
    match(CypherParser::T__1);
    setState(1373);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1372);
      match(CypherParser::SP);
    }
    setState(1375);
    iC_DataType(0);
    setState(1377);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1376);
      match(CypherParser::SP);
    }
    setState(1379);
    match(CypherParser::T__3);
    setState(1381);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1380);
      match(CypherParser::SP);
    }
    setState(1383);
    iC_DataType(0);
    setState(1385);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_DecimalTypeContext ------------------------------------------------------------------

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

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

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

CypherParser::OC_IntegerLiteralContext* CypherParser::IC_DecimalTypeContext::oC_IntegerLiteral(size_t i) {
  return getRuleContext<CypherParser::OC_IntegerLiteralContext>(i);
}

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

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


size_t CypherParser::IC_DecimalTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_DecimalType;
}


CypherParser::IC_DecimalTypeContext* CypherParser::iC_DecimalType() {
  IC_DecimalTypeContext *_localctx = _tracker.createInstance<IC_DecimalTypeContext>(_ctx, getState());
  enterRule(_localctx, 126, CypherParser::RuleIC_DecimalType);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1390);
      match(CypherParser::SP);
    }
    setState(1393);
    match(CypherParser::T__1);
    setState(1395);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1394);
      match(CypherParser::SP);
    }
    setState(1397);
    oC_IntegerLiteral();
    setState(1399);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1398);
      match(CypherParser::SP);
    }
    setState(1401);
    match(CypherParser::T__3);
    setState(1403);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1402);
      match(CypherParser::SP);
    }
    setState(1405);
    oC_IntegerLiteral();
    setState(1407);
    _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_DataTypeContext ------------------------------------------------------------------

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

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

CypherParser::IC_UnionTypeContext* CypherParser::IC_DataTypeContext::iC_UnionType() {
  return getRuleContext<CypherParser::IC_UnionTypeContext>(0);
}

CypherParser::IC_StructTypeContext* CypherParser::IC_DataTypeContext::iC_StructType() {
  return getRuleContext<CypherParser::IC_StructTypeContext>(0);
}

CypherParser::IC_MapTypeContext* CypherParser::IC_DataTypeContext::iC_MapType() {
  return getRuleContext<CypherParser::IC_MapTypeContext>(0);
}

CypherParser::IC_DecimalTypeContext* CypherParser::IC_DataTypeContext::iC_DecimalType() {
  return getRuleContext<CypherParser::IC_DecimalTypeContext>(0);
}

CypherParser::IC_DataTypeContext* CypherParser::IC_DataTypeContext::iC_DataType() {
  return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}

CypherParser::IC_ListIdentifiersContext* CypherParser::IC_DataTypeContext::iC_ListIdentifiers() {
  return getRuleContext<CypherParser::IC_ListIdentifiersContext>(0);
}


size_t CypherParser::IC_DataTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_DataType;
}



CypherParser::IC_DataTypeContext* CypherParser::iC_DataType() {
   return iC_DataType(0);
}

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

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1417);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 182, _ctx)) {
    case 1: {
      setState(1412);
      oC_SymbolicName();
      break;
    }

    case 2: {
      setState(1413);
      iC_UnionType();
      break;
    }

    case 3: {
      setState(1414);
      iC_StructType();
      break;
    }

    case 4: {
      setState(1415);
      iC_MapType();
      break;
    }

    case 5: {
      setState(1416);
      iC_DecimalType();
      break;
    }

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

        if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
        setState(1420);
        iC_ListIdentifiers(); 
      }
      setState(1425);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 183, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- IC_ListIdentifiersContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_ListIdentifierContext *> CypherParser::IC_ListIdentifiersContext::iC_ListIdentifier() {
  return getRuleContexts<CypherParser::IC_ListIdentifierContext>();
}

CypherParser::IC_ListIdentifierContext* CypherParser::IC_ListIdentifiersContext::iC_ListIdentifier(size_t i) {
  return getRuleContext<CypherParser::IC_ListIdentifierContext>(i);
}


size_t CypherParser::IC_ListIdentifiersContext::getRuleIndex() const {
  return CypherParser::RuleIC_ListIdentifiers;
}


CypherParser::IC_ListIdentifiersContext* CypherParser::iC_ListIdentifiers() {
  IC_ListIdentifiersContext *_localctx = _tracker.createInstance<IC_ListIdentifiersContext>(_ctx, getState());
  enterRule(_localctx, 130, CypherParser::RuleIC_ListIdentifiers);

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

  return _localctx;
}

//----------------- IC_ListIdentifierContext ------------------------------------------------------------------

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

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


size_t CypherParser::IC_ListIdentifierContext::getRuleIndex() const {
  return CypherParser::RuleIC_ListIdentifier;
}


CypherParser::IC_ListIdentifierContext* CypherParser::iC_ListIdentifier() {
  IC_ListIdentifierContext *_localctx = _tracker.createInstance<IC_ListIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 132, CypherParser::RuleIC_ListIdentifier);
  size_t _la = 0;

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

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

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 187, _ctx)) {
    case 1: {
      setState(1444);
      match(CypherParser::SP);
      setState(1445);
      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, 138, CypherParser::RuleOC_Profile);

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

  return _localctx;
}

//----------------- IC_TransactionContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

tree::TerminalNode* CypherParser::IC_TransactionContext::CHECKPOINT() {
  return getToken(CypherParser::CHECKPOINT, 0);
}


size_t CypherParser::IC_TransactionContext::getRuleIndex() const {
  return CypherParser::RuleIC_Transaction;
}


CypherParser::IC_TransactionContext* CypherParser::iC_Transaction() {
  IC_TransactionContext *_localctx = _tracker.createInstance<IC_TransactionContext>(_ctx, getState());
  enterRule(_localctx, 140, CypherParser::RuleIC_Transaction);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1453);
      match(CypherParser::BEGIN);
      setState(1454);
      match(CypherParser::SP);
      setState(1455);
      match(CypherParser::TRANSACTION);
      setState(1456);
      match(CypherParser::SP);
      setState(1457);
      match(CypherParser::READ);
      setState(1458);
      match(CypherParser::SP);
      setState(1459);
      match(CypherParser::ONLY);
      break;
    }

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

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

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1462);
      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;
}

//----------------- IC_ExtensionContext ------------------------------------------------------------------

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

CypherParser::IC_LoadExtensionContext* CypherParser::IC_ExtensionContext::iC_LoadExtension() {
  return getRuleContext<CypherParser::IC_LoadExtensionContext>(0);
}

CypherParser::IC_InstallExtensionContext* CypherParser::IC_ExtensionContext::iC_InstallExtension() {
  return getRuleContext<CypherParser::IC_InstallExtensionContext>(0);
}

CypherParser::IC_UninstallExtensionContext* CypherParser::IC_ExtensionContext::iC_UninstallExtension() {
  return getRuleContext<CypherParser::IC_UninstallExtensionContext>(0);
}

CypherParser::IC_UpdateExtensionContext* CypherParser::IC_ExtensionContext::iC_UpdateExtension() {
  return getRuleContext<CypherParser::IC_UpdateExtensionContext>(0);
}


size_t CypherParser::IC_ExtensionContext::getRuleIndex() const {
  return CypherParser::RuleIC_Extension;
}


CypherParser::IC_ExtensionContext* CypherParser::iC_Extension() {
  IC_ExtensionContext *_localctx = _tracker.createInstance<IC_ExtensionContext>(_ctx, getState());
  enterRule(_localctx, 142, CypherParser::RuleIC_Extension);

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

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

      case CypherParser::UNINSTALL: {
        enterOuterAlt(_localctx, 3);
        setState(1467);
        iC_UninstallExtension();
        break;
      }

      case CypherParser::UPDATE: {
        enterOuterAlt(_localctx, 4);
        setState(1468);
        iC_UpdateExtension();
        break;
      }

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

  return _localctx;
}

//----------------- IC_LoadExtensionContext ------------------------------------------------------------------

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

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

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

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

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

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

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


size_t CypherParser::IC_LoadExtensionContext::getRuleIndex() const {
  return CypherParser::RuleIC_LoadExtension;
}


CypherParser::IC_LoadExtensionContext* CypherParser::iC_LoadExtension() {
  IC_LoadExtensionContext *_localctx = _tracker.createInstance<IC_LoadExtensionContext>(_ctx, getState());
  enterRule(_localctx, 144, CypherParser::RuleIC_LoadExtension);

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

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

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

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

//----------------- IC_InstallExtensionContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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


size_t CypherParser::IC_InstallExtensionContext::getRuleIndex() const {
  return CypherParser::RuleIC_InstallExtension;
}


CypherParser::IC_InstallExtensionContext* CypherParser::iC_InstallExtension() {
  IC_InstallExtensionContext *_localctx = _tracker.createInstance<IC_InstallExtensionContext>(_ctx, getState());
  enterRule(_localctx, 146, CypherParser::RuleIC_InstallExtension);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::FORCE) {
      setState(1481);
      match(CypherParser::FORCE);
      setState(1482);
      match(CypherParser::SP);
    }
    setState(1485);
    match(CypherParser::INSTALL);
    setState(1486);
    match(CypherParser::SP);
    setState(1487);
    oC_Variable();
    setState(1492);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 193, _ctx)) {
    case 1: {
      setState(1488);
      match(CypherParser::SP);
      setState(1489);
      match(CypherParser::FROM);
      setState(1490);
      match(CypherParser::SP);
      setState(1491);
      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;
}

//----------------- IC_UninstallExtensionContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_UninstallExtensionContext::getRuleIndex() const {
  return CypherParser::RuleIC_UninstallExtension;
}


CypherParser::IC_UninstallExtensionContext* CypherParser::iC_UninstallExtension() {
  IC_UninstallExtensionContext *_localctx = _tracker.createInstance<IC_UninstallExtensionContext>(_ctx, getState());
  enterRule(_localctx, 148, CypherParser::RuleIC_UninstallExtension);

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

  return _localctx;
}

//----------------- IC_UpdateExtensionContext ------------------------------------------------------------------

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

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

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

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


size_t CypherParser::IC_UpdateExtensionContext::getRuleIndex() const {
  return CypherParser::RuleIC_UpdateExtension;
}


CypherParser::IC_UpdateExtensionContext* CypherParser::iC_UpdateExtension() {
  IC_UpdateExtensionContext *_localctx = _tracker.createInstance<IC_UpdateExtensionContext>(_ctx, getState());
  enterRule(_localctx, 150, CypherParser::RuleIC_UpdateExtension);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1502);
    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, 154, 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(1525);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 198, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1504);
      oC_SingleQuery();
      setState(1511);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 195, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1506);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1505);
            match(CypherParser::SP);
          }
          setState(1508);
          oC_Union(); 
        }
        setState(1513);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 195, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1518); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1514);
                oC_Return();
                setState(1516);
                _errHandler->sync(this);

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

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1539);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 201, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1527);
      match(CypherParser::UNION);
      setState(1528);
      match(CypherParser::SP);
      setState(1529);
      match(CypherParser::ALL);
      setState(1531);
      _errHandler->sync(this);

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

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

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

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1542);
      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, 160, 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(1580);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 211, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1551);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::CALL || ((((_la - 105) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 105)) & 4398046576649) != 0)) {
        setState(1545);
        oC_ReadingClause();
        setState(1547);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1546);
          match(CypherParser::SP);
        }
        setState(1553);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1554);
      oC_Return();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1561);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::CALL || ((((_la - 105) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 105)) & 4398046576649) != 0)) {
        setState(1555);
        oC_ReadingClause();
        setState(1557);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1556);
          match(CypherParser::SP);
        }
        setState(1563);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1564);
      oC_UpdatingClause();
      setState(1571);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 208, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1566);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1565);
            match(CypherParser::SP);
          }
          setState(1568);
          oC_UpdatingClause(); 
        }
        setState(1573);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 208, _ctx);
      }
      setState(1578);
      _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1574);
          match(CypherParser::SP);
        }
        setState(1577);
        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::IC_QueryPartContext *> CypherParser::OC_MultiPartQueryContext::iC_QueryPart() {
  return getRuleContexts<CypherParser::IC_QueryPartContext>();
}

CypherParser::IC_QueryPartContext* CypherParser::OC_MultiPartQueryContext::iC_QueryPart(size_t i) {
  return getRuleContext<CypherParser::IC_QueryPartContext>(i);
}

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

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


size_t CypherParser::OC_MultiPartQueryContext::getRuleIndex() const {
  return CypherParser::RuleOC_MultiPartQuery;
}


CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() {
  OC_MultiPartQueryContext *_localctx = _tracker.createInstance<OC_MultiPartQueryContext>(_ctx, getState());
  enterRule(_localctx, 162, 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(1586); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(1582);
              iC_QueryPart();
              setState(1584);
              _errHandler->sync(this);

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

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

  return _localctx;
}

//----------------- IC_QueryPartContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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


size_t CypherParser::IC_QueryPartContext::getRuleIndex() const {
  return CypherParser::RuleIC_QueryPart;
}


CypherParser::IC_QueryPartContext* CypherParser::iC_QueryPart() {
  IC_QueryPartContext *_localctx = _tracker.createInstance<IC_QueryPartContext>(_ctx, getState());
  enterRule(_localctx, 164, CypherParser::RuleIC_QueryPart);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1598);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::CALL || ((((_la - 105) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 105)) & 4398046576649) != 0)) {
      setState(1592);
      oC_ReadingClause();
      setState(1594);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1593);
        match(CypherParser::SP);
      }
      setState(1600);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1607);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 68) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 68)) & 4398046511393) != 0) || _la == CypherParser::SET) {
      setState(1601);
      oC_UpdatingClause();
      setState(1603);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1602);
        match(CypherParser::SP);
      }
      setState(1609);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1610);
    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, 166, CypherParser::RuleOC_UpdatingClause);

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

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

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

      case CypherParser::DELETE:
      case CypherParser::DETACH: {
        enterOuterAlt(_localctx, 4);
        setState(1615);
        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::IC_InQueryCallContext* CypherParser::OC_ReadingClauseContext::iC_InQueryCall() {
  return getRuleContext<CypherParser::IC_InQueryCallContext>(0);
}

CypherParser::IC_LoadFromContext* CypherParser::OC_ReadingClauseContext::iC_LoadFrom() {
  return getRuleContext<CypherParser::IC_LoadFromContext>(0);
}


size_t CypherParser::OC_ReadingClauseContext::getRuleIndex() const {
  return CypherParser::RuleOC_ReadingClause;
}


CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() {
  OC_ReadingClauseContext *_localctx = _tracker.createInstance<OC_ReadingClauseContext>(_ctx, getState());
  enterRule(_localctx, 168, CypherParser::RuleOC_ReadingClause);

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

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

      case CypherParser::CALL: {
        enterOuterAlt(_localctx, 3);
        setState(1620);
        iC_InQueryCall();
        break;
      }

      case CypherParser::LOAD: {
        enterOuterAlt(_localctx, 4);
        setState(1621);
        iC_LoadFrom();
        break;
      }

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

  return _localctx;
}

//----------------- IC_LoadFromContext ------------------------------------------------------------------

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

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

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

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

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

CypherParser::IC_ScanSourceContext* CypherParser::IC_LoadFromContext::iC_ScanSource() {
  return getRuleContext<CypherParser::IC_ScanSourceContext>(0);
}

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

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

CypherParser::IC_ColumnDefinitionsContext* CypherParser::IC_LoadFromContext::iC_ColumnDefinitions() {
  return getRuleContext<CypherParser::IC_ColumnDefinitionsContext>(0);
}

CypherParser::IC_OptionsContext* CypherParser::IC_LoadFromContext::iC_Options() {
  return getRuleContext<CypherParser::IC_OptionsContext>(0);
}

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


size_t CypherParser::IC_LoadFromContext::getRuleIndex() const {
  return CypherParser::RuleIC_LoadFrom;
}


CypherParser::IC_LoadFromContext* CypherParser::iC_LoadFrom() {
  IC_LoadFromContext *_localctx = _tracker.createInstance<IC_LoadFromContext>(_ctx, getState());
  enterRule(_localctx, 170, CypherParser::RuleIC_LoadFrom);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 223, _ctx)) {
    case 1: {
      setState(1625);
      match(CypherParser::SP);
      setState(1626);
      match(CypherParser::WITH);
      setState(1627);
      match(CypherParser::SP);
      setState(1628);
      match(CypherParser::HEADERS);
      setState(1630);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1629);
        match(CypherParser::SP);
      }
      setState(1632);
      match(CypherParser::T__1);
      setState(1634);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1633);
        match(CypherParser::SP);
      }
      setState(1636);
      iC_ColumnDefinitions();
      setState(1638);
      _errHandler->sync(this);

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

    default:
      break;
    }
    setState(1644);
    match(CypherParser::SP);
    setState(1645);
    match(CypherParser::FROM);
    setState(1646);
    match(CypherParser::SP);
    setState(1647);
    iC_ScanSource();
    setState(1661);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1648);
        match(CypherParser::SP);
      }
      setState(1651);
      match(CypherParser::T__1);
      setState(1653);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1652);
        match(CypherParser::SP);
      }
      setState(1655);
      iC_Options();
      setState(1657);
      _errHandler->sync(this);

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1663);
        match(CypherParser::SP);
      }
      setState(1666);
      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, 172, CypherParser::RuleOC_YieldItem);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx)) {
    case 1: {
      setState(1669);
      oC_Variable();
      setState(1670);
      match(CypherParser::SP);
      setState(1671);
      match(CypherParser::AS);
      setState(1672);
      match(CypherParser::SP);
      break;
    }

    default:
      break;
    }
    setState(1676);
    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, 174, 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(1678);
    oC_YieldItem();
    setState(1689);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 233, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1680);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1679);
          match(CypherParser::SP);
        }
        setState(1682);
        match(CypherParser::T__3);
        setState(1684);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1683);
          match(CypherParser::SP);
        }
        setState(1686);
        oC_YieldItem(); 
      }
      setState(1691);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 233, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_InQueryCallContext ------------------------------------------------------------------

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

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

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

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

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

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

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

CypherParser::OC_YieldItemsContext* CypherParser::IC_InQueryCallContext::oC_YieldItems() {
  return getRuleContext<CypherParser::OC_YieldItemsContext>(0);
}


size_t CypherParser::IC_InQueryCallContext::getRuleIndex() const {
  return CypherParser::RuleIC_InQueryCall;
}


CypherParser::IC_InQueryCallContext* CypherParser::iC_InQueryCall() {
  IC_InQueryCallContext *_localctx = _tracker.createInstance<IC_InQueryCallContext>(_ctx, getState());
  enterRule(_localctx, 176, CypherParser::RuleIC_InQueryCall);
  size_t _la = 0;

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

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

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1701);
        match(CypherParser::SP);
      }
      setState(1704);
      match(CypherParser::YIELD);
      setState(1705);
      match(CypherParser::SP);
      setState(1706);
      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::IC_HintContext* CypherParser::OC_MatchContext::iC_Hint() {
  return getRuleContext<CypherParser::IC_HintContext>(0);
}


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


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

    _la = _input->LA(1);
    if (_la == CypherParser::OPTIONAL) {
      setState(1709);
      match(CypherParser::OPTIONAL);
      setState(1710);
      match(CypherParser::SP);
    }
    setState(1713);
    match(CypherParser::MATCH);
    setState(1715);
    _errHandler->sync(this);

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

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

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

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

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

  return _localctx;
}

//----------------- IC_HintContext ------------------------------------------------------------------

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

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

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

CypherParser::IC_JoinNodeContext* CypherParser::IC_HintContext::iC_JoinNode() {
  return getRuleContext<CypherParser::IC_JoinNodeContext>(0);
}


size_t CypherParser::IC_HintContext::getRuleIndex() const {
  return CypherParser::RuleIC_Hint;
}


CypherParser::IC_HintContext* CypherParser::iC_Hint() {
  IC_HintContext *_localctx = _tracker.createInstance<IC_HintContext>(_ctx, getState());
  enterRule(_localctx, 180, CypherParser::RuleIC_Hint);

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

  return _localctx;
}

//----------------- IC_JoinNodeContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_JoinNodeContext *> CypherParser::IC_JoinNodeContext::iC_JoinNode() {
  return getRuleContexts<CypherParser::IC_JoinNodeContext>();
}

CypherParser::IC_JoinNodeContext* CypherParser::IC_JoinNodeContext::iC_JoinNode(size_t i) {
  return getRuleContext<CypherParser::IC_JoinNodeContext>(i);
}

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

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

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

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

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

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

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


size_t CypherParser::IC_JoinNodeContext::getRuleIndex() const {
  return CypherParser::RuleIC_JoinNode;
}



CypherParser::IC_JoinNodeContext* CypherParser::iC_JoinNode() {
   return iC_JoinNode(0);
}

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

    size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1732);
          match(CypherParser::SP);
        }
        setState(1735);
        iC_JoinNode(0);
        setState(1737);
        _errHandler->sync(this);

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

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

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(1760);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(1758);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 246, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<IC_JoinNodeContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleIC_JoinNode);
          setState(1744);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(1745);
          match(CypherParser::SP);
          setState(1746);
          match(CypherParser::JOIN);
          setState(1747);
          match(CypherParser::SP);
          setState(1748);
          iC_JoinNode(5);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<IC_JoinNodeContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleIC_JoinNode);
          setState(1749);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(1754); 
          _errHandler->sync(this);
          alt = 1;
          do {
            switch (alt) {
              case 1: {
                    setState(1750);
                    match(CypherParser::SP);
                    setState(1751);
                    match(CypherParser::MULTI_JOIN);
                    setState(1752);
                    match(CypherParser::SP);
                    setState(1753);
                    oC_SchemaName();
                    break;
                  }

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

        default:
          break;
        } 
      }
      setState(1762);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _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, 184, 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(1763);
    match(CypherParser::UNWIND);
    setState(1765);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1764);
      match(CypherParser::SP);
    }
    setState(1767);
    oC_Expression();
    setState(1768);
    match(CypherParser::SP);
    setState(1769);
    match(CypherParser::AS);
    setState(1770);
    match(CypherParser::SP);
    setState(1771);
    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, 186, 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(1773);
    match(CypherParser::CREATE);
    setState(1775);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1774);
      match(CypherParser::SP);
    }
    setState(1777);
    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, 188, 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(1779);
    match(CypherParser::MERGE);
    setState(1781);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1780);
      match(CypherParser::SP);
    }
    setState(1783);
    oC_Pattern();
    setState(1788);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1784);
        match(CypherParser::SP);
        setState(1785);
        oC_MergeAction(); 
      }
      setState(1790);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1801);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1791);
      match(CypherParser::ON);
      setState(1792);
      match(CypherParser::SP);
      setState(1793);
      match(CypherParser::MATCH);
      setState(1794);
      match(CypherParser::SP);
      setState(1795);
      oC_Set();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1796);
      match(CypherParser::ON);
      setState(1797);
      match(CypherParser::SP);
      setState(1798);
      match(CypherParser::CREATE);
      setState(1799);
      match(CypherParser::SP);
      setState(1800);
      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);
}

CypherParser::OC_AtomContext* CypherParser::OC_SetContext::oC_Atom() {
  return getRuleContext<CypherParser::OC_AtomContext>(0);
}

CypherParser::IC_PropertiesContext* CypherParser::OC_SetContext::iC_Properties() {
  return getRuleContext<CypherParser::IC_PropertiesContext>(0);
}


size_t CypherParser::OC_SetContext::getRuleIndex() const {
  return CypherParser::RuleOC_Set;
}


CypherParser::OC_SetContext* CypherParser::oC_Set() {
  OC_SetContext *_localctx = _tracker.createInstance<OC_SetContext>(_ctx, getState());
  enterRule(_localctx, 192, CypherParser::RuleOC_Set);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1835);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 260, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1803);
      match(CypherParser::SET);
      setState(1805);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1804);
        match(CypherParser::SP);
      }
      setState(1807);
      oC_SetItem();
      setState(1818);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 256, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1809);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1808);
            match(CypherParser::SP);
          }
          setState(1811);
          match(CypherParser::T__3);
          setState(1813);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(1812);
            match(CypherParser::SP);
          }
          setState(1815);
          oC_SetItem(); 
        }
        setState(1820);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 256, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1821);
      match(CypherParser::SET);
      setState(1823);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1822);
        match(CypherParser::SP);
      }
      setState(1825);
      oC_Atom();
      setState(1827);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1826);
        match(CypherParser::SP);
      }
      setState(1829);
      match(CypherParser::T__5);
      setState(1831);
      _errHandler->sync(this);

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

    default:
      break;
    }
   
  }
  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, 194, 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(1837);
    oC_PropertyExpression();
    setState(1839);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1838);
      match(CypherParser::SP);
    }
    setState(1841);
    match(CypherParser::T__5);
    setState(1843);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1842);
      match(CypherParser::SP);
    }
    setState(1845);
    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, 196, 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(1849);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::DETACH) {
      setState(1847);
      match(CypherParser::DETACH);
      setState(1848);
      match(CypherParser::SP);
    }
    setState(1851);
    match(CypherParser::DELETE);
    setState(1853);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(1852);
      match(CypherParser::SP);
    }
    setState(1855);
    oC_Expression();
    setState(1866);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 267, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1857);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1856);
          match(CypherParser::SP);
        }
        setState(1859);
        match(CypherParser::T__3);
        setState(1861);
        _errHandler->sync(this);

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

  return _localctx;
}

//----------------- 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, 198, 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(1869);
    match(CypherParser::WITH);
    setState(1870);
    oC_ProjectionBody();
    setState(1875);
    _errHandler->sync(this);

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

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

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

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

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

    default:
      break;
    }
    setState(1886);
    match(CypherParser::SP);
    setState(1887);
    oC_ProjectionItems();
    setState(1890);
    _errHandler->sync(this);

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

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 274, _ctx)) {
    case 1: {
      setState(1896);
      match(CypherParser::SP);
      setState(1897);
      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, 204, 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(1928);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::STAR: {
        enterOuterAlt(_localctx, 1);
        setState(1900);
        match(CypherParser::STAR);
        setState(1911);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 277, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(1902);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1901);
              match(CypherParser::SP);
            }
            setState(1904);
            match(CypherParser::T__3);
            setState(1906);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1905);
              match(CypherParser::SP);
            }
            setState(1908);
            oC_ProjectionItem(); 
          }
          setState(1913);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 277, _ctx);
        }
        break;
      }

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

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

            _la = _input->LA(1);
            if (_la == CypherParser::SP) {
              setState(1919);
              match(CypherParser::SP);
            }
            setState(1922);
            oC_ProjectionItem(); 
          }
          setState(1927);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 280, _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, 206, CypherParser::RuleOC_ProjectionItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1937);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 282, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1930);
      oC_Expression();
      setState(1931);
      match(CypherParser::SP);
      setState(1932);
      match(CypherParser::AS);
      setState(1933);
      match(CypherParser::SP);
      setState(1934);
      oC_Variable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1936);
      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, 208, 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(1939);
    match(CypherParser::ORDER);
    setState(1940);
    match(CypherParser::SP);
    setState(1941);
    match(CypherParser::BY);
    setState(1942);
    match(CypherParser::SP);
    setState(1943);
    oC_SortItem();
    setState(1951);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__3) {
      setState(1944);
      match(CypherParser::T__3);
      setState(1946);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(1945);
        match(CypherParser::SP);
      }
      setState(1948);
      oC_SortItem();
      setState(1953);
      _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, 210, CypherParser::RuleOC_Skip);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1958);
    match(CypherParser::LIMIT);
    setState(1959);
    match(CypherParser::SP);
    setState(1960);
    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, 214, 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(1962);
    oC_Expression();
    setState(1967);
    _errHandler->sync(this);

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

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

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

  return _localctx;
}

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1969);
    match(CypherParser::WHERE);
    setState(1970);
    match(CypherParser::SP);
    setState(1971);
    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, 218, 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(1973);
    oC_PatternPart();
    setState(1984);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 289, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1975);
        _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1978);
          match(CypherParser::SP);
        }
        setState(1981);
        oC_PatternPart(); 
      }
      setState(1986);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 289, _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, 220, CypherParser::RuleOC_PatternPart);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(1988);
          match(CypherParser::SP);
        }
        setState(1991);
        match(CypherParser::T__5);
        setState(1993);
        _errHandler->sync(this);

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

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2000);
    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, 224, 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(2016);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 295, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2002);
      oC_NodePattern();
      setState(2009);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2004);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2003);
            match(CypherParser::SP);
          }
          setState(2006);
          oC_PatternElementChain(); 
        }
        setState(2011);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2012);
      match(CypherParser::T__1);
      setState(2013);
      oC_PatternElement();
      setState(2014);
      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::IC_PropertiesContext* CypherParser::OC_NodePatternContext::iC_Properties() {
  return getRuleContext<CypherParser::IC_PropertiesContext>(0);
}


size_t CypherParser::OC_NodePatternContext::getRuleIndex() const {
  return CypherParser::RuleOC_NodePattern;
}


CypherParser::OC_NodePatternContext* CypherParser::oC_NodePattern() {
  OC_NodePatternContext *_localctx = _tracker.createInstance<OC_NodePatternContext>(_ctx, getState());
  enterRule(_localctx, 226, 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(2018);
    match(CypherParser::T__1);
    setState(2020);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
      setState(2022);
      oC_Variable();
      setState(2024);
      _errHandler->sync(this);

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

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

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__8) {
      setState(2034);
      iC_Properties();
      setState(2036);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2035);
        match(CypherParser::SP);
      }
    }
    setState(2040);
    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, 228, 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(2042);
    oC_RelationshipPattern();
    setState(2044);
    _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2049);
        match(CypherParser::SP);
      }
      setState(2052);
      oC_Dash();
      setState(2054);
      _errHandler->sync(this);

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

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

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

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

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

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2071);
        match(CypherParser::SP);
      }
      setState(2074);
      oC_Dash();
      setState(2076);
      _errHandler->sync(this);

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

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

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

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2087);
        match(CypherParser::SP);
      }
      setState(2090);
      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::IC_RecursiveDetailContext* CypherParser::OC_RelationshipDetailContext::iC_RecursiveDetail() {
  return getRuleContext<CypherParser::IC_RecursiveDetailContext>(0);
}

CypherParser::IC_PropertiesContext* CypherParser::OC_RelationshipDetailContext::iC_Properties() {
  return getRuleContext<CypherParser::IC_PropertiesContext>(0);
}


size_t CypherParser::OC_RelationshipDetailContext::getRuleIndex() const {
  return CypherParser::RuleOC_RelationshipDetail;
}


CypherParser::OC_RelationshipDetailContext* CypherParser::oC_RelationshipDetail() {
  OC_RelationshipDetailContext *_localctx = _tracker.createInstance<OC_RelationshipDetailContext>(_ctx, getState());
  enterRule(_localctx, 232, 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(2094);
    match(CypherParser::T__6);
    setState(2096);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
      setState(2098);
      oC_Variable();
      setState(2100);
      _errHandler->sync(this);

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

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

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

    _la = _input->LA(1);
    if (_la == CypherParser::STAR) {
      setState(2110);
      iC_RecursiveDetail();
      setState(2112);
      _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__8) {
      setState(2116);
      iC_Properties();
      setState(2118);
      _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_PropertiesContext ------------------------------------------------------------------

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

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

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

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

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

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

tree::TerminalNode* CypherParser::IC_PropertiesContext::COLON(size_t i) {
  return getToken(CypherParser::COLON, i);
}

std::vector<CypherParser::OC_ExpressionContext *> CypherParser::IC_PropertiesContext::oC_Expression() {
  return getRuleContexts<CypherParser::OC_ExpressionContext>();
}

CypherParser::OC_ExpressionContext* CypherParser::IC_PropertiesContext::oC_Expression(size_t i) {
  return getRuleContext<CypherParser::OC_ExpressionContext>(i);
}


size_t CypherParser::IC_PropertiesContext::getRuleIndex() const {
  return CypherParser::RuleIC_Properties;
}


CypherParser::IC_PropertiesContext* CypherParser::iC_Properties() {
  IC_PropertiesContext *_localctx = _tracker.createInstance<IC_PropertiesContext>(_ctx, getState());
  enterRule(_localctx, 234, CypherParser::RuleIC_Properties);
  size_t _la = 0;

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -3185593048922849280) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2304862428370032329) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 81100080244413111) != 0)) {
      setState(2128);
      oC_PropertyKeyName();
      setState(2130);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2129);
        match(CypherParser::SP);
      }
      setState(2132);
      match(CypherParser::COLON);
      setState(2134);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2133);
        match(CypherParser::SP);
      }
      setState(2136);
      oC_Expression();
      setState(2138);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2137);
        match(CypherParser::SP);
      }
      setState(2158);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::T__3) {
        setState(2140);
        match(CypherParser::T__3);
        setState(2142);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2141);
          match(CypherParser::SP);
        }
        setState(2144);
        oC_PropertyKeyName();
        setState(2146);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2145);
          match(CypherParser::SP);
        }
        setState(2148);
        match(CypherParser::COLON);
        setState(2150);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2149);
          match(CypherParser::SP);
        }
        setState(2152);
        oC_Expression();
        setState(2154);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2153);
          match(CypherParser::SP);
        }
        setState(2160);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(2163);
    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, 236, 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(2165);
    match(CypherParser::COLON);
    setState(2167);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2166);
      match(CypherParser::SP);
    }
    setState(2169);
    oC_RelTypeName();
    setState(2183);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 339, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2171);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2170);
          match(CypherParser::SP);
        }
        setState(2173);
        match(CypherParser::T__10);
        setState(2175);
        _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2177);
          match(CypherParser::SP);
        }
        setState(2180);
        oC_RelTypeName(); 
      }
      setState(2185);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 339, _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<tree::TerminalNode *> CypherParser::OC_NodeLabelsContext::COLON() {
  return getTokens(CypherParser::COLON);
}

tree::TerminalNode* CypherParser::OC_NodeLabelsContext::COLON(size_t i) {
  return getToken(CypherParser::COLON, i);
}

std::vector<CypherParser::OC_LabelNameContext *> CypherParser::OC_NodeLabelsContext::oC_LabelName() {
  return getRuleContexts<CypherParser::OC_LabelNameContext>();
}

CypherParser::OC_LabelNameContext* CypherParser::OC_NodeLabelsContext::oC_LabelName(size_t i) {
  return getRuleContext<CypherParser::OC_LabelNameContext>(i);
}

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

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


size_t CypherParser::OC_NodeLabelsContext::getRuleIndex() const {
  return CypherParser::RuleOC_NodeLabels;
}


CypherParser::OC_NodeLabelsContext* CypherParser::oC_NodeLabels() {
  OC_NodeLabelsContext *_localctx = _tracker.createInstance<OC_NodeLabelsContext>(_ctx, getState());
  enterRule(_localctx, 238, 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(2186);
    match(CypherParser::COLON);
    setState(2188);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2187);
      match(CypherParser::SP);
    }
    setState(2190);
    oC_LabelName();
    setState(2207);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 345, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2192);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2191);
          match(CypherParser::SP);
        }
        setState(2199);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case CypherParser::T__10: {
            setState(2194);
            match(CypherParser::T__10);
            setState(2196);
            _errHandler->sync(this);

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

          case CypherParser::COLON: {
            setState(2198);
            match(CypherParser::COLON);
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(2202);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2201);
          match(CypherParser::SP);
        }
        setState(2204);
        oC_LabelName(); 
      }
      setState(2209);
      _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;
}

//----------------- IC_RecursiveDetailContext ------------------------------------------------------------------

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

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

CypherParser::IC_RecursiveTypeContext* CypherParser::IC_RecursiveDetailContext::iC_RecursiveType() {
  return getRuleContext<CypherParser::IC_RecursiveTypeContext>(0);
}

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

CypherParser::IC_RecursiveComprehensionContext* CypherParser::IC_RecursiveDetailContext::iC_RecursiveComprehension() {
  return getRuleContext<CypherParser::IC_RecursiveComprehensionContext>(0);
}

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

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


size_t CypherParser::IC_RecursiveDetailContext::getRuleIndex() const {
  return CypherParser::RuleIC_RecursiveDetail;
}


CypherParser::IC_RecursiveDetailContext* CypherParser::iC_RecursiveDetail() {
  IC_RecursiveDetailContext *_localctx = _tracker.createInstance<IC_RecursiveDetailContext>(_ctx, getState());
  enterRule(_localctx, 240, CypherParser::RuleIC_RecursiveDetail);
  size_t _la = 0;

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

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

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

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

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

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

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

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

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

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

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

  return _localctx;
}

//----------------- IC_RecursiveTypeContext ------------------------------------------------------------------

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

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

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

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

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

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

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

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

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


size_t CypherParser::IC_RecursiveTypeContext::getRuleIndex() const {
  return CypherParser::RuleIC_RecursiveType;
}


CypherParser::IC_RecursiveTypeContext* CypherParser::iC_RecursiveType() {
  IC_RecursiveTypeContext *_localctx = _tracker.createInstance<IC_RecursiveTypeContext>(_ctx, getState());
  enterRule(_localctx, 242, CypherParser::RuleIC_RecursiveType);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == CypherParser::ALL) {
        setState(2229);
        match(CypherParser::ALL);
        setState(2230);
        match(CypherParser::SP);
      }
      setState(2233);
      match(CypherParser::WSHORTEST);
      setState(2235);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2234);
        match(CypherParser::SP);
      }
      setState(2237);
      match(CypherParser::T__1);
      setState(2239);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2238);
        match(CypherParser::SP);
      }
      setState(2241);
      oC_PropertyKeyName();
      setState(2243);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2247);
      match(CypherParser::SHORTEST);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2248);
      match(CypherParser::ALL);
      setState(2249);
      match(CypherParser::SP);
      setState(2250);
      match(CypherParser::SHORTEST);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2251);
      match(CypherParser::TRAIL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2252);
      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) {
}

tree::TerminalNode* CypherParser::OC_RangeLiteralContext::DOTDOT() {
  return getToken(CypherParser::DOTDOT, 0);
}

CypherParser::OC_LowerBoundContext* CypherParser::OC_RangeLiteralContext::oC_LowerBound() {
  return getRuleContext<CypherParser::OC_LowerBoundContext>(0);
}

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

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

CypherParser::OC_UpperBoundContext* CypherParser::OC_RangeLiteralContext::oC_UpperBound() {
  return getRuleContext<CypherParser::OC_UpperBoundContext>(0);
}

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


size_t CypherParser::OC_RangeLiteralContext::getRuleIndex() const {
  return CypherParser::RuleOC_RangeLiteral;
}


CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() {
  OC_RangeLiteralContext *_localctx = _tracker.createInstance<OC_RangeLiteralContext>(_ctx, getState());
  enterRule(_localctx, 244, CypherParser::RuleOC_RangeLiteral);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == CypherParser::DecimalInteger) {
        setState(2255);
        oC_LowerBound();
      }
      setState(2259);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2258);
        match(CypherParser::SP);
      }
      setState(2261);
      match(CypherParser::DOTDOT);
      setState(2263);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (_la == CypherParser::DecimalInteger) {
        setState(2265);
        oC_UpperBound();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2268);
      oC_IntegerLiteral();
      break;
    }

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

  return _localctx;
}

//----------------- IC_RecursiveComprehensionContext ------------------------------------------------------------------

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

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

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

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

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

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

std::vector<CypherParser::IC_RecursiveProjectionItemsContext *> CypherParser::IC_RecursiveComprehensionContext::iC_RecursiveProjectionItems() {
  return getRuleContexts<CypherParser::IC_RecursiveProjectionItemsContext>();
}

CypherParser::IC_RecursiveProjectionItemsContext* CypherParser::IC_RecursiveComprehensionContext::iC_RecursiveProjectionItems(size_t i) {
  return getRuleContext<CypherParser::IC_RecursiveProjectionItemsContext>(i);
}


size_t CypherParser::IC_RecursiveComprehensionContext::getRuleIndex() const {
  return CypherParser::RuleIC_RecursiveComprehension;
}


CypherParser::IC_RecursiveComprehensionContext* CypherParser::iC_RecursiveComprehension() {
  IC_RecursiveComprehensionContext *_localctx = _tracker.createInstance<IC_RecursiveComprehensionContext>(_ctx, getState());
  enterRule(_localctx, 246, CypherParser::RuleIC_RecursiveComprehension);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2272);
      match(CypherParser::SP);
    }
    setState(2275);
    oC_Variable();
    setState(2277);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2276);
      match(CypherParser::SP);
    }
    setState(2279);
    match(CypherParser::T__3);
    setState(2281);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2280);
      match(CypherParser::SP);
    }
    setState(2283);
    oC_Variable();
    setState(2295);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2284);
        match(CypherParser::SP);
      }
      setState(2287);
      match(CypherParser::T__10);
      setState(2289);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2288);
        match(CypherParser::SP);
      }
      setState(2291);
      oC_Where();
      setState(2293);
      _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__10 || _la == CypherParser::SP) {
      setState(2298);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2297);
        match(CypherParser::SP);
      }
      setState(2300);
      match(CypherParser::T__10);
      setState(2302);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2301);
        match(CypherParser::SP);
      }
      setState(2304);
      iC_RecursiveProjectionItems();
      setState(2306);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2305);
        match(CypherParser::SP);
      }
      setState(2308);
      match(CypherParser::T__3);
      setState(2310);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2309);
        match(CypherParser::SP);
      }
      setState(2312);
      iC_RecursiveProjectionItems();
      setState(2314);
      _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_RecursiveProjectionItemsContext ------------------------------------------------------------------

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

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

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

CypherParser::OC_ProjectionItemsContext* CypherParser::IC_RecursiveProjectionItemsContext::oC_ProjectionItems() {
  return getRuleContext<CypherParser::OC_ProjectionItemsContext>(0);
}


size_t CypherParser::IC_RecursiveProjectionItemsContext::getRuleIndex() const {
  return CypherParser::RuleIC_RecursiveProjectionItems;
}


CypherParser::IC_RecursiveProjectionItemsContext* CypherParser::iC_RecursiveProjectionItems() {
  IC_RecursiveProjectionItemsContext *_localctx = _tracker.createInstance<IC_RecursiveProjectionItemsContext>(_ctx, getState());
  enterRule(_localctx, 248, CypherParser::RuleIC_RecursiveProjectionItems);
  size_t _la = 0;

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

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2296981129019905737) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 87878604057858743) != 0)) {
      setState(2324);
      oC_ProjectionItems();
    }
    setState(2328);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2327);
      match(CypherParser::SP);
    }
    setState(2330);
    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, 250, CypherParser::RuleOC_LowerBound);

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

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

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

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


size_t CypherParser::OC_LabelNameContext::getRuleIndex() const {
  return CypherParser::RuleOC_LabelName;
}


CypherParser::OC_LabelNameContext* CypherParser::oC_LabelName() {
  OC_LabelNameContext *_localctx = _tracker.createInstance<OC_LabelNameContext>(_ctx, getState());
  enterRule(_localctx, 254, CypherParser::RuleOC_LabelName);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::T__4) {
      setState(2337);
      match(CypherParser::T__4);
      setState(2338);
      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, 256, CypherParser::RuleOC_RelTypeName);

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

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2345);
    oC_XorExpression();
    setState(2352);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 379, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2346);
        match(CypherParser::SP);
        setState(2347);
        match(CypherParser::OR);
        setState(2348);
        match(CypherParser::SP);
        setState(2349);
        oC_XorExpression(); 
      }
      setState(2354);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 379, _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, 262, CypherParser::RuleOC_XorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2355);
    oC_AndExpression();
    setState(2362);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 380, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2356);
        match(CypherParser::SP);
        setState(2357);
        match(CypherParser::XOR);
        setState(2358);
        match(CypherParser::SP);
        setState(2359);
        oC_AndExpression(); 
      }
      setState(2364);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 380, _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, 264, CypherParser::RuleOC_AndExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2365);
    oC_NotExpression();
    setState(2372);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 381, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2366);
        match(CypherParser::SP);
        setState(2367);
        match(CypherParser::AND);
        setState(2368);
        match(CypherParser::SP);
        setState(2369);
        oC_NotExpression(); 
      }
      setState(2374);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 381, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 266, 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(2381);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::NOT) {
      setState(2375);
      match(CypherParser::NOT);
      setState(2377);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2376);
        match(CypherParser::SP);
      }
      setState(2383);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2384);
    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::IC_BitwiseOrOperatorExpressionContext *> CypherParser::OC_ComparisonExpressionContext::iC_BitwiseOrOperatorExpression() {
  return getRuleContexts<CypherParser::IC_BitwiseOrOperatorExpressionContext>();
}

CypherParser::IC_BitwiseOrOperatorExpressionContext* CypherParser::OC_ComparisonExpressionContext::iC_BitwiseOrOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::IC_BitwiseOrOperatorExpressionContext>(i);
}

std::vector<CypherParser::IC_ComparisonOperatorContext *> CypherParser::OC_ComparisonExpressionContext::iC_ComparisonOperator() {
  return getRuleContexts<CypherParser::IC_ComparisonOperatorContext>();
}

CypherParser::IC_ComparisonOperatorContext* CypherParser::OC_ComparisonExpressionContext::iC_ComparisonOperator(size_t i) {
  return getRuleContext<CypherParser::IC_ComparisonOperatorContext>(i);
}

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

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

tree::TerminalNode* CypherParser::OC_ComparisonExpressionContext::INVALID_NOT_EQUAL() {
  return getToken(CypherParser::INVALID_NOT_EQUAL, 0);
}


size_t CypherParser::OC_ComparisonExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_ComparisonExpression;
}


CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpression() {
  OC_ComparisonExpressionContext *_localctx = _tracker.createInstance<OC_ComparisonExpressionContext>(_ctx, getState());
  enterRule(_localctx, 268, 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(2434);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 394, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2386);
      iC_BitwiseOrOperatorExpression();
      setState(2396);
      _errHandler->sync(this);

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2387);
          match(CypherParser::SP);
        }
        setState(2390);
        iC_ComparisonOperator();
        setState(2392);
        _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2398);
      iC_BitwiseOrOperatorExpression();

      setState(2400);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2399);
        match(CypherParser::SP);
      }
      setState(2402);
      antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken = match(CypherParser::INVALID_NOT_EQUAL);
      setState(2404);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2403);
        match(CypherParser::SP);
      }
      setState(2406);
      iC_BitwiseOrOperatorExpression();
       notifyInvalidNotEqualOperator(antlrcpp::downCast<OC_ComparisonExpressionContext *>(_localctx)->invalid_not_equalToken); 
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2410);
      iC_BitwiseOrOperatorExpression();
      setState(2412);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2411);
        match(CypherParser::SP);
      }
      setState(2414);
      iC_ComparisonOperator();
      setState(2416);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2415);
        match(CypherParser::SP);
      }
      setState(2418);
      iC_BitwiseOrOperatorExpression();
      setState(2428); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2420);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(2419);
                  match(CypherParser::SP);
                }
                setState(2422);
                iC_ComparisonOperator();
                setState(2424);
                _errHandler->sync(this);

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

        default:
          throw NoViableAltException(this);
        }
        setState(2430); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 393, _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;
}

//----------------- IC_ComparisonOperatorContext ------------------------------------------------------------------

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


size_t CypherParser::IC_ComparisonOperatorContext::getRuleIndex() const {
  return CypherParser::RuleIC_ComparisonOperator;
}


CypherParser::IC_ComparisonOperatorContext* CypherParser::iC_ComparisonOperator() {
  IC_ComparisonOperatorContext *_localctx = _tracker.createInstance<IC_ComparisonOperatorContext>(_ctx, getState());
  enterRule(_localctx, 270, CypherParser::RuleIC_ComparisonOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2436);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 127040) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_BitwiseOrOperatorExpressionContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_BitwiseAndOperatorExpressionContext *> CypherParser::IC_BitwiseOrOperatorExpressionContext::iC_BitwiseAndOperatorExpression() {
  return getRuleContexts<CypherParser::IC_BitwiseAndOperatorExpressionContext>();
}

CypherParser::IC_BitwiseAndOperatorExpressionContext* CypherParser::IC_BitwiseOrOperatorExpressionContext::iC_BitwiseAndOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::IC_BitwiseAndOperatorExpressionContext>(i);
}

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

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


size_t CypherParser::IC_BitwiseOrOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleIC_BitwiseOrOperatorExpression;
}


CypherParser::IC_BitwiseOrOperatorExpressionContext* CypherParser::iC_BitwiseOrOperatorExpression() {
  IC_BitwiseOrOperatorExpressionContext *_localctx = _tracker.createInstance<IC_BitwiseOrOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 272, CypherParser::RuleIC_BitwiseOrOperatorExpression);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2439);
          match(CypherParser::SP);
        }
        setState(2442);
        match(CypherParser::T__10);
        setState(2444);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2443);
          match(CypherParser::SP);
        }
        setState(2446);
        iC_BitwiseAndOperatorExpression(); 
      }
      setState(2451);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 397, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_BitwiseAndOperatorExpressionContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_BitShiftOperatorExpressionContext *> CypherParser::IC_BitwiseAndOperatorExpressionContext::iC_BitShiftOperatorExpression() {
  return getRuleContexts<CypherParser::IC_BitShiftOperatorExpressionContext>();
}

CypherParser::IC_BitShiftOperatorExpressionContext* CypherParser::IC_BitwiseAndOperatorExpressionContext::iC_BitShiftOperatorExpression(size_t i) {
  return getRuleContext<CypherParser::IC_BitShiftOperatorExpressionContext>(i);
}

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

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


size_t CypherParser::IC_BitwiseAndOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleIC_BitwiseAndOperatorExpression;
}


CypherParser::IC_BitwiseAndOperatorExpressionContext* CypherParser::iC_BitwiseAndOperatorExpression() {
  IC_BitwiseAndOperatorExpressionContext *_localctx = _tracker.createInstance<IC_BitwiseAndOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 274, CypherParser::RuleIC_BitwiseAndOperatorExpression);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2453);
          match(CypherParser::SP);
        }
        setState(2456);
        match(CypherParser::T__16);
        setState(2458);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2457);
          match(CypherParser::SP);
        }
        setState(2460);
        iC_BitShiftOperatorExpression(); 
      }
      setState(2465);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_BitShiftOperatorExpressionContext ------------------------------------------------------------------

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

std::vector<CypherParser::OC_AddOrSubtractExpressionContext *> CypherParser::IC_BitShiftOperatorExpressionContext::oC_AddOrSubtractExpression() {
  return getRuleContexts<CypherParser::OC_AddOrSubtractExpressionContext>();
}

CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::IC_BitShiftOperatorExpressionContext::oC_AddOrSubtractExpression(size_t i) {
  return getRuleContext<CypherParser::OC_AddOrSubtractExpressionContext>(i);
}

std::vector<CypherParser::IC_BitShiftOperatorContext *> CypherParser::IC_BitShiftOperatorExpressionContext::iC_BitShiftOperator() {
  return getRuleContexts<CypherParser::IC_BitShiftOperatorContext>();
}

CypherParser::IC_BitShiftOperatorContext* CypherParser::IC_BitShiftOperatorExpressionContext::iC_BitShiftOperator(size_t i) {
  return getRuleContext<CypherParser::IC_BitShiftOperatorContext>(i);
}

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

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


size_t CypherParser::IC_BitShiftOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleIC_BitShiftOperatorExpression;
}


CypherParser::IC_BitShiftOperatorExpressionContext* CypherParser::iC_BitShiftOperatorExpression() {
  IC_BitShiftOperatorExpressionContext *_localctx = _tracker.createInstance<IC_BitShiftOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 276, CypherParser::RuleIC_BitShiftOperatorExpression);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2467);
          match(CypherParser::SP);
        }
        setState(2470);
        iC_BitShiftOperator();
        setState(2472);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2471);
          match(CypherParser::SP);
        }
        setState(2474);
        oC_AddOrSubtractExpression(); 
      }
      setState(2480);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 403, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_BitShiftOperatorContext ------------------------------------------------------------------

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


size_t CypherParser::IC_BitShiftOperatorContext::getRuleIndex() const {
  return CypherParser::RuleIC_BitShiftOperator;
}


CypherParser::IC_BitShiftOperatorContext* CypherParser::iC_BitShiftOperator() {
  IC_BitShiftOperatorContext *_localctx = _tracker.createInstance<IC_BitShiftOperatorContext>(_ctx, getState());
  enterRule(_localctx, 278, CypherParser::RuleIC_BitShiftOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2481);
    _la = _input->LA(1);
    if (!(_la == CypherParser::T__17

    || _la == CypherParser::T__18)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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::IC_AddOrSubtractOperatorContext *> CypherParser::OC_AddOrSubtractExpressionContext::iC_AddOrSubtractOperator() {
  return getRuleContexts<CypherParser::IC_AddOrSubtractOperatorContext>();
}

CypherParser::IC_AddOrSubtractOperatorContext* CypherParser::OC_AddOrSubtractExpressionContext::iC_AddOrSubtractOperator(size_t i) {
  return getRuleContext<CypherParser::IC_AddOrSubtractOperatorContext>(i);
}

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

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


size_t CypherParser::OC_AddOrSubtractExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_AddOrSubtractExpression;
}


CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::oC_AddOrSubtractExpression() {
  OC_AddOrSubtractExpressionContext *_localctx = _tracker.createInstance<OC_AddOrSubtractExpressionContext>(_ctx, getState());
  enterRule(_localctx, 280, 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(2483);
    oC_MultiplyDivideModuloExpression();
    setState(2495);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2485);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2484);
          match(CypherParser::SP);
        }
        setState(2487);
        iC_AddOrSubtractOperator();
        setState(2489);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2488);
          match(CypherParser::SP);
        }
        setState(2491);
        oC_MultiplyDivideModuloExpression(); 
      }
      setState(2497);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_AddOrSubtractOperatorContext ------------------------------------------------------------------

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

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


size_t CypherParser::IC_AddOrSubtractOperatorContext::getRuleIndex() const {
  return CypherParser::RuleIC_AddOrSubtractOperator;
}


CypherParser::IC_AddOrSubtractOperatorContext* CypherParser::iC_AddOrSubtractOperator() {
  IC_AddOrSubtractOperatorContext *_localctx = _tracker.createInstance<IC_AddOrSubtractOperatorContext>(_ctx, getState());
  enterRule(_localctx, 282, CypherParser::RuleIC_AddOrSubtractOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2498);
    _la = _input->LA(1);
    if (!(_la == CypherParser::T__19 || _la == CypherParser::MINUS)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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::IC_MultiplyDivideModuloOperatorContext *> CypherParser::OC_MultiplyDivideModuloExpressionContext::iC_MultiplyDivideModuloOperator() {
  return getRuleContexts<CypherParser::IC_MultiplyDivideModuloOperatorContext>();
}

CypherParser::IC_MultiplyDivideModuloOperatorContext* CypherParser::OC_MultiplyDivideModuloExpressionContext::iC_MultiplyDivideModuloOperator(size_t i) {
  return getRuleContext<CypherParser::IC_MultiplyDivideModuloOperatorContext>(i);
}

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

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


size_t CypherParser::OC_MultiplyDivideModuloExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_MultiplyDivideModuloExpression;
}


CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::oC_MultiplyDivideModuloExpression() {
  OC_MultiplyDivideModuloExpressionContext *_localctx = _tracker.createInstance<OC_MultiplyDivideModuloExpressionContext>(_ctx, getState());
  enterRule(_localctx, 284, 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(2500);
    oC_PowerOfExpression();
    setState(2512);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2502);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2501);
          match(CypherParser::SP);
        }
        setState(2504);
        iC_MultiplyDivideModuloOperator();
        setState(2506);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2505);
          match(CypherParser::SP);
        }
        setState(2508);
        oC_PowerOfExpression(); 
      }
      setState(2514);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_MultiplyDivideModuloOperatorContext ------------------------------------------------------------------

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

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


size_t CypherParser::IC_MultiplyDivideModuloOperatorContext::getRuleIndex() const {
  return CypherParser::RuleIC_MultiplyDivideModuloOperator;
}


CypherParser::IC_MultiplyDivideModuloOperatorContext* CypherParser::iC_MultiplyDivideModuloOperator() {
  IC_MultiplyDivideModuloOperatorContext *_localctx = _tracker.createInstance<IC_MultiplyDivideModuloOperatorContext>(_ctx, getState());
  enterRule(_localctx, 286, CypherParser::RuleIC_MultiplyDivideModuloOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2515);
    _la = _input->LA(1);
    if (!(_la == CypherParser::T__20

    || _la == CypherParser::T__21 || _la == CypherParser::STAR)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 288, 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(2517);
    oC_StringListNullOperatorExpression();
    setState(2528);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 412, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2519);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2518);
          match(CypherParser::SP);
        }
        setState(2521);
        match(CypherParser::T__22);
        setState(2523);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2522);
          match(CypherParser::SP);
        }
        setState(2525);
        oC_StringListNullOperatorExpression(); 
      }
      setState(2530);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 412, _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, 290, CypherParser::RuleOC_StringListNullOperatorExpression);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 414, _ctx)) {
    case 1: {
      setState(2532);
      oC_StringOperatorExpression();
      break;
    }

    case 2: {
      setState(2534); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2533);
                oC_ListOperatorExpression();
                break;
              }

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

    case 3: {
      setState(2538);
      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);
}

tree::TerminalNode* CypherParser::OC_ListOperatorExpressionContext::DOTDOT() {
  return getToken(CypherParser::DOTDOT, 0);
}


size_t CypherParser::OC_ListOperatorExpressionContext::getRuleIndex() const {
  return CypherParser::RuleOC_ListOperatorExpression;
}


CypherParser::OC_ListOperatorExpressionContext* CypherParser::oC_ListOperatorExpression() {
  OC_ListOperatorExpressionContext *_localctx = _tracker.createInstance<OC_ListOperatorExpressionContext>(_ctx, getState());
  enterRule(_localctx, 292, CypherParser::RuleOC_ListOperatorExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2560);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 418, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2541);
      match(CypherParser::SP);
      setState(2542);
      match(CypherParser::IN);
      setState(2544);
      _errHandler->sync(this);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2547);
      match(CypherParser::T__6);
      setState(2548);
      oC_Expression();
      setState(2549);
      match(CypherParser::T__7);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2551);
      match(CypherParser::T__6);
      setState(2553);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 65)) & -2296981129019905737) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 129)) & 87878569698120375) != 0)) {
        setState(2552);
        oC_Expression();
      }
      setState(2555);
      _la = _input->LA(1);
      if (!(_la == CypherParser::COLON

      || _la == CypherParser::DOTDOT)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(2557);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 65)) & -2296981129019905737) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 129)) & 87878569698120375) != 0)) {
        setState(2556);
        oC_Expression();
      }
      setState(2559);
      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, 294, 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(2573);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 419, _ctx)) {
    case 1: {
      setState(2562);
      oC_RegularExpression();
      break;
    }

    case 2: {
      setState(2563);
      match(CypherParser::SP);
      setState(2564);
      match(CypherParser::STARTS);
      setState(2565);
      match(CypherParser::SP);
      setState(2566);
      match(CypherParser::WITH);
      break;
    }

    case 3: {
      setState(2567);
      match(CypherParser::SP);
      setState(2568);
      match(CypherParser::ENDS);
      setState(2569);
      match(CypherParser::SP);
      setState(2570);
      match(CypherParser::WITH);
      break;
    }

    case 4: {
      setState(2571);
      match(CypherParser::SP);
      setState(2572);
      match(CypherParser::CONTAINS);
      break;
    }

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2575);
      match(CypherParser::SP);
    }
    setState(2578);
    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, 296, 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(2581);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2580);
      match(CypherParser::SP);
    }
    setState(2583);
    match(CypherParser::T__23);
   
  }
  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, 298, CypherParser::RuleOC_NullOperatorExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2595);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 422, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2585);
      match(CypherParser::SP);
      setState(2586);
      match(CypherParser::IS);
      setState(2587);
      match(CypherParser::SP);
      setState(2588);
      match(CypherParser::NULL_);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2589);
      match(CypherParser::SP);
      setState(2590);
      match(CypherParser::IS);
      setState(2591);
      match(CypherParser::SP);
      setState(2592);
      match(CypherParser::NOT);
      setState(2593);
      match(CypherParser::SP);
      setState(2594);
      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, 300, 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(2603);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::MINUS) {
      setState(2597);
      match(CypherParser::MINUS);
      setState(2599);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2598);
        match(CypherParser::SP);
      }
      setState(2605);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2606);
    oC_PropertyOrLabelsExpression();
    setState(2611);
    _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2607);
        match(CypherParser::SP);
      }
      setState(2610);
      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, 302, 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(2613);
    oC_Atom();
    setState(2620);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 428, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2615);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2614);
          match(CypherParser::SP);
        }
        setState(2617);
        oC_PropertyLookup(); 
      }
      setState(2622);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 428, _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, 304, CypherParser::RuleOC_Atom);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2624);
      oC_Parameter();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2625);
      oC_CaseExpression();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2626);
      oC_ParenthesizedExpression();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2627);
      oC_FunctionInvocation();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2628);
      oC_PathPatterns();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2629);
      oC_ExistCountSubquery();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2630);
      oC_Variable();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2631);
      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, 306, CypherParser::RuleOC_Quantifier);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2635);
          match(CypherParser::SP);
        }
        setState(2638);
        match(CypherParser::T__1);
        setState(2640);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2639);
          match(CypherParser::SP);
        }
        setState(2642);
        oC_FilterExpression();
        setState(2644);
        _errHandler->sync(this);

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

      case CypherParser::ANY: {
        enterOuterAlt(_localctx, 2);
        setState(2648);
        match(CypherParser::ANY);
        setState(2650);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2649);
          match(CypherParser::SP);
        }
        setState(2652);
        match(CypherParser::T__1);
        setState(2654);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2653);
          match(CypherParser::SP);
        }
        setState(2656);
        oC_FilterExpression();
        setState(2658);
        _errHandler->sync(this);

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

      case CypherParser::NONE: {
        enterOuterAlt(_localctx, 3);
        setState(2662);
        match(CypherParser::NONE);
        setState(2664);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2663);
          match(CypherParser::SP);
        }
        setState(2666);
        match(CypherParser::T__1);
        setState(2668);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2667);
          match(CypherParser::SP);
        }
        setState(2670);
        oC_FilterExpression();
        setState(2672);
        _errHandler->sync(this);

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

      case CypherParser::SINGLE: {
        enterOuterAlt(_localctx, 4);
        setState(2676);
        match(CypherParser::SINGLE);
        setState(2678);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2677);
          match(CypherParser::SP);
        }
        setState(2680);
        match(CypherParser::T__1);
        setState(2682);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2681);
          match(CypherParser::SP);
        }
        setState(2684);
        oC_FilterExpression();
        setState(2686);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2685);
          match(CypherParser::SP);
        }
        setState(2688);
        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, 308, CypherParser::RuleOC_FilterExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2692);
    oC_IdInColl();
    setState(2693);
    match(CypherParser::SP);
    setState(2694);
    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, 310, CypherParser::RuleOC_IdInColl);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2696);
    oC_Variable();
    setState(2697);
    match(CypherParser::SP);
    setState(2698);
    match(CypherParser::IN);
    setState(2699);
    match(CypherParser::SP);
    setState(2700);
    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::IC_StructLiteralContext* CypherParser::OC_LiteralContext::iC_StructLiteral() {
  return getRuleContext<CypherParser::IC_StructLiteralContext>(0);
}


size_t CypherParser::OC_LiteralContext::getRuleIndex() const {
  return CypherParser::RuleOC_Literal;
}


CypherParser::OC_LiteralContext* CypherParser::oC_Literal() {
  OC_LiteralContext *_localctx = _tracker.createInstance<OC_LiteralContext>(_ctx, getState());
  enterRule(_localctx, 312, CypherParser::RuleOC_Literal);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2708);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::DecimalInteger:
      case CypherParser::ExponentDecimalReal:
      case CypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(2702);
        oC_NumberLiteral();
        break;
      }

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

      case CypherParser::FALSE:
      case CypherParser::TRUE: {
        enterOuterAlt(_localctx, 3);
        setState(2704);
        oC_BooleanLiteral();
        break;
      }

      case CypherParser::NULL_: {
        enterOuterAlt(_localctx, 4);
        setState(2705);
        match(CypherParser::NULL_);
        break;
      }

      case CypherParser::T__6: {
        enterOuterAlt(_localctx, 5);
        setState(2706);
        oC_ListLiteral();
        break;
      }

      case CypherParser::T__8: {
        enterOuterAlt(_localctx, 6);
        setState(2707);
        iC_StructLiteral();
        break;
      }

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

  return _localctx;
}

//----------------- 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, 314, 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(2710);
    _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::IC_ListEntryContext *> CypherParser::OC_ListLiteralContext::iC_ListEntry() {
  return getRuleContexts<CypherParser::IC_ListEntryContext>();
}

CypherParser::IC_ListEntryContext* CypherParser::OC_ListLiteralContext::iC_ListEntry(size_t i) {
  return getRuleContext<CypherParser::IC_ListEntryContext>(i);
}


size_t CypherParser::OC_ListLiteralContext::getRuleIndex() const {
  return CypherParser::RuleOC_ListLiteral;
}


CypherParser::OC_ListLiteralContext* CypherParser::oC_ListLiteral() {
  OC_ListLiteralContext *_localctx = _tracker.createInstance<OC_ListLiteralContext>(_ctx, getState());
  enterRule(_localctx, 316, 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(2712);
    match(CypherParser::T__6);
    setState(2714);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2296981129019905737) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 87878569698120375) != 0)) {
      setState(2716);
      oC_Expression();
      setState(2718);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2717);
        match(CypherParser::SP);
      }
      setState(2726);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == CypherParser::T__3) {
        setState(2720);
        iC_ListEntry();
        setState(2722);
        _errHandler->sync(this);

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

  return _localctx;
}

//----------------- IC_ListEntryContext ------------------------------------------------------------------

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

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

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


size_t CypherParser::IC_ListEntryContext::getRuleIndex() const {
  return CypherParser::RuleIC_ListEntry;
}


CypherParser::IC_ListEntryContext* CypherParser::iC_ListEntry() {
  IC_ListEntryContext *_localctx = _tracker.createInstance<IC_ListEntryContext>(_ctx, getState());
  enterRule(_localctx, 318, CypherParser::RuleIC_ListEntry);
  size_t _la = 0;

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

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

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 65)) & -2296981129019905737) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 129)) & 87878569698120375) != 0)) {
      setState(2737);
      oC_Expression();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_StructLiteralContext ------------------------------------------------------------------

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

std::vector<CypherParser::IC_StructFieldContext *> CypherParser::IC_StructLiteralContext::iC_StructField() {
  return getRuleContexts<CypherParser::IC_StructFieldContext>();
}

CypherParser::IC_StructFieldContext* CypherParser::IC_StructLiteralContext::iC_StructField(size_t i) {
  return getRuleContext<CypherParser::IC_StructFieldContext>(i);
}

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

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


size_t CypherParser::IC_StructLiteralContext::getRuleIndex() const {
  return CypherParser::RuleIC_StructLiteral;
}


CypherParser::IC_StructLiteralContext* CypherParser::iC_StructLiteral() {
  IC_StructLiteralContext *_localctx = _tracker.createInstance<IC_StructLiteralContext>(_ctx, getState());
  enterRule(_localctx, 320, CypherParser::RuleIC_StructLiteral);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2741);
      match(CypherParser::SP);
    }
    setState(2744);
    iC_StructField();
    setState(2746);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2745);
      match(CypherParser::SP);
    }
    setState(2758);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == CypherParser::T__3) {
      setState(2748);
      match(CypherParser::T__3);
      setState(2750);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2749);
        match(CypherParser::SP);
      }
      setState(2752);
      iC_StructField();
      setState(2754);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2753);
        match(CypherParser::SP);
      }
      setState(2760);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2761);
    match(CypherParser::T__9);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_StructFieldContext ------------------------------------------------------------------

CypherParser::IC_StructFieldContext::IC_StructFieldContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::IC_StructFieldContext::COLON() {
  return getToken(CypherParser::COLON, 0);
}

CypherParser::OC_ExpressionContext* CypherParser::IC_StructFieldContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}

CypherParser::OC_SymbolicNameContext* CypherParser::IC_StructFieldContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* CypherParser::IC_StructFieldContext::StringLiteral() {
  return getToken(CypherParser::StringLiteral, 0);
}

std::vector<tree::TerminalNode *> CypherParser::IC_StructFieldContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::IC_StructFieldContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::IC_StructFieldContext::getRuleIndex() const {
  return CypherParser::RuleIC_StructField;
}


CypherParser::IC_StructFieldContext* CypherParser::iC_StructField() {
  IC_StructFieldContext *_localctx = _tracker.createInstance<IC_StructFieldContext>(_ctx, getState());
  enterRule(_localctx, 322, CypherParser::RuleIC_StructField);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2765);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::PASSWORD:
      case CypherParser::ROLE:
      case CypherParser::MAP:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2763);
        oC_SymbolicName();
        break;
      }

      case CypherParser::StringLiteral: {
        setState(2764);
        match(CypherParser::StringLiteral);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2768);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2767);
      match(CypherParser::SP);
    }
    setState(2770);
    match(CypherParser::COLON);
    setState(2772);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2771);
      match(CypherParser::SP);
    }
    setState(2774);
    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, 324, 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(2776);
    match(CypherParser::T__1);
    setState(2778);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2777);
      match(CypherParser::SP);
    }
    setState(2780);
    oC_Expression();
    setState(2782);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2781);
      match(CypherParser::SP);
    }
    setState(2784);
    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::IC_FunctionParameterContext *> CypherParser::OC_FunctionInvocationContext::iC_FunctionParameter() {
  return getRuleContexts<CypherParser::IC_FunctionParameterContext>();
}

CypherParser::IC_FunctionParameterContext* CypherParser::OC_FunctionInvocationContext::iC_FunctionParameter(size_t i) {
  return getRuleContext<CypherParser::IC_FunctionParameterContext>(i);
}

tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::AS() {
  return getToken(CypherParser::AS, 0);
}

CypherParser::IC_DataTypeContext* CypherParser::OC_FunctionInvocationContext::iC_DataType() {
  return getRuleContext<CypherParser::IC_DataTypeContext>(0);
}

CypherParser::OC_FunctionNameContext* CypherParser::OC_FunctionInvocationContext::oC_FunctionName() {
  return getRuleContext<CypherParser::OC_FunctionNameContext>(0);
}

tree::TerminalNode* CypherParser::OC_FunctionInvocationContext::DISTINCT() {
  return getToken(CypherParser::DISTINCT, 0);
}


size_t CypherParser::OC_FunctionInvocationContext::getRuleIndex() const {
  return CypherParser::RuleOC_FunctionInvocation;
}


CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation() {
  OC_FunctionInvocationContext *_localctx = _tracker.createInstance<OC_FunctionInvocationContext>(_ctx, getState());
  enterRule(_localctx, 326, CypherParser::RuleOC_FunctionInvocation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2863);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 480, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2786);
      match(CypherParser::COUNT);
      setState(2788);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2787);
        match(CypherParser::SP);
      }
      setState(2790);
      match(CypherParser::T__1);
      setState(2792);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2791);
        match(CypherParser::SP);
      }
      setState(2794);
      match(CypherParser::STAR);
      setState(2796);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2795);
        match(CypherParser::SP);
      }
      setState(2798);
      match(CypherParser::T__2);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2799);
      match(CypherParser::CAST);
      setState(2801);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2800);
        match(CypherParser::SP);
      }
      setState(2803);
      match(CypherParser::T__1);
      setState(2805);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2804);
        match(CypherParser::SP);
      }
      setState(2807);
      iC_FunctionParameter();
      setState(2809);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2808);
        match(CypherParser::SP);
      }
      setState(2821);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case CypherParser::AS: {
          setState(2811);
          match(CypherParser::AS);
          setState(2813);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2812);
            match(CypherParser::SP);
          }
          setState(2815);
          iC_DataType(0);
          break;
        }

        case CypherParser::T__3: {
          setState(2816);
          match(CypherParser::T__3);
          setState(2818);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2817);
            match(CypherParser::SP);
          }
          setState(2820);
          iC_FunctionParameter();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(2824);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2823);
        match(CypherParser::SP);
      }
      setState(2826);
      match(CypherParser::T__2);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2828);
      oC_FunctionName();
      setState(2830);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2829);
        match(CypherParser::SP);
      }
      setState(2832);
      match(CypherParser::T__1);
      setState(2834);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2833);
        match(CypherParser::SP);
      }
      setState(2840);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::DISTINCT) {
        setState(2836);
        match(CypherParser::DISTINCT);
        setState(2838);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2837);
          match(CypherParser::SP);
        }
      }
      setState(2859);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -2320550076713270652) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 65)) & -2296981129019905737) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 129)) & 87878569698120375) != 0)) {
        setState(2842);
        iC_FunctionParameter();
        setState(2844);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2843);
          match(CypherParser::SP);
        }
        setState(2856);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__3) {
          setState(2846);
          match(CypherParser::T__3);
          setState(2848);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2847);
            match(CypherParser::SP);
          }
          setState(2850);
          iC_FunctionParameter();
          setState(2852);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2851);
            match(CypherParser::SP);
          }
          setState(2858);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(2861);
      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, 328, CypherParser::RuleOC_FunctionName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2865);
    oC_SymbolicName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_FunctionParameterContext ------------------------------------------------------------------

CypherParser::IC_FunctionParameterContext::IC_FunctionParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::OC_ExpressionContext* CypherParser::IC_FunctionParameterContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}

CypherParser::OC_SymbolicNameContext* CypherParser::IC_FunctionParameterContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}

tree::TerminalNode* CypherParser::IC_FunctionParameterContext::COLON() {
  return getToken(CypherParser::COLON, 0);
}

std::vector<tree::TerminalNode *> CypherParser::IC_FunctionParameterContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::IC_FunctionParameterContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}

CypherParser::IC_LambdaParameterContext* CypherParser::IC_FunctionParameterContext::iC_LambdaParameter() {
  return getRuleContext<CypherParser::IC_LambdaParameterContext>(0);
}


size_t CypherParser::IC_FunctionParameterContext::getRuleIndex() const {
  return CypherParser::RuleIC_FunctionParameter;
}


CypherParser::IC_FunctionParameterContext* CypherParser::iC_FunctionParameter() {
  IC_FunctionParameterContext *_localctx = _tracker.createInstance<IC_FunctionParameterContext>(_ctx, getState());
  enterRule(_localctx, 330, CypherParser::RuleIC_FunctionParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2880);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 484, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2876);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 483, _ctx)) {
      case 1: {
        setState(2867);
        oC_SymbolicName();
        setState(2869);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2868);
          match(CypherParser::SP);
        }
        setState(2871);
        match(CypherParser::COLON);
        setState(2872);
        match(CypherParser::T__5);
        setState(2874);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2873);
          match(CypherParser::SP);
        }
        break;
      }

      default:
        break;
      }
      setState(2878);
      oC_Expression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2879);
      iC_LambdaParameter();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_LambdaParameterContext ------------------------------------------------------------------

CypherParser::IC_LambdaParameterContext::IC_LambdaParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

CypherParser::IC_LambdaVarsContext* CypherParser::IC_LambdaParameterContext::iC_LambdaVars() {
  return getRuleContext<CypherParser::IC_LambdaVarsContext>(0);
}

tree::TerminalNode* CypherParser::IC_LambdaParameterContext::MINUS() {
  return getToken(CypherParser::MINUS, 0);
}

CypherParser::OC_ExpressionContext* CypherParser::IC_LambdaParameterContext::oC_Expression() {
  return getRuleContext<CypherParser::OC_ExpressionContext>(0);
}

std::vector<tree::TerminalNode *> CypherParser::IC_LambdaParameterContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::IC_LambdaParameterContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::IC_LambdaParameterContext::getRuleIndex() const {
  return CypherParser::RuleIC_LambdaParameter;
}


CypherParser::IC_LambdaParameterContext* CypherParser::iC_LambdaParameter() {
  IC_LambdaParameterContext *_localctx = _tracker.createInstance<IC_LambdaParameterContext>(_ctx, getState());
  enterRule(_localctx, 332, CypherParser::RuleIC_LambdaParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2882);
    iC_LambdaVars();
    setState(2884);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2883);
      match(CypherParser::SP);
    }
    setState(2886);
    match(CypherParser::MINUS);
    setState(2887);
    match(CypherParser::T__14);
    setState(2889);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2888);
      match(CypherParser::SP);
    }
    setState(2891);
    oC_Expression();
    setState(2893);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 487, _ctx)) {
    case 1: {
      setState(2892);
      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;
}

//----------------- IC_LambdaVarsContext ------------------------------------------------------------------

CypherParser::IC_LambdaVarsContext::IC_LambdaVarsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<CypherParser::OC_SymbolicNameContext *> CypherParser::IC_LambdaVarsContext::oC_SymbolicName() {
  return getRuleContexts<CypherParser::OC_SymbolicNameContext>();
}

CypherParser::OC_SymbolicNameContext* CypherParser::IC_LambdaVarsContext::oC_SymbolicName(size_t i) {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(i);
}

std::vector<tree::TerminalNode *> CypherParser::IC_LambdaVarsContext::SP() {
  return getTokens(CypherParser::SP);
}

tree::TerminalNode* CypherParser::IC_LambdaVarsContext::SP(size_t i) {
  return getToken(CypherParser::SP, i);
}


size_t CypherParser::IC_LambdaVarsContext::getRuleIndex() const {
  return CypherParser::RuleIC_LambdaVars;
}


CypherParser::IC_LambdaVarsContext* CypherParser::iC_LambdaVars() {
  IC_LambdaVarsContext *_localctx = _tracker.createInstance<IC_LambdaVarsContext>(_ctx, getState());
  enterRule(_localctx, 334, CypherParser::RuleIC_LambdaVars);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2919);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::PASSWORD:
      case CypherParser::ROLE:
      case CypherParser::MAP:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(2895);
        oC_SymbolicName();
        break;
      }

      case CypherParser::T__1: {
        enterOuterAlt(_localctx, 2);
        setState(2896);
        match(CypherParser::T__1);
        setState(2898);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2897);
          match(CypherParser::SP);
        }
        setState(2900);
        oC_SymbolicName();
        setState(2902);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == CypherParser::SP) {
          setState(2901);
          match(CypherParser::SP);
        }
        setState(2914);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == CypherParser::T__3) {
          setState(2904);
          match(CypherParser::T__3);
          setState(2906);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2905);
            match(CypherParser::SP);
          }
          setState(2908);
          oC_SymbolicName();
          setState(2910);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == CypherParser::SP) {
            setState(2909);
            match(CypherParser::SP);
          }
          setState(2916);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2917);
        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, 336, 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(2921);
    oC_NodePattern();
    setState(2926); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2923);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == CypherParser::SP) {
                setState(2922);
                match(CypherParser::SP);
              }
              setState(2925);
              oC_PatternElementChain();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(2928); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 495, _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::IC_HintContext* CypherParser::OC_ExistCountSubqueryContext::iC_Hint() {
  return getRuleContext<CypherParser::IC_HintContext>(0);
}


size_t CypherParser::OC_ExistCountSubqueryContext::getRuleIndex() const {
  return CypherParser::RuleOC_ExistCountSubquery;
}


CypherParser::OC_ExistCountSubqueryContext* CypherParser::oC_ExistCountSubquery() {
  OC_ExistCountSubqueryContext *_localctx = _tracker.createInstance<OC_ExistCountSubqueryContext>(_ctx, getState());
  enterRule(_localctx, 338, 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(2930);
    _la = _input->LA(1);
    if (!(_la == CypherParser::COUNT

    || _la == CypherParser::EXISTS)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2932);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2931);
      match(CypherParser::SP);
    }
    setState(2934);
    match(CypherParser::T__8);
    setState(2936);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2935);
      match(CypherParser::SP);
    }
    setState(2938);
    match(CypherParser::MATCH);
    setState(2940);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2939);
      match(CypherParser::SP);
    }
    setState(2942);
    oC_Pattern();
    setState(2947);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 500, _ctx)) {
    case 1: {
      setState(2944);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2943);
        match(CypherParser::SP);
      }
      setState(2946);
      oC_Where();
      break;
    }

    default:
      break;
    }
    setState(2953);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 502, _ctx)) {
    case 1: {
      setState(2950);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2949);
        match(CypherParser::SP);
      }
      setState(2952);
      iC_Hint();
      break;
    }

    default:
      break;
    }
    setState(2956);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2955);
      match(CypherParser::SP);
    }
    setState(2958);
    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, 340, 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(2960);
    match(CypherParser::T__4);
    setState(2962);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(2961);
      match(CypherParser::SP);
    }
    setState(2966);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::PASSWORD:
      case CypherParser::ROLE:
      case CypherParser::MAP:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(2964);
        oC_PropertyKeyName();
        break;
      }

      case CypherParser::STAR: {
        setState(2965);
        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, 342, 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(2990);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 511, _ctx)) {
    case 1: {
      setState(2968);
      match(CypherParser::CASE);
      setState(2973); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2970);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(2969);
                  match(CypherParser::SP);
                }
                setState(2972);
                oC_CaseAlternative();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(2975); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 507, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 2: {
      setState(2977);
      match(CypherParser::CASE);
      setState(2979);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2978);
        match(CypherParser::SP);
      }
      setState(2981);
      oC_Expression();
      setState(2986); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(2983);
                _errHandler->sync(this);

                _la = _input->LA(1);
                if (_la == CypherParser::SP) {
                  setState(2982);
                  match(CypherParser::SP);
                }
                setState(2985);
                oC_CaseAlternative();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(2988); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 510, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    default:
      break;
    }
    setState(3000);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 514, _ctx)) {
    case 1: {
      setState(2993);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2992);
        match(CypherParser::SP);
      }
      setState(2995);
      match(CypherParser::ELSE);
      setState(2997);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == CypherParser::SP) {
        setState(2996);
        match(CypherParser::SP);
      }
      setState(2999);
      oC_Expression();
      break;
    }

    default:
      break;
    }
    setState(3003);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(3002);
      match(CypherParser::SP);
    }
    setState(3005);
    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, 344, 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(3007);
    match(CypherParser::WHEN);
    setState(3009);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(3008);
      match(CypherParser::SP);
    }
    setState(3011);
    oC_Expression();
    setState(3013);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(3012);
      match(CypherParser::SP);
    }
    setState(3015);
    match(CypherParser::THEN);
    setState(3017);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(3016);
      match(CypherParser::SP);
    }
    setState(3019);
    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, 346, CypherParser::RuleOC_Variable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3021);
    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, 348, CypherParser::RuleOC_NumberLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3025);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ExponentDecimalReal:
      case CypherParser::RegularDecimalReal: {
        enterOuterAlt(_localctx, 1);
        setState(3023);
        oC_DoubleLiteral();
        break;
      }

      case CypherParser::DecimalInteger: {
        enterOuterAlt(_localctx, 2);
        setState(3024);
        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, 350, CypherParser::RuleOC_Parameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3027);
    match(CypherParser::T__24);
    setState(3030);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::PASSWORD:
      case CypherParser::ROLE:
      case CypherParser::MAP:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP:
      case CypherParser::HexLetter:
      case CypherParser::UnescapedSymbolicName:
      case CypherParser::EscapedSymbolicName: {
        setState(3028);
        oC_SymbolicName();
        break;
      }

      case CypherParser::DecimalInteger: {
        setState(3029);
        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, 352, 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(3032);
    oC_Atom();
    setState(3034);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == CypherParser::SP) {
      setState(3033);
      match(CypherParser::SP);
    }
    setState(3036);
    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_SymbolicNameContext* CypherParser::OC_PropertyKeyNameContext::oC_SymbolicName() {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(0);
}


size_t CypherParser::OC_PropertyKeyNameContext::getRuleIndex() const {
  return CypherParser::RuleOC_PropertyKeyName;
}


CypherParser::OC_PropertyKeyNameContext* CypherParser::oC_PropertyKeyName() {
  OC_PropertyKeyNameContext *_localctx = _tracker.createInstance<OC_PropertyKeyNameContext>(_ctx, getState());
  enterRule(_localctx, 354, CypherParser::RuleOC_PropertyKeyName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3038);
    oC_SymbolicName();
   
  }
  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, 356, CypherParser::RuleOC_IntegerLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3040);
    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, 358, 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(3042);
    _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) {
}

std::vector<CypherParser::OC_SymbolicNameContext *> CypherParser::OC_SchemaNameContext::oC_SymbolicName() {
  return getRuleContexts<CypherParser::OC_SymbolicNameContext>();
}

CypherParser::OC_SymbolicNameContext* CypherParser::OC_SchemaNameContext::oC_SymbolicName(size_t i) {
  return getRuleContext<CypherParser::OC_SymbolicNameContext>(i);
}


size_t CypherParser::OC_SchemaNameContext::getRuleIndex() const {
  return CypherParser::RuleOC_SchemaName;
}


CypherParser::OC_SchemaNameContext* CypherParser::oC_SchemaName() {
  OC_SchemaNameContext *_localctx = _tracker.createInstance<OC_SchemaNameContext>(_ctx, getState());
  enterRule(_localctx, 360, CypherParser::RuleOC_SchemaName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3044);
    oC_SymbolicName();
    setState(3047);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 522, _ctx)) {
    case 1: {
      setState(3045);
      match(CypherParser::T__4);
      setState(3046);
      oC_SymbolicName();
      break;
    }

    default:
      break;
    }
   
  }
  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::IC_NonReservedKeywordsContext* CypherParser::OC_SymbolicNameContext::iC_NonReservedKeywords() {
  return getRuleContext<CypherParser::IC_NonReservedKeywordsContext>(0);
}


size_t CypherParser::OC_SymbolicNameContext::getRuleIndex() const {
  return CypherParser::RuleOC_SymbolicName;
}


CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() {
  OC_SymbolicNameContext *_localctx = _tracker.createInstance<OC_SymbolicNameContext>(_ctx, getState());
  enterRule(_localctx, 362, CypherParser::RuleOC_SymbolicName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3054);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case CypherParser::UnescapedSymbolicName: {
        enterOuterAlt(_localctx, 1);
        setState(3049);
        match(CypherParser::UnescapedSymbolicName);
        break;
      }

      case CypherParser::EscapedSymbolicName: {
        enterOuterAlt(_localctx, 2);
        setState(3050);
        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(3052);
        match(CypherParser::HexLetter);
        break;
      }

      case CypherParser::ADD:
      case CypherParser::ALTER:
      case CypherParser::AS:
      case CypherParser::ATTACH:
      case CypherParser::BEGIN:
      case CypherParser::BY:
      case CypherParser::CALL:
      case CypherParser::CHECKPOINT:
      case CypherParser::COMMENT:
      case CypherParser::COMMIT:
      case CypherParser::CONTAINS:
      case CypherParser::COPY:
      case CypherParser::COUNT:
      case CypherParser::CYCLE:
      case CypherParser::DATABASE:
      case CypherParser::DELETE:
      case CypherParser::DETACH:
      case CypherParser::DROP:
      case CypherParser::EXPLAIN:
      case CypherParser::EXPORT:
      case CypherParser::EXTENSION:
      case CypherParser::FROM:
      case CypherParser::FORCE:
      case CypherParser::GRAPH:
      case CypherParser::IMPORT:
      case CypherParser::IF:
      case CypherParser::INCREMENT:
      case CypherParser::IS:
      case CypherParser::KEY:
      case CypherParser::LIMIT:
      case CypherParser::LOAD:
      case CypherParser::LOGICAL:
      case CypherParser::MATCH:
      case CypherParser::MAXVALUE:
      case CypherParser::MERGE:
      case CypherParser::MINVALUE:
      case CypherParser::NO:
      case CypherParser::NODE:
      case CypherParser::PROJECT:
      case CypherParser::READ:
      case CypherParser::REL:
      case CypherParser::RENAME:
      case CypherParser::RETURN:
      case CypherParser::ROLLBACK:
      case CypherParser::SEQUENCE:
      case CypherParser::SET:
      case CypherParser::START:
      case CypherParser::STRUCT:
      case CypherParser::TO:
      case CypherParser::TRANSACTION:
      case CypherParser::TYPE:
      case CypherParser::UNINSTALL:
      case CypherParser::UPDATE:
      case CypherParser::USE:
      case CypherParser::WRITE:
      case CypherParser::YIELD:
      case CypherParser::USER:
      case CypherParser::PASSWORD:
      case CypherParser::ROLE:
      case CypherParser::MAP:
      case CypherParser::DECIMAL:
      case CypherParser::L_SKIP: {
        enterOuterAlt(_localctx, 4);
        setState(3053);
        iC_NonReservedKeywords();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IC_NonReservedKeywordsContext ------------------------------------------------------------------

CypherParser::IC_NonReservedKeywordsContext::IC_NonReservedKeywordsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COMMENT() {
  return getToken(CypherParser::COMMENT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ADD() {
  return getToken(CypherParser::ADD, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ALTER() {
  return getToken(CypherParser::ALTER, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::AS() {
  return getToken(CypherParser::AS, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ATTACH() {
  return getToken(CypherParser::ATTACH, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::BEGIN() {
  return getToken(CypherParser::BEGIN, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::BY() {
  return getToken(CypherParser::BY, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CALL() {
  return getToken(CypherParser::CALL, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CHECKPOINT() {
  return getToken(CypherParser::CHECKPOINT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COMMIT() {
  return getToken(CypherParser::COMMIT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CONTAINS() {
  return getToken(CypherParser::CONTAINS, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COPY() {
  return getToken(CypherParser::COPY, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::COUNT() {
  return getToken(CypherParser::COUNT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::CYCLE() {
  return getToken(CypherParser::CYCLE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DATABASE() {
  return getToken(CypherParser::DATABASE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DECIMAL() {
  return getToken(CypherParser::DECIMAL, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DELETE() {
  return getToken(CypherParser::DELETE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DETACH() {
  return getToken(CypherParser::DETACH, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::DROP() {
  return getToken(CypherParser::DROP, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::EXPLAIN() {
  return getToken(CypherParser::EXPLAIN, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::EXPORT() {
  return getToken(CypherParser::EXPORT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::EXTENSION() {
  return getToken(CypherParser::EXTENSION, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::FORCE() {
  return getToken(CypherParser::FORCE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::GRAPH() {
  return getToken(CypherParser::GRAPH, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::IF() {
  return getToken(CypherParser::IF, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::IS() {
  return getToken(CypherParser::IS, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::IMPORT() {
  return getToken(CypherParser::IMPORT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::INCREMENT() {
  return getToken(CypherParser::INCREMENT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::KEY() {
  return getToken(CypherParser::KEY, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::LOAD() {
  return getToken(CypherParser::LOAD, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::LOGICAL() {
  return getToken(CypherParser::LOGICAL, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MATCH() {
  return getToken(CypherParser::MATCH, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MAXVALUE() {
  return getToken(CypherParser::MAXVALUE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MERGE() {
  return getToken(CypherParser::MERGE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MINVALUE() {
  return getToken(CypherParser::MINVALUE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::NO() {
  return getToken(CypherParser::NO, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::NODE() {
  return getToken(CypherParser::NODE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::PROJECT() {
  return getToken(CypherParser::PROJECT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::READ() {
  return getToken(CypherParser::READ, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::REL() {
  return getToken(CypherParser::REL, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::RENAME() {
  return getToken(CypherParser::RENAME, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::RETURN() {
  return getToken(CypherParser::RETURN, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ROLLBACK() {
  return getToken(CypherParser::ROLLBACK, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::ROLE() {
  return getToken(CypherParser::ROLE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::SEQUENCE() {
  return getToken(CypherParser::SEQUENCE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::SET() {
  return getToken(CypherParser::SET, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::START() {
  return getToken(CypherParser::START, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::STRUCT() {
  return getToken(CypherParser::STRUCT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::L_SKIP() {
  return getToken(CypherParser::L_SKIP, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::LIMIT() {
  return getToken(CypherParser::LIMIT, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::TRANSACTION() {
  return getToken(CypherParser::TRANSACTION, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::TYPE() {
  return getToken(CypherParser::TYPE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::USE() {
  return getToken(CypherParser::USE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::UNINSTALL() {
  return getToken(CypherParser::UNINSTALL, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::UPDATE() {
  return getToken(CypherParser::UPDATE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::WRITE() {
  return getToken(CypherParser::WRITE, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::FROM() {
  return getToken(CypherParser::FROM, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::TO() {
  return getToken(CypherParser::TO, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::YIELD() {
  return getToken(CypherParser::YIELD, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::USER() {
  return getToken(CypherParser::USER, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::PASSWORD() {
  return getToken(CypherParser::PASSWORD, 0);
}

tree::TerminalNode* CypherParser::IC_NonReservedKeywordsContext::MAP() {
  return getToken(CypherParser::MAP, 0);
}


size_t CypherParser::IC_NonReservedKeywordsContext::getRuleIndex() const {
  return CypherParser::RuleIC_NonReservedKeywords;
}


CypherParser::IC_NonReservedKeywordsContext* CypherParser::iC_NonReservedKeywords() {
  IC_NonReservedKeywordsContext *_localctx = _tracker.createInstance<IC_NonReservedKeywordsContext>(_ctx, getState());
  enterRule(_localctx, 364, CypherParser::RuleIC_NonReservedKeywords);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3056);
    _la = _input->LA(1);
    if (!(((((_la - 47) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 47)) & -1201032351101114475) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 111)) & 26890641172561933) != 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, 366, 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(3058);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1006641152) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 368, 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(3060);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 16106160128) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- 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, 370, 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(3062);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 35167192219648) != 0) || _la == CypherParser::MINUS)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

bool CypherParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 64: return iC_DataTypeSempred(antlrcpp::downCast<IC_DataTypeContext *>(context), predicateIndex);
    case 91: return iC_JoinNodeSempred(antlrcpp::downCast<IC_JoinNodeContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool CypherParser::iC_DataTypeSempred(IC_DataTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 5);

  default:
    break;
  }
  return true;
}

bool CypherParser::iC_JoinNodeSempred(IC_JoinNodeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 1: return precpred(_ctx, 4);
    case 2: return precpred(_ctx, 3);

  default:
    break;
  }
  return true;
}

void CypherParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  cypherParserInitialize();
#else
  ::antlr4::internal::call_once(cypherParserOnceFlag, cypherParserInitialize);
#endif
}
