diff --git a/extension/duckdb/test/test_files/external_table.test b/extension/duckdb/test/test_files/external_table.test new file mode 100644 index 00000000000..602e1b7d10e --- /dev/null +++ b/extension/duckdb/test/test_files/external_table.test @@ -0,0 +1,60 @@ +-DATASET CSV empty + +-- + +-CASE ExternalDuckDBTable + +-STATEMENT load extension "${KUZU_ROOT_DIRECTORY}/extension/duckdb/build/libduckdb.kuzu_extension" +---- ok +-STATEMENT ATTACH '${KUZU_ROOT_DIRECTORY}/dataset/databases/duckdb_database/tinysnb.db' as tinysnb (dbtype duckdb, skip_unsupported_table = true); +---- 1 +Attached database successfully. +-STATEMENT BEGIN TRANSACTION; +---- ok +-STATEMENT CREATE EXTERNAL NODE TABLE duck_person AS tinysnb.person (PRIMARY KEY (ID)); +---- ok +-STATEMENT COMMIT; +---- ok +-RELOADDB +-STATEMENT CALL SHOW_TABLES() RETURN *; +---- 1 +duck_person|EXTERNAL_NODE|local(kuzu)| +-STATEMENT BEGIN TRANSACTION; +---- ok +-STATEMENT ALTER TABLE duck_person RENAME TO d_person; +---- ok +-STATEMENT COMMIT; +---- ok +-RELOADDB +-STATEMENT CALL SHOW_TABLES() RETURN *; +---- 1 +d_person|EXTERNAL_NODE|local(kuzu)| +-STATEMENT BEGIN TRANSACTION; +---- ok +-STATEMENT DROP TABLE d_person; +---- ok +-STATEMENT COMMIT; +---- ok +-RELOADDB +-STATEMENT CALL SHOW_TABLES() RETURN *; +---- 0 +-STATEMENT load extension "${KUZU_ROOT_DIRECTORY}/extension/duckdb/build/libduckdb.kuzu_extension" +---- ok +-STATEMENT ATTACH '${KUZU_ROOT_DIRECTORY}/dataset/databases/duckdb_database/tinysnb.db' as tinysnb (dbtype duckdb, skip_unsupported_table = true); +---- 1 +Attached database successfully. +-STATEMENT CREATE EXTERNAL NODE TABLE duck_person AS tinysnb.person (PRIMARY KEY (ID)); +---- 1 +Table duck_person has been created. +-STATEMENT COPY duck_person FROM (LOAD FROM tinysnb.person RETURN ID); +---- ok +-STATEMENT MATCH (a:duck_person) RETURN a.ID, a.fName; +---- 8 +0|Alice +2|Bob +3|Carol +5|Dan +7|Elizabeth +8|Farooq +9|Greg +10|Hubert Blaine Wolfeschlegelsteinhausenbergerdorff diff --git a/scripts/antlr4/Cypher.g4 b/scripts/antlr4/Cypher.g4 index f9594764849..4da1f4de902 100644 --- a/scripts/antlr4/Cypher.g4 +++ b/scripts/antlr4/Cypher.g4 @@ -94,6 +94,8 @@ EXPORT : ( 'E' | 'e' ) ( 'X' | 'x' ) ( 'P' | 'p' ) ( 'O' | 'o' ) ( 'R' | 'r' ) ( EXTENSION : ( 'E' | 'e' ) ( 'X' | 'x' ) ( 'T' | 't' ) ( 'E' | 'e' ) ( 'N' | 'n' ) ( 'S' | 's' ) ( 'I' | 'i' ) ( 'O' | 'o' ) ( 'N' | 'n' ) ; +EXTERNAL : ( 'E' | 'e' ) ( 'X' | 'x' ) ( 'T' | 't' ) ( 'E' | 'e' ) ( 'R' | 'r' ) ( 'N' | 'n' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ; + FALSE : ( 'F' | 'f' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ( 'S' | 's' ) ( 'E' | 'e' ) ; FROM : ( 'F' | 'f' ) ( 'R' | 'r' ) ( 'O' | 'o' ) ( 'M' | 'm' ) ; @@ -231,6 +233,7 @@ oC_Cypher oC_Statement : oC_Query | kU_CreateNodeTable + | kU_CreateExternalNodeTable | kU_CreateRelTable | kU_CreateRelTableGroup | kU_CreateRdfGraph @@ -318,10 +321,13 @@ kU_IfNotExists : IF SP NOT SP EXISTS ; kU_CreateNodeTable - : CREATE SP NODE SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_CreateNodeConstraint ) SP? ')' ; + : CREATE SP NODE SP TABLE SP ( kU_IfNotExists SP )? oC_SchemaName SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_PrimaryKey ) SP? ')' ; + +kU_CreateExternalNodeTable + : CREATE SP EXTERNAL SP NODE SP TABLE SP oC_SchemaName SP AS SP oC_SchemaName kU_TableLookup SP? '(' SP? kU_PrimaryKey SP? ')' ; kU_CreateRelTable - : CREATE SP REL SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName SP? '(' SP? kU_RelTableConnection SP? ( ',' SP? kU_PropertyDefinitions SP? )? ( ',' SP? oC_SymbolicName SP? )? ')' ; + : CREATE SP REL SP TABLE SP ( kU_IfNotExists SP )? oC_SchemaName SP? '(' SP? kU_RelTableConnection SP? ( ',' SP? kU_PropertyDefinitions SP? )? ( ',' SP? oC_SymbolicName SP? )? ')' ; kU_CreateRelTableGroup : CREATE SP REL SP TABLE SP GROUP SP (kU_IfNotExists SP)? oC_SchemaName SP? '(' SP? kU_RelTableConnection ( SP? ',' SP? kU_RelTableConnection )+ SP? ( ',' SP? kU_PropertyDefinitions SP? )? ( ',' SP? oC_SymbolicName SP? )? ')' ; @@ -330,10 +336,10 @@ kU_RelTableConnection : FROM SP oC_SchemaName SP TO SP oC_SchemaName ; kU_CreateRdfGraph - : CREATE SP RDFGRAPH SP (kU_IfNotExists SP)? oC_SchemaName ; + : CREATE SP RDFGRAPH SP ( kU_IfNotExists SP )? oC_SchemaName ; kU_CreateSequence - : CREATE SP SEQUENCE SP (kU_IfNotExists SP)? oC_SchemaName (SP kU_SequenceOptions)* ; + : CREATE SP SEQUENCE SP ( kU_IfNotExists SP )? oC_SchemaName ( SP kU_SequenceOptions )* ; kU_CreateType : CREATE SP TYPE SP oC_SchemaName SP AS SP kU_DataType SP? ; @@ -393,7 +399,7 @@ kU_PropertyDefinitions : kU_PropertyDefinition ( SP? ',' SP? kU_PropertyDefiniti kU_PropertyDefinition : kU_ColumnDefinition ( SP kU_Default )? ; -kU_CreateNodeConstraint : PRIMARY SP KEY SP? '(' SP? oC_PropertyKeyName SP? ')' ; +kU_PrimaryKey : PRIMARY SP KEY SP? '(' SP? oC_PropertyKeyName SP? ')' ; DECIMAL: ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'C' | 'c' ) ( 'I' | 'i' ) ( 'M' | 'm' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ; @@ -808,6 +814,9 @@ kU_CountSubquery oC_PropertyLookup : '.' SP? ( oC_PropertyKeyName | STAR ) ; +kU_TableLookup + : '.' SP? oC_SchemaName ; + oC_CaseExpression : ( ( CASE ( SP? oC_CaseAlternative )+ ) | ( CASE SP? oC_Expression ( SP? oC_CaseAlternative )+ ) ) ( SP? ELSE SP? oC_Expression )? SP? END ; @@ -954,10 +963,6 @@ kU_NonReservedKeywords | TYPE | USE | WRITE - | SINGLE - | NONE - | ANY - | ALL ; UnescapedSymbolicName diff --git a/scripts/antlr4/hash.md5 b/scripts/antlr4/hash.md5 index 114eb9bf291..4a55e2cb6c4 100644 --- a/scripts/antlr4/hash.md5 +++ b/scripts/antlr4/hash.md5 @@ -1 +1 @@ -675c2985175bbbf23811cbc12a11870e +2e49cc9ece0a0f04e6b8518c18f148fc diff --git a/src/antlr4/Cypher.g4 b/src/antlr4/Cypher.g4 index f908d1567ef..073d099ed8a 100644 --- a/src/antlr4/Cypher.g4 +++ b/src/antlr4/Cypher.g4 @@ -8,6 +8,7 @@ oC_Cypher oC_Statement : oC_Query | kU_CreateNodeTable + | kU_CreateExternalNodeTable | kU_CreateRelTable | kU_CreateRelTableGroup | kU_CreateRdfGraph @@ -95,10 +96,13 @@ kU_IfNotExists : IF SP NOT SP EXISTS ; kU_CreateNodeTable - : CREATE SP NODE SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_CreateNodeConstraint ) SP? ')' ; + : CREATE SP NODE SP TABLE SP ( kU_IfNotExists SP )? oC_SchemaName SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_PrimaryKey ) SP? ')' ; + +kU_CreateExternalNodeTable + : CREATE SP EXTERNAL SP NODE SP TABLE SP oC_SchemaName SP AS SP oC_SchemaName kU_TableLookup SP? '(' SP? kU_PrimaryKey SP? ')' ; kU_CreateRelTable - : CREATE SP REL SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName SP? '(' SP? kU_RelTableConnection SP? ( ',' SP? kU_PropertyDefinitions SP? )? ( ',' SP? oC_SymbolicName SP? )? ')' ; + : CREATE SP REL SP TABLE SP ( kU_IfNotExists SP )? oC_SchemaName SP? '(' SP? kU_RelTableConnection SP? ( ',' SP? kU_PropertyDefinitions SP? )? ( ',' SP? oC_SymbolicName SP? )? ')' ; kU_CreateRelTableGroup : CREATE SP REL SP TABLE SP GROUP SP (kU_IfNotExists SP)? oC_SchemaName SP? '(' SP? kU_RelTableConnection ( SP? ',' SP? kU_RelTableConnection )+ SP? ( ',' SP? kU_PropertyDefinitions SP? )? ( ',' SP? oC_SymbolicName SP? )? ')' ; @@ -107,10 +111,10 @@ kU_RelTableConnection : FROM SP oC_SchemaName SP TO SP oC_SchemaName ; kU_CreateRdfGraph - : CREATE SP RDFGRAPH SP (kU_IfNotExists SP)? oC_SchemaName ; + : CREATE SP RDFGRAPH SP ( kU_IfNotExists SP )? oC_SchemaName ; kU_CreateSequence - : CREATE SP SEQUENCE SP (kU_IfNotExists SP)? oC_SchemaName (SP kU_SequenceOptions)* ; + : CREATE SP SEQUENCE SP ( kU_IfNotExists SP )? oC_SchemaName ( SP kU_SequenceOptions )* ; kU_CreateType : CREATE SP TYPE SP oC_SchemaName SP AS SP kU_DataType SP? ; @@ -170,7 +174,7 @@ kU_PropertyDefinitions : kU_PropertyDefinition ( SP? ',' SP? kU_PropertyDefiniti kU_PropertyDefinition : kU_ColumnDefinition ( SP kU_Default )? ; -kU_CreateNodeConstraint : PRIMARY SP KEY SP? '(' SP? oC_PropertyKeyName SP? ')' ; +kU_PrimaryKey : PRIMARY SP KEY SP? '(' SP? oC_PropertyKeyName SP? ')' ; DECIMAL: ( 'D' | 'd' ) ( 'E' | 'e' ) ( 'C' | 'c' ) ( 'I' | 'i' ) ( 'M' | 'm' ) ( 'A' | 'a' ) ( 'L' | 'l' ) ; @@ -585,6 +589,9 @@ kU_CountSubquery oC_PropertyLookup : '.' SP? ( oC_PropertyKeyName | STAR ) ; +kU_TableLookup + : '.' SP? oC_SchemaName ; + oC_CaseExpression : ( ( CASE ( SP? oC_CaseAlternative )+ ) | ( CASE SP? oC_Expression ( SP? oC_CaseAlternative )+ ) ) ( SP? ELSE SP? oC_Expression )? SP? END ; diff --git a/src/antlr4/keywords.txt b/src/antlr4/keywords.txt index e51d6baeba8..121d7cb14f3 100644 --- a/src/antlr4/keywords.txt +++ b/src/antlr4/keywords.txt @@ -38,6 +38,7 @@ EXISTS EXPLAIN EXPORT EXTENSION +EXTERNAL FALSE FROM GLOB diff --git a/src/binder/bind/CMakeLists.txt b/src/binder/bind/CMakeLists.txt index 7bd2e3352cc..cc881fa9733 100644 --- a/src/binder/bind/CMakeLists.txt +++ b/src/binder/bind/CMakeLists.txt @@ -20,6 +20,7 @@ add_library( bind_transaction.cpp bind_updating_clause.cpp bind_extension.cpp + bind_external.cpp bind_export_database.cpp bind_import_database.cpp bind_use_database.cpp) diff --git a/src/binder/bind/bind_ddl.cpp b/src/binder/bind/bind_ddl.cpp index 2b2ec18e3a0..95294be09bd 100644 --- a/src/binder/bind/bind_ddl.cpp +++ b/src/binder/bind/bind_ddl.cpp @@ -107,11 +107,14 @@ static void validatePrimaryKey(const std::string& pkColName, } } -BoundCreateTableInfo Binder::bindCreateTableInfo(const parser::CreateTableInfo* info) { - switch (info->tableType) { +BoundCreateTableInfo Binder::bindCreateTableInfo(const parser::CreateTableInfo& info) { + switch (info.tableType) { case TableType::NODE: { return bindCreateNodeTableInfo(info); } + case TableType::EXTERNAL_NODE: { + return bindCreateExternalNodeTableInfo(info); + } case TableType::REL: { return bindCreateRelTableInfo(info); } @@ -127,24 +130,61 @@ BoundCreateTableInfo Binder::bindCreateTableInfo(const parser::CreateTableInfo* } } -BoundCreateTableInfo Binder::bindCreateNodeTableInfo(const CreateTableInfo* info) { - auto propertyDefinitions = bindPropertyDefinitions(info->propertyDefinitions, info->tableName); - auto& extraInfo = info->extraInfo->constCast(); +BoundCreateTableInfo Binder::bindCreateNodeTableInfo(const CreateTableInfo& info) { + auto propertyDefinitions = bindPropertyDefinitions(info.propertyDefinitions, info.tableName); + auto& extraInfo = info.extraInfo->constCast(); validatePrimaryKey(extraInfo.pKName, propertyDefinitions); auto boundExtraInfo = std::make_unique(extraInfo.pKName, std::move(propertyDefinitions)); - return BoundCreateTableInfo(TableType::NODE, info->tableName, info->onConflict, + return BoundCreateTableInfo(TableType::NODE, info.tableName, info.onConflict, + std::move(boundExtraInfo)); +} + +static PropertyDefinition getDefinition(const std::vector& definitions, + const std::string& name) { + for (auto& definition : definitions) { + if (definition.getName() == name) { + return definition.copy(); + } + } + // LCOV_EXCL_START + throw BinderException(stringFormat("Cannot find property with name {}.", name)); + // LCOV_EXCL_STOP +} + +static std::string getPhysicalTableName(std::string name) { + return "_" + name; +} + +BoundCreateTableInfo Binder::bindCreateExternalNodeTableInfo(const CreateTableInfo& info) { + auto& extraInfo = info.extraInfo->constCast(); + auto entry = bindExternalTableEntry(extraInfo.dbName, extraInfo.tableName); + auto& propertyDefinitions = entry->getProperties(); + // Bind physical create node table info + auto pkDefinition = getDefinition(propertyDefinitions, extraInfo.pkName); + std::vector physicalPropertyDefinitions; + physicalPropertyDefinitions.push_back(pkDefinition.copy()); + auto boundPhysicalExtraInfo = std::make_unique(extraInfo.pkName, + std::move(physicalPropertyDefinitions)); + auto boundPhysicalCreateInfo = + BoundCreateTableInfo(TableType::NODE, getPhysicalTableName(info.tableName), + ConflictAction::ON_CONFLICT_THROW, std::move(boundPhysicalExtraInfo)); + // Bind create node table reference info + auto boundExtraInfo = std::make_unique(extraInfo.pkName, + extraInfo.dbName, extraInfo.tableName, std::move(boundPhysicalCreateInfo), + copyVector(propertyDefinitions)); + return BoundCreateTableInfo(TableType::EXTERNAL_NODE, info.tableName, info.onConflict, std::move(boundExtraInfo)); } -BoundCreateTableInfo Binder::bindCreateRelTableInfo(const CreateTableInfo* info) { +BoundCreateTableInfo Binder::bindCreateRelTableInfo(const CreateTableInfo& info) { std::vector propertyDefinitions; propertyDefinitions.emplace_back( ColumnDefinition(InternalKeyword::ID, LogicalType::INTERNAL_ID())); - for (auto& definition : bindPropertyDefinitions(info->propertyDefinitions, info->tableName)) { + for (auto& definition : bindPropertyDefinitions(info.propertyDefinitions, info.tableName)) { propertyDefinitions.push_back(definition.copy()); } - auto& extraInfo = info->extraInfo->constCast(); + auto& extraInfo = info.extraInfo->constCast(); auto srcMultiplicity = RelMultiplicityUtils::getFwd(extraInfo.relMultiplicity); auto dstMultiplicity = RelMultiplicityUtils::getBwd(extraInfo.relMultiplicity); auto srcTableID = bindTableID(extraInfo.srcTableName); @@ -153,7 +193,7 @@ BoundCreateTableInfo Binder::bindCreateRelTableInfo(const CreateTableInfo* info) validateTableType(dstTableID, TableType::NODE); auto boundExtraInfo = std::make_unique(srcMultiplicity, dstMultiplicity, srcTableID, dstTableID, std::move(propertyDefinitions)); - return BoundCreateTableInfo(TableType::REL, info->tableName, info->onConflict, + return BoundCreateTableInfo(TableType::REL, info.tableName, info.onConflict, std::move(boundExtraInfo)); } @@ -162,29 +202,29 @@ static std::string getRelGroupTableName(const std::string& relGroupName, return relGroupName + "_" + srcTableName + "_" + dstTableName; } -BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo* info) { - auto relGroupName = info->tableName; - auto& extraInfo = info->extraInfo->constCast(); +BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo& info) { + auto relGroupName = info.tableName; + auto& extraInfo = info.extraInfo->constCast(); auto relMultiplicity = extraInfo.relMultiplicity; std::vector boundCreateRelTableInfos; - auto relCreateInfo = std::make_unique(TableType::REL, "", info->onConflict); - relCreateInfo->propertyDefinitions = copyVector(info->propertyDefinitions); + auto relCreateInfo = CreateTableInfo(TableType::REL, "", info.onConflict); + relCreateInfo.propertyDefinitions = copyVector(info.propertyDefinitions); for (auto& [srcTableName, dstTableName] : extraInfo.srcDstTablePairs) { - relCreateInfo->tableName = getRelGroupTableName(relGroupName, srcTableName, dstTableName); - relCreateInfo->extraInfo = + relCreateInfo.tableName = getRelGroupTableName(relGroupName, srcTableName, dstTableName); + relCreateInfo.extraInfo = std::make_unique(relMultiplicity, srcTableName, dstTableName); - boundCreateRelTableInfos.push_back(bindCreateRelTableInfo(relCreateInfo.get())); + boundCreateRelTableInfos.push_back(bindCreateRelTableInfo(relCreateInfo)); } auto boundExtraInfo = std::make_unique(std::move(boundCreateRelTableInfos)); - return BoundCreateTableInfo(TableType::REL_GROUP, info->tableName, info->onConflict, + return BoundCreateTableInfo(TableType::REL_GROUP, info.tableName, info.onConflict, std::move(boundExtraInfo)); } std::unique_ptr Binder::bindCreateTable(const Statement& statement) { auto createTable = statement.constPtrCast(); - auto tableName = createTable->getInfo()->tableName; - switch (createTable->getInfo()->onConflict) { + auto tableName = createTable->getInfo().tableName; + switch (createTable->getInfo().onConflict) { case common::ConflictAction::ON_CONFLICT_THROW: { if (clientContext->getCatalog()->containsTable(clientContext->getTx(), tableName)) { throw BinderException(tableName + " already exists in catalog."); diff --git a/src/binder/bind/bind_external.cpp b/src/binder/bind/bind_external.cpp new file mode 100644 index 00000000000..8e422caf5b2 --- /dev/null +++ b/src/binder/bind/bind_external.cpp @@ -0,0 +1,42 @@ +#include "binder/binder.h" +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" +#include "common/exception/binder.h" +#include "main/client_context.h" +#include "main/database_manager.h" + +using namespace kuzu::common; +using namespace kuzu::catalog; + +namespace kuzu { +namespace binder { + +catalog::TableCatalogEntry* Binder::bindExternalTableEntry(const std::string& dbName, + const std::string& tableName) { + auto attachedDB = clientContext->getDatabaseManager()->getAttachedDatabase(dbName); + if (attachedDB == nullptr) { + throw BinderException{stringFormat("No database named {} has been attached.", dbName)}; + } + auto attachedCatalog = attachedDB->getCatalog(); + auto tableID = attachedCatalog->getTableID(clientContext->getTx(), tableName); + return attachedCatalog->getTableCatalogEntry(clientContext->getTx(), tableID); +} + +void Binder::bindExternalTableEntry(NodeOrRelExpression& nodeOrRel) { + if (nodeOrRel.isMultiLabeled() || nodeOrRel.isEmpty()) { + return; + } + auto entry = nodeOrRel.getSingleEntry(); + switch (entry->getType()) { + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: { + auto& tableEntry = entry->constCast(); + auto externalEntry = bindExternalTableEntry(tableEntry.getExternalDBName(), + tableEntry.getExternalTableName()); + nodeOrRel.setExternalEntry(externalEntry); + } break; + default: + break; + } +} + +} // namespace binder +} // namespace kuzu diff --git a/src/binder/bind/bind_file_scan.cpp b/src/binder/bind/bind_file_scan.cpp index 12ef2258553..beaea6b785a 100644 --- a/src/binder/bind/bind_file_scan.cpp +++ b/src/binder/bind/bind_file_scan.cpp @@ -123,19 +123,6 @@ std::unique_ptr Binder::bindQueryScanSource(const BaseScanS return std::make_unique(std::move(boundStatement)); } -static TableFunction getObjectScanFunc(const std::string& dbName, const std::string& tableName, - main::ClientContext* clientContext) { - // Bind external database table - auto attachedDB = clientContext->getDatabaseManager()->getAttachedDatabase(dbName); - if (attachedDB == nullptr) { - throw BinderException{stringFormat("No database named {} has been attached.", dbName)}; - } - auto attachedCatalog = attachedDB->getCatalog(); - auto tableID = attachedCatalog->getTableID(clientContext->getTx(), tableName); - auto entry = attachedCatalog->getTableCatalogEntry(clientContext->getTx(), tableID); - return entry->ptrCast()->getScanFunction(); -} - std::unique_ptr Binder::bindObjectScanSource(const BaseScanSource& scanSource, const parser::options_t& options, const std::vector& columnNames, const std::vector& columnTypes) { @@ -153,18 +140,22 @@ std::unique_ptr Binder::bindObjectScanSource(const BaseScan bindData = func.bindFunc(clientContext, &replacementData->bindInput); } else if (clientContext->getDatabaseManager()->hasDefaultDatabase()) { auto dbName = clientContext->getDatabaseManager()->getDefaultDatabase(); - func = getObjectScanFunc(dbName, objectSource->objectNames[0], clientContext); - auto bindInput = function::ScanTableFuncBindInput(); + auto tableName = objectSource->objectNames[0]; + auto entry = bindExternalTableEntry(dbName, tableName); + func = entry->getScanFunction(); + auto bindInput = ScanTableFuncBindInput(); bindData = func.bindFunc(clientContext, &bindInput); } else { throw BinderException(ExceptionMessage::variableNotInScope(objectName)); } } else if (objectSource->objectNames.size() == 2) { // Bind external database table - objectName = objectSource->objectNames[0] + "." + objectSource->objectNames[1]; - func = getObjectScanFunc(objectSource->objectNames[0], objectSource->objectNames[1], - clientContext); - auto bindInput = function::ScanTableFuncBindInput(); + auto dbName = objectSource->objectNames[0]; + auto tableName = objectSource->objectNames[1]; + objectName = dbName + "." + tableName; + auto entry = bindExternalTableEntry(dbName, tableName); + func = entry->getScanFunction(); + auto bindInput = ScanTableFuncBindInput(); bindData = func.bindFunc(clientContext, &bindInput); } else { // LCOV_EXCL_START diff --git a/src/binder/bind/bind_graph_pattern.cpp b/src/binder/bind/bind_graph_pattern.cpp index 2cdc6e42944..0b04568ae27 100644 --- a/src/binder/bind/bind_graph_pattern.cpp +++ b/src/binder/bind/bind_graph_pattern.cpp @@ -9,6 +9,7 @@ #include "catalog/catalog_entry/rdf_graph_catalog_entry.h" #include "catalog/catalog_entry/rel_group_catalog_entry.h" #include "catalog/catalog_entry/rel_table_catalog_entry.h" +#include "common/distinct_vector.h" #include "common/exception/binder.h" #include "common/keyword/rdf_keyword.h" #include "common/string_format.h" @@ -124,18 +125,13 @@ std::shared_ptr Binder::createPath(const std::string& pathName, } static std::vector getPropertyNames(const std::vector& entries) { - std::vector result; - std::unordered_set propertyNamesSet; + auto distinctVector = DistinctVector(); for (auto& entry : entries) { for (auto& property : entry->getProperties()) { - if (propertyNamesSet.contains(property.getName())) { - continue; - } - propertyNamesSet.insert(property.getName()); - result.push_back(property.getName()); + distinctVector.add(property.getName()); } } - return result; + return distinctVector.values; } static std::unique_ptr createPropertyExpression(const std::string& propertyName, @@ -286,23 +282,19 @@ std::shared_ptr Binder::createNonRecursiveQueryRel(const std::str "PropertyGraph in one pattern is currently not supported.", parsedName, relTableName, rdfGraphName)); } - common::table_id_vector_t resourceTableIDs; + std::vector resourceEntries; for (auto& tableID : rdfGraphTableIDSet) { auto entry = catalog->getTableCatalogEntry(transaction, tableID); auto& rdfGraphEntry = entry->constCast(); - resourceTableIDs.push_back(rdfGraphEntry.getResourceTableID()); + resourceEntries.push_back( + catalog->getTableCatalogEntry(transaction, rdfGraphEntry.getResourceTableID())); } auto pID = expressionBinder.bindNodeOrRelPropertyExpression(*queryRel, std::string(rdf::PID)); - auto rdfInfo = std::make_unique(resourceTableIDs, std::move(pID)); + auto rdfInfo = std::make_unique(resourceEntries, std::move(pID)); queryRel->setRdfPredicateInfo(std::move(rdfInfo)); - std::vector resourceTableSchemas; - for (auto tableID : resourceTableIDs) { - resourceTableSchemas.push_back(catalog->getTableCatalogEntry(transaction, tableID)); - } // Mock existence of pIRI property. - auto pIRI = - createPropertyExpression(std::string(rdf::IRI), *queryRel, resourceTableSchemas); + auto pIRI = createPropertyExpression(std::string(rdf::IRI), *queryRel, resourceEntries); queryRel->addPropertyExpression(std::string(rdf::IRI), std::move(pIRI)); } std::vector fields; @@ -592,6 +584,7 @@ std::shared_ptr Binder::createQueryNode(const std::string& parse } auto extraInfo = std::make_unique(fieldNames, fieldTypes); queryNode->setExtraTypeInfo(std::move(extraInfo)); + bindExternalTableEntry(*queryNode); return queryNode; } @@ -686,7 +679,8 @@ std::vector Binder::getTableEntries( std::vector Binder::getNodeTableEntries(TableCatalogEntry* entry) const { switch (entry->getTableType()) { - case TableType::NODE: { + case TableType::NODE: + case TableType::EXTERNAL_NODE: { return {entry}; } default: diff --git a/src/binder/bind/copy/bind_copy_from.cpp b/src/binder/bind/copy/bind_copy_from.cpp index ec8c649a2cf..8492d9147d9 100644 --- a/src/binder/bind/copy/bind_copy_from.cpp +++ b/src/binder/bind/copy/bind_copy_from.cpp @@ -1,6 +1,7 @@ #include "binder/binder.h" #include "binder/copy/bound_copy_from.h" #include "catalog/catalog.h" +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" #include "catalog/catalog_entry/node_table_catalog_entry.h" #include "catalog/catalog_entry/rdf_graph_catalog_entry.h" #include "catalog/catalog_entry/rel_table_catalog_entry.h" @@ -40,6 +41,11 @@ std::unique_ptr Binder::bindCopyFromClause(const Statement& stat auto nodeTableEntry = tableEntry->ptrCast(); return bindCopyNodeFrom(statement, nodeTableEntry); } + case TableType::EXTERNAL_NODE: { + auto externalEntry = tableEntry->ptrCast(); + auto physicalEntry = externalEntry->getPhysicalEntry()->ptrCast(); + return bindCopyNodeFrom(statement, physicalEntry); + } case TableType::REL: { auto relTableEntry = tableEntry->ptrCast(); return bindCopyRelFrom(statement, relTableEntry); diff --git a/src/binder/bind/ddl/bind_create_rdf_graph.cpp b/src/binder/bind/ddl/bind_create_rdf_graph.cpp index a88f0270b07..dc0a71566be 100644 --- a/src/binder/bind/ddl/bind_create_rdf_graph.cpp +++ b/src/binder/bind/ddl/bind_create_rdf_graph.cpp @@ -12,8 +12,8 @@ using namespace kuzu::catalog; namespace kuzu { namespace binder { -BoundCreateTableInfo Binder::bindCreateRdfGraphInfo(const CreateTableInfo* info) { - auto rdfGraphName = info->tableName; +BoundCreateTableInfo Binder::bindCreateRdfGraphInfo(const CreateTableInfo& info) { + auto rdfGraphName = info.tableName; // Resource table. auto resourceTableName = RDFGraphCatalogEntry::getResourceTableName(rdfGraphName); auto iriColumnDefinition = ColumnDefinition(std::string(rdf::IRI), LogicalType::STRING()); @@ -22,7 +22,7 @@ BoundCreateTableInfo Binder::bindCreateRdfGraphInfo(const CreateTableInfo* info) auto resourceExtraInfo = std::make_unique( iriColumnDefinition.name, std::move(resourceProperties)); auto resourceCreateInfo = BoundCreateTableInfo(TableType::NODE, resourceTableName, - info->onConflict, std::move(resourceExtraInfo)); + info.onConflict, std::move(resourceExtraInfo)); // Literal table. auto literalTableName = RDFGraphCatalogEntry::getLiteralTableName(rdfGraphName); auto literalIDColumnDefinition = ColumnDefinition(std::string(rdf::ID), LogicalType::SERIAL()); @@ -39,7 +39,7 @@ BoundCreateTableInfo Binder::bindCreateRdfGraphInfo(const CreateTableInfo* info) auto literalExtraInfo = std::make_unique( literalIDColumnDefinition.name, std::move(literalProperties)); auto literalCreateInfo = BoundCreateTableInfo(TableType::NODE, literalTableName, - info->onConflict, std::move(literalExtraInfo)); + info.onConflict, std::move(literalExtraInfo)); // Resource triple table. auto resourceTripleTableName = RDFGraphCatalogEntry::getResourceTripleTableName(rdfGraphName); auto resourceTripleIDColumnDefinition = @@ -52,7 +52,7 @@ BoundCreateTableInfo Binder::bindCreateRdfGraphInfo(const CreateTableInfo* info) auto boundResourceTripleExtraInfo = std::make_unique( INVALID_TABLE_ID, INVALID_TABLE_ID, std::move(resourceTripleProperties)); auto boundResourceTripleCreateInfo = BoundCreateTableInfo(TableType::REL, - resourceTripleTableName, info->onConflict, std::move(boundResourceTripleExtraInfo)); + resourceTripleTableName, info.onConflict, std::move(boundResourceTripleExtraInfo)); // Literal triple table. auto literalTripleTableName = RDFGraphCatalogEntry::getLiteralTripleTableName(rdfGraphName); auto literalTripleIDColumnDefinition = @@ -65,12 +65,12 @@ BoundCreateTableInfo Binder::bindCreateRdfGraphInfo(const CreateTableInfo* info) auto boundLiteralTripleExtraInfo = std::make_unique( INVALID_TABLE_ID, INVALID_TABLE_ID, std::move(literalTripleProperties)); auto boundLiteralTripleCreateInfo = BoundCreateTableInfo(TableType::REL, literalTripleTableName, - info->onConflict, std::move(boundLiteralTripleExtraInfo)); + info.onConflict, std::move(boundLiteralTripleExtraInfo)); // Rdf table. auto boundExtraInfo = std::make_unique( std::move(resourceCreateInfo), std::move(literalCreateInfo), std::move(boundResourceTripleCreateInfo), std::move(boundLiteralTripleCreateInfo)); - return BoundCreateTableInfo(TableType::RDF, rdfGraphName, info->onConflict, + return BoundCreateTableInfo(TableType::RDF, rdfGraphName, info.onConflict, std::move(boundExtraInfo)); } diff --git a/src/binder/bind/ddl/bound_create_table_info.cpp b/src/binder/bind/ddl/bound_create_table_info.cpp index 675767cc8f3..ae98e7c9927 100644 --- a/src/binder/bind/ddl/bound_create_table_info.cpp +++ b/src/binder/bind/ddl/bound_create_table_info.cpp @@ -31,6 +31,7 @@ BoundCreateTableInfo BoundCreateTableInfo::deserialize(Deserializer& deserialize deserializer.deserializeValue(hasParent); switch (type) { case TableType::NODE: + case TableType::EXTERNAL_NODE: case TableType::REL: { extraInfo = BoundExtraCreateTableInfo::deserialize(deserializer, type); } break; @@ -62,6 +63,9 @@ std::unique_ptr BoundExtraCreateTableInfo::deserializ case TableType::NODE: { info = BoundExtraCreateNodeTableInfo::deserialize(deserializer); } break; + case TableType::EXTERNAL_NODE: { + info = BoundExtraCreateExternalNodeTableInfo::deserialize(deserializer); + } break; case TableType::REL: { info = BoundExtraCreateRelTableInfo::deserialize(deserializer); } break; @@ -86,6 +90,27 @@ std::unique_ptr BoundExtraCreateNodeTableInfo::de std::vector()); } +void BoundExtraCreateExternalNodeTableInfo::serialize(Serializer& serializer) const { + BoundExtraCreateTableInfo::serialize(serializer); + serializer.serializeValue(primaryKeyName); + serializer.serializeValue(externalDBName); + serializer.serializeValue(externalTableName); + physicalInfo.serialize(serializer); +} + +std::unique_ptr +BoundExtraCreateExternalNodeTableInfo::deserialize(Deserializer& deserializer) { + std::string primaryKeyName; + std::string externalDBName; + std::string externalTableName; + deserializer.deserializeValue(primaryKeyName); + deserializer.deserializeValue(externalDBName); + deserializer.deserializeValue(externalTableName); + BoundCreateTableInfo physicalInfo = BoundCreateTableInfo::deserialize(deserializer); + return std::make_unique(primaryKeyName, externalDBName, + externalTableName, std::move(physicalInfo), std::vector()); +} + void BoundExtraCreateRelTableInfo::serialize(Serializer& serializer) const { BoundExtraCreateTableInfo::serialize(serializer); serializer.serializeValue(srcMultiplicity); diff --git a/src/binder/expression/rel_expression.cpp b/src/binder/expression/rel_expression.cpp index 4486350aaf9..e6c4c0b17eb 100644 --- a/src/binder/expression/rel_expression.cpp +++ b/src/binder/expression/rel_expression.cpp @@ -1,10 +1,20 @@ #include "binder/expression/rel_expression.h" +#include "catalog/catalog_entry/table_catalog_entry.h" + using namespace kuzu::common; namespace kuzu { namespace binder { +common::table_id_vector_t RdfPredicateInfo::getResourceTableIDs() const { + common::table_id_vector_t tableIDs; + for (auto entry : resourceEntries) { + tableIDs.push_back(entry->getTableID()); + } + return tableIDs; +} + std::string RelExpression::detailsToString() const { std::string result = toString(); switch (relType) { diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 64d71670bc9..e55c8e89403 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -5,6 +5,7 @@ #include "binder/ddl/bound_alter_info.h" #include "binder/ddl/bound_create_sequence_info.h" #include "binder/ddl/bound_create_table_info.h" +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" #include "catalog/catalog_entry/function_catalog_entry.h" #include "catalog/catalog_entry/node_table_catalog_entry.h" #include "catalog/catalog_entry/rdf_graph_catalog_entry.h" @@ -188,12 +189,15 @@ table_id_set_t Catalog::getBwdRelTableIDs(Transaction* transaction, table_id_t n return result; } -table_id_t Catalog::createTableSchema(Transaction* transaction, const BoundCreateTableInfo& info) { +table_id_t Catalog::createTableEntry(Transaction* transaction, const BoundCreateTableInfo& info) { std::unique_ptr entry; switch (info.type) { case TableType::NODE: { entry = createNodeTableEntry(transaction, info); } break; + case TableType::EXTERNAL_NODE: { + entry = createExternalNodeTableEntry(transaction, info); + } break; case TableType::REL: { entry = createRelTableEntry(transaction, info); } break; @@ -234,11 +238,11 @@ void Catalog::dropTableEntry(Transaction* transaction, table_id_t tableID) { } } break; case CatalogEntryType::RDF_GRAPH_ENTRY: { - const auto rdfGraphSchema = tableEntry->ptrCast(); - dropTableEntry(transaction, rdfGraphSchema->getResourceTableID()); - dropTableEntry(transaction, rdfGraphSchema->getLiteralTableID()); - dropTableEntry(transaction, rdfGraphSchema->getResourceTripleTableID()); - dropTableEntry(transaction, rdfGraphSchema->getLiteralTripleTableID()); + const auto rdfGraphEntry = tableEntry->constPtrCast(); + dropTableEntry(transaction, rdfGraphEntry->getResourceTableID()); + dropTableEntry(transaction, rdfGraphEntry->getLiteralTableID()); + dropTableEntry(transaction, rdfGraphEntry->getResourceTripleTableID()); + dropTableEntry(transaction, rdfGraphEntry->getLiteralTripleTableID()); } break; default: { // DO NOTHING. @@ -513,47 +517,54 @@ void Catalog::alterRdfChildTableEntries(Transaction* transaction, CatalogEntry* tables->alterEntry(transaction, *literalTripleRenameInfo); } -std::unique_ptr Catalog::createNodeTableEntry(Transaction*, +std::unique_ptr Catalog::createNodeTableEntry(Transaction*, const BoundCreateTableInfo& info) const { const auto extraInfo = info.extraInfo->constPtrCast(); auto nodeTableEntry = std::make_unique(tables.get(), info.tableName, extraInfo->primaryKeyName); - for (auto& definition : extraInfo->propertyDefinitions) { - nodeTableEntry->addProperty(definition); - } + nodeTableEntry->addProperties(extraInfo->propertyDefinitions); nodeTableEntry->setHasParent(info.hasParent); return nodeTableEntry; } -std::unique_ptr Catalog::createRelTableEntry(Transaction*, +std::unique_ptr Catalog::createExternalNodeTableEntry(Transaction* transaction, + const BoundCreateTableInfo& info) const { + auto extraInfo = info.extraInfo->constPtrCast(); + auto physicalEntry = createNodeTableEntry(transaction, extraInfo->physicalInfo); + auto entry = std::make_unique(tables.get(), info.tableName, + extraInfo->externalDBName, extraInfo->externalTableName, std::move(physicalEntry), + extraInfo->primaryKeyName); + entry->addProperties(extraInfo->propertyDefinitions); + return entry; +} + +std::unique_ptr Catalog::createRelTableEntry(Transaction*, const BoundCreateTableInfo& info) const { const auto extraInfo = info.extraInfo.get()->constPtrCast(); auto relTableEntry = std::make_unique(tables.get(), info.tableName, extraInfo->srcMultiplicity, extraInfo->dstMultiplicity, extraInfo->srcTableID, extraInfo->dstTableID); - for (auto& definition : extraInfo->propertyDefinitions) { - relTableEntry->addProperty(definition); - } + relTableEntry->addProperties(extraInfo->propertyDefinitions); relTableEntry->setHasParent(info.hasParent); return relTableEntry; } -std::unique_ptr Catalog::createRelTableGroupEntry(Transaction* transaction, +std::unique_ptr Catalog::createRelTableGroupEntry(Transaction* transaction, const BoundCreateTableInfo& info) { - const auto extraInfo = info.extraInfo->ptrCast(); + auto extraInfo = info.extraInfo->ptrCast(); std::vector relTableIDs; relTableIDs.reserve(extraInfo->infos.size()); for (auto& childInfo : extraInfo->infos) { childInfo.hasParent = true; - relTableIDs.push_back(createTableSchema(transaction, childInfo)); + relTableIDs.push_back(createTableEntry(transaction, childInfo)); } return std::make_unique(tables.get(), info.tableName, std::move(relTableIDs)); } -std::unique_ptr Catalog::createRdfGraphEntry(Transaction* transaction, +std::unique_ptr Catalog::createRdfGraphEntry(Transaction* transaction, const BoundCreateTableInfo& info) { - const auto extraInfo = info.extraInfo->ptrCast(); + auto extraInfo = info.extraInfo->ptrCast(); auto& resourceInfo = extraInfo->resourceInfo; auto& literalInfo = extraInfo->literalInfo; auto& resourceTripleInfo = extraInfo->resourceTripleInfo; @@ -567,17 +578,17 @@ std::unique_ptr Catalog::createRdfGraphEntry(Transaction* transact const auto literalTripleExtraInfo = literalTripleInfo.extraInfo->ptrCast(); // Resource table - auto resourceTableID = createTableSchema(transaction, resourceInfo); + auto resourceTableID = createTableEntry(transaction, resourceInfo); // Literal table - auto literalTableID = createTableSchema(transaction, literalInfo); + auto literalTableID = createTableEntry(transaction, literalInfo); // Resource triple table resourceTripleExtraInfo->srcTableID = resourceTableID; resourceTripleExtraInfo->dstTableID = resourceTableID; - auto resourceTripleTableID = createTableSchema(transaction, resourceTripleInfo); + auto resourceTripleTableID = createTableEntry(transaction, resourceTripleInfo); // Literal triple table literalTripleExtraInfo->srcTableID = resourceTableID; literalTripleExtraInfo->dstTableID = literalTableID; - auto literalTripleTableID = createTableSchema(transaction, literalTripleInfo); + auto literalTripleTableID = createTableEntry(transaction, literalTripleInfo); // Rdf graph entry auto rdfGraphName = info.tableName; return std::make_unique(tables.get(), rdfGraphName, resourceTableID, diff --git a/src/catalog/catalog_entry/CMakeLists.txt b/src/catalog/catalog_entry/CMakeLists.txt index d234b264770..4da1cb56672 100644 --- a/src/catalog/catalog_entry/CMakeLists.txt +++ b/src/catalog/catalog_entry/CMakeLists.txt @@ -2,6 +2,8 @@ add_library(kuzu_catalog_entry OBJECT catalog_entry.cpp catalog_entry_type.cpp + external_node_table_catalog_entry.cpp + external_table_catalog_entry.cpp function_catalog_entry.cpp table_catalog_entry.cpp node_table_catalog_entry.cpp diff --git a/src/catalog/catalog_entry/catalog_entry.cpp b/src/catalog/catalog_entry/catalog_entry.cpp index a556eba7c63..d312eb8a913 100644 --- a/src/catalog/catalog_entry/catalog_entry.cpp +++ b/src/catalog/catalog_entry/catalog_entry.cpp @@ -37,6 +37,7 @@ std::unique_ptr CatalogEntry::deserialize(common::Deserializer& de std::unique_ptr entry; switch (type) { case CatalogEntryType::NODE_TABLE_ENTRY: + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: case CatalogEntryType::REL_TABLE_ENTRY: case CatalogEntryType::REL_GROUP_ENTRY: case CatalogEntryType::RDF_GRAPH_ENTRY: { diff --git a/src/catalog/catalog_entry/catalog_entry_type.cpp b/src/catalog/catalog_entry/catalog_entry_type.cpp index e1e7f1cb9be..ed59cb46479 100644 --- a/src/catalog/catalog_entry/catalog_entry_type.cpp +++ b/src/catalog/catalog_entry/catalog_entry_type.cpp @@ -17,6 +17,8 @@ std::string CatalogEntryTypeUtils::toString(CatalogEntryType type) { return "RDF_GRAPH_ENTRY"; case CatalogEntryType::FOREIGN_TABLE_ENTRY: return "FOREIGN_TABLE_ENTRY"; + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: + return "EXTERNAL_NODE_TABLE_ENTRY"; case CatalogEntryType::SCALAR_MACRO_ENTRY: return "SCALAR_MACRO_ENTRY"; case CatalogEntryType::AGGREGATE_FUNCTION_ENTRY: diff --git a/src/catalog/catalog_entry/external_node_table_catalog_entry.cpp b/src/catalog/catalog_entry/external_node_table_catalog_entry.cpp new file mode 100644 index 00000000000..ec3549af6a2 --- /dev/null +++ b/src/catalog/catalog_entry/external_node_table_catalog_entry.cpp @@ -0,0 +1,42 @@ +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" + +#include "binder/ddl/bound_create_table_info.h" +#include "common/serializer/deserializer.h" + +using namespace kuzu::binder; +using namespace kuzu::common; +using namespace kuzu::transaction; + +namespace kuzu { +namespace catalog { + +void ExternalNodeTableCatalogEntry::serialize(Serializer& serializer) const { + ExternalTableCatalogEntry::serialize(serializer); + serializer.write(primaryKeyName); +} + +std::unique_ptr ExternalNodeTableCatalogEntry::deserialize( + Deserializer& deserializer) { + std::string primaryKeyName; + deserializer.deserializeValue(primaryKeyName); + auto entry = std::make_unique(); + entry->primaryKeyName = primaryKeyName; + return entry; +} + +std::unique_ptr ExternalNodeTableCatalogEntry::copy() const { + auto result = std::make_unique(); + result->primaryKeyName = primaryKeyName; + result->copyFrom(*this); + return result; +} + +std::unique_ptr +ExternalNodeTableCatalogEntry::getBoundExtraCreateInfo(Transaction* transaction) const { + return std::make_unique(primaryKeyName, externalDBName, + externalTableName, physicalEntry->getBoundCreateTableInfo(transaction), + copyVector(getProperties())); +} + +} // namespace catalog +} // namespace kuzu diff --git a/src/catalog/catalog_entry/external_table_catalog_entry.cpp b/src/catalog/catalog_entry/external_table_catalog_entry.cpp new file mode 100644 index 00000000000..af38bb5330a --- /dev/null +++ b/src/catalog/catalog_entry/external_table_catalog_entry.cpp @@ -0,0 +1,49 @@ +#include "catalog/catalog_entry/external_table_catalog_entry.h" + +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" +#include "common/serializer/deserializer.h" + +using namespace kuzu::common; + +namespace kuzu { +namespace catalog { + +void ExternalTableCatalogEntry::copyFrom(const CatalogEntry& other) { + TableCatalogEntry::copyFrom(other); + auto& otherTable = other.constCast(); + externalDBName = otherTable.externalDBName; + externalTableName = otherTable.externalTableName; + physicalEntry = otherTable.physicalEntry->copy(); +} + +void ExternalTableCatalogEntry::serialize(Serializer& serializer) const { + TableCatalogEntry::serialize(serializer); + serializer.write(externalDBName); + serializer.write(externalTableName); + KU_ASSERT(physicalEntry != nullptr); + physicalEntry->serialize(serializer); +} + +std::unique_ptr ExternalTableCatalogEntry::deserialize( + Deserializer& deserializer, CatalogEntryType type) { + std::string externalDBName; + std::string externalTableName; + deserializer.deserializeValue(externalDBName); + deserializer.deserializeValue(externalTableName); + auto physicalEntry = CatalogEntry::deserialize(deserializer); + std::unique_ptr entry; + switch (type) { + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: { + entry = ExternalNodeTableCatalogEntry::deserialize(deserializer); + } break; + default: + KU_UNREACHABLE; + } + entry->externalDBName = externalDBName; + entry->externalTableName = externalTableName; + entry->physicalEntry = physicalEntry->ptrCast()->copy(); + return entry; +} + +} // namespace catalog +} // namespace kuzu diff --git a/src/catalog/catalog_entry/table_catalog_entry.cpp b/src/catalog/catalog_entry/table_catalog_entry.cpp index 527034993c6..c7793ecb1e5 100644 --- a/src/catalog/catalog_entry/table_catalog_entry.cpp +++ b/src/catalog/catalog_entry/table_catalog_entry.cpp @@ -1,6 +1,7 @@ #include "catalog/catalog_entry/table_catalog_entry.h" #include "binder/ddl/bound_alter_info.h" +#include "catalog/catalog_entry/external_table_catalog_entry.h" #include "catalog/catalog_entry/node_table_catalog_entry.h" #include "catalog/catalog_entry/rdf_graph_catalog_entry.h" #include "catalog/catalog_entry/rel_group_catalog_entry.h" @@ -76,6 +77,13 @@ column_id_t TableCatalogEntry::getColumnID(const std::string& propertyName) cons return propertyCollection.getColumnID(propertyName); } +void TableCatalogEntry::addProperties( + const std::vector& propertyDefinitions) { + for (auto& definition : propertyDefinitions) { + propertyCollection.add(definition); + } +} + void TableCatalogEntry::addProperty(const PropertyDefinition& propertyDefinition) { propertyCollection.add(propertyDefinition); } @@ -107,18 +115,21 @@ std::unique_ptr TableCatalogEntry::deserialize(Deserializer& auto propertyCollection = PropertyDefinitionCollection::deserialize(deserializer); std::unique_ptr result; switch (type) { - case CatalogEntryType::NODE_TABLE_ENTRY: + case CatalogEntryType::NODE_TABLE_ENTRY: { result = NodeTableCatalogEntry::deserialize(deserializer); - break; - case CatalogEntryType::REL_TABLE_ENTRY: + } break; + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: { + result = ExternalTableCatalogEntry::deserialize(deserializer, type); + } break; + case CatalogEntryType::REL_TABLE_ENTRY: { result = RelTableCatalogEntry::deserialize(deserializer); - break; - case CatalogEntryType::REL_GROUP_ENTRY: + } break; + case CatalogEntryType::REL_GROUP_ENTRY: { result = RelGroupCatalogEntry::deserialize(deserializer); - break; - case CatalogEntryType::RDF_GRAPH_ENTRY: + } break; + case CatalogEntryType::RDF_GRAPH_ENTRY: { result = RDFGraphCatalogEntry::deserialize(deserializer); - break; + } break; default: KU_UNREACHABLE; } @@ -129,7 +140,7 @@ std::unique_ptr TableCatalogEntry::deserialize(Deserializer& void TableCatalogEntry::copyFrom(const CatalogEntry& other) { CatalogEntry::copyFrom(other); - auto& otherTable = ku_dynamic_cast(other); + auto& otherTable = other.constCast(); set = otherTable.set; comment = otherTable.comment; propertyCollection = otherTable.propertyCollection.copy(); diff --git a/src/catalog/catalog_set.cpp b/src/catalog/catalog_set.cpp index 203e64fb196..c0df2fbfc9b 100644 --- a/src/catalog/catalog_set.cpp +++ b/src/catalog/catalog_set.cpp @@ -2,6 +2,7 @@ #include "binder/ddl/bound_alter_info.h" #include "catalog/catalog_entry/dummy_catalog_entry.h" +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" #include "catalog/catalog_entry/table_catalog_entry.h" #include "common/assert.h" #include "common/exception/catalog.h" @@ -69,6 +70,9 @@ oid_t CatalogSet::createEntry(Transaction* transaction, std::unique_ptrsetOID(oid); + if (entry->getType() == CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY) { + entry->ptrCast()->getPhysicalEntry()->setOID(nextOID++); + } entryPtr = createEntryNoLock(transaction, std::move(entry)); } KU_ASSERT(entryPtr); @@ -174,6 +178,7 @@ void CatalogSet::alterEntry(Transaction* transaction, const binder::BoundAlterIn // LCOV_EXCL_STOP entry = getEntryNoLock(transaction, alterInfo.tableName); KU_ASSERT(entry->getType() == CatalogEntryType::NODE_TABLE_ENTRY || + entry->getType() == CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY || entry->getType() == CatalogEntryType::REL_TABLE_ENTRY || entry->getType() == CatalogEntryType::REL_GROUP_ENTRY || entry->getType() == CatalogEntryType::RDF_GRAPH_ENTRY); diff --git a/src/common/enums/table_type.cpp b/src/common/enums/table_type.cpp index f591db6c479..04fd032a422 100644 --- a/src/common/enums/table_type.cpp +++ b/src/common/enums/table_type.cpp @@ -25,6 +25,9 @@ std::string TableTypeUtils::toString(TableType tableType) { case TableType::FOREIGN: { return "ATTACHED"; } + case TableType::EXTERNAL_NODE: { + return "EXTERNAL_NODE"; + } default: KU_UNREACHABLE; } diff --git a/src/include/binder/binder.h b/src/include/binder/binder.h index d32b0a1b6e5..39ab5f4baf5 100644 --- a/src/include/binder/binder.h +++ b/src/include/binder/binder.h @@ -100,11 +100,12 @@ class Binder { common::LogicalTypeID typeID); /*** bind DDL ***/ - BoundCreateTableInfo bindCreateTableInfo(const parser::CreateTableInfo* info); - BoundCreateTableInfo bindCreateNodeTableInfo(const parser::CreateTableInfo* info); - BoundCreateTableInfo bindCreateRelTableInfo(const parser::CreateTableInfo* info); - BoundCreateTableInfo bindCreateRelTableGroupInfo(const parser::CreateTableInfo* info); - BoundCreateTableInfo bindCreateRdfGraphInfo(const parser::CreateTableInfo* info); + BoundCreateTableInfo bindCreateTableInfo(const parser::CreateTableInfo& info); + BoundCreateTableInfo bindCreateNodeTableInfo(const parser::CreateTableInfo& info); + BoundCreateTableInfo bindCreateExternalNodeTableInfo(const parser::CreateTableInfo& info); + BoundCreateTableInfo bindCreateRelTableInfo(const parser::CreateTableInfo& info); + BoundCreateTableInfo bindCreateRelTableGroupInfo(const parser::CreateTableInfo& info); + BoundCreateTableInfo bindCreateRdfGraphInfo(const parser::CreateTableInfo& info); std::unique_ptr bindCreateTable(const parser::Statement& statement); std::unique_ptr bindCreateType(const parser::Statement& statement); std::unique_ptr bindCreateSequence(const parser::Statement& statement); @@ -288,6 +289,10 @@ class Binder { std::vector getTableEntries( const common::table_id_vector_t& tableIDs); + catalog::TableCatalogEntry* bindExternalTableEntry(const std::string& dbName, + const std::string& tableName); + void bindExternalTableEntry(NodeOrRelExpression& nodeOrRel); + /*** validations ***/ // E.g. ... RETURN a, b AS a static void validateProjectionColumnNamesAreUnique(const expression_vector& expressions); diff --git a/src/include/binder/ddl/bound_create_table_info.h b/src/include/binder/ddl/bound_create_table_info.h index 16d5b5003e5..35f158bd35f 100644 --- a/src/include/binder/ddl/bound_create_table_info.h +++ b/src/include/binder/ddl/bound_create_table_info.h @@ -93,6 +93,32 @@ struct BoundExtraCreateNodeTableInfo final : public BoundExtraCreateTableInfo { common::Deserializer& deserializer); }; +struct BoundExtraCreateExternalNodeTableInfo : public BoundExtraCreateTableInfo { + std::string primaryKeyName; + std::string externalDBName; + std::string externalTableName; + BoundCreateTableInfo physicalInfo; + + BoundExtraCreateExternalNodeTableInfo(std::string primaryKeyName, std::string externalDBName, + std::string externalTableName, BoundCreateTableInfo physicalInfo, + std::vector definitions) + : BoundExtraCreateTableInfo{std::move(definitions)}, + primaryKeyName{std::move(primaryKeyName)}, externalDBName{std::move(externalDBName)}, + externalTableName{std::move(externalTableName)}, physicalInfo{std::move(physicalInfo)} {} + BoundExtraCreateExternalNodeTableInfo(const BoundExtraCreateExternalNodeTableInfo& other) + : BoundExtraCreateTableInfo{other}, primaryKeyName{other.primaryKeyName}, + externalDBName{other.externalDBName}, externalTableName{other.externalTableName}, + physicalInfo{other.physicalInfo.copy()} {} + + std::unique_ptr copy() const override { + return std::make_unique(*this); + } + + void serialize(common::Serializer& serializer) const override; + static std::unique_ptr deserialize( + common::Deserializer& deserializer); +}; + struct BoundExtraCreateRelTableInfo final : public BoundExtraCreateTableInfo { common::RelMultiplicity srcMultiplicity; common::RelMultiplicity dstMultiplicity; diff --git a/src/include/binder/expression/node_rel_expression.h b/src/include/binder/expression/node_rel_expression.h index 44fb01ba01c..45514e6e411 100644 --- a/src/include/binder/expression/node_rel_expression.h +++ b/src/include/binder/expression/node_rel_expression.h @@ -38,12 +38,15 @@ class NodeOrRelExpression : public Expression { void addEntries(const std::vector entries_); catalog::TableCatalogEntry* getSingleEntry() const; + void setExternalEntry(catalog::TableCatalogEntry* entry) { externalEntry = entry; } + bool hasExternalEntry() const { return externalEntry != nullptr; } + catalog::TableCatalogEntry* getExternalEntry() const { return externalEntry; } + void addPropertyExpression(const std::string& propertyName, std::unique_ptr property); bool hasPropertyExpression(const std::string& propertyName) const { return propertyNameToIdx.contains(propertyName); } - // Deep copy expression. std::shared_ptr getPropertyExpression(const std::string& propertyName) const; const std::vector>& getPropertyExprsRef() const { return propertyExprs; @@ -77,6 +80,8 @@ class NodeOrRelExpression : public Expression { std::string variableName; // A pattern may bind to multiple tables. std::vector entries; + // A pattern may refers to an external extry. + catalog::TableCatalogEntry* externalEntry = nullptr; // Index over propertyExprs on property name. common::case_insensitive_map_t propertyNameToIdx; // Property expressions with order (aligned with catalog). diff --git a/src/include/binder/expression/rel_expression.h b/src/include/binder/expression/rel_expression.h index 793ef69871b..d05c2c6f4e0 100644 --- a/src/include/binder/expression/rel_expression.h +++ b/src/include/binder/expression/rel_expression.h @@ -46,12 +46,14 @@ struct RecursiveInfo { }; struct RdfPredicateInfo { - std::vector resourceTableIDs; + std::vector resourceEntries; std::shared_ptr predicateID; - RdfPredicateInfo(std::vector resourceTableIDs, + common::table_id_vector_t getResourceTableIDs() const; + + RdfPredicateInfo(std::vector resourceEntries, std::shared_ptr predicateID) - : resourceTableIDs{std::move(resourceTableIDs)}, predicateID{std::move(predicateID)} {} + : resourceEntries{std::move(resourceEntries)}, predicateID{std::move(predicateID)} {} DELETE_COPY_DEFAULT_MOVE(RdfPredicateInfo); }; diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index b5b3030e154..9203f5cafe9 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -91,7 +91,7 @@ class KUZU_API Catalog { common::table_id_set_t getBwdRelTableIDs(transaction::Transaction* transaction, common::table_id_t nodeTableID) const; - common::table_id_t createTableSchema(transaction::Transaction* transaction, + common::table_id_t createTableEntry(transaction::Transaction* transaction, const binder::BoundCreateTableInfo& info); void dropTableEntry(transaction::Transaction* transaction, const std::string& name); void dropTableEntry(transaction::Transaction* transaction, common::table_id_t tableID); @@ -172,28 +172,19 @@ class KUZU_API Catalog { return result; } - std::vector getTableIDs(transaction::Transaction* transaction, - CatalogEntryType catalogType) const; - - void alterRdfChildTableEntries(transaction::Transaction* transaction, CatalogEntry* tableEntry, + void alterRdfChildTableEntries(transaction::Transaction* transaction, CatalogEntry* entry, const binder::BoundAlterInfo& info) const; - std::unique_ptr createNodeTableEntry(transaction::Transaction* transaction, + std::unique_ptr createNodeTableEntry(transaction::Transaction* transaction, const binder::BoundCreateTableInfo& info) const; - std::unique_ptr createRelTableEntry(transaction::Transaction* transaction, + std::unique_ptr createExternalNodeTableEntry( + transaction::Transaction* transaction, const binder::BoundCreateTableInfo& info) const; + std::unique_ptr createRelTableEntry(transaction::Transaction* transaction, const binder::BoundCreateTableInfo& info) const; - std::unique_ptr createRelTableGroupEntry(transaction::Transaction* transaction, - const binder::BoundCreateTableInfo& info); - std::unique_ptr createRdfGraphEntry(transaction::Transaction* transaction, + std::unique_ptr createRelTableGroupEntry( + transaction::Transaction* transaction, const binder::BoundCreateTableInfo& info); + std::unique_ptr createRdfGraphEntry(transaction::Transaction* transaction, const binder::BoundCreateTableInfo& info); - // ----------------------------- Sequence entries ---------------------------- - void iterateSequenceCatalogEntries(const transaction::Transaction* transaction, - const std::function& func) const { - for (auto& [_, entry] : sequences->getEntries(transaction)) { - func(entry); - } - } - protected: std::unique_ptr tables; diff --git a/src/include/catalog/catalog_entry/catalog_entry_type.h b/src/include/catalog/catalog_entry/catalog_entry_type.h index 2cfa135867b..1859e6a45a5 100644 --- a/src/include/catalog/catalog_entry/catalog_entry_type.h +++ b/src/include/catalog/catalog_entry/catalog_entry_type.h @@ -13,6 +13,7 @@ enum class CatalogEntryType : uint8_t { REL_GROUP_ENTRY = 2, RDF_GRAPH_ENTRY = 3, FOREIGN_TABLE_ENTRY = 4, + EXTERNAL_NODE_TABLE_ENTRY = 5, // Macro entries SCALAR_MACRO_ENTRY = 10, // Function entries diff --git a/src/include/catalog/catalog_entry/external_node_table_catalog_entry.h b/src/include/catalog/catalog_entry/external_node_table_catalog_entry.h new file mode 100644 index 00000000000..282d22e7477 --- /dev/null +++ b/src/include/catalog/catalog_entry/external_node_table_catalog_entry.h @@ -0,0 +1,37 @@ +#pragma once + +#include "external_table_catalog_entry.h" + +namespace kuzu { +namespace catalog { + +class ExternalNodeTableCatalogEntry : public ExternalTableCatalogEntry { + static constexpr CatalogEntryType entryType_ = CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY; + +public: + ExternalNodeTableCatalogEntry() = default; + ExternalNodeTableCatalogEntry(CatalogSet* set, std::string name, std::string externalDBName, + std::string externalTableName, std::unique_ptr physicalEntry, + std::string primaryKeyName) + : ExternalTableCatalogEntry{set, entryType_, name, externalDBName, externalTableName, + std::move(physicalEntry)}, + primaryKeyName{std::move(primaryKeyName)} {} + + common::TableType getTableType() const override { return common::TableType::EXTERNAL_NODE; } + + void serialize(common::Serializer& serializer) const override; + static std::unique_ptr deserialize( + common::Deserializer& deserializer); + + std::unique_ptr copy() const override; + +private: + std::unique_ptr getBoundExtraCreateInfo( + transaction::Transaction* transaction) const override; + +private: + std::string primaryKeyName; +}; + +} // namespace catalog +} // namespace kuzu diff --git a/src/include/catalog/catalog_entry/external_table_catalog_entry.h b/src/include/catalog/catalog_entry/external_table_catalog_entry.h new file mode 100644 index 00000000000..d2488dff1f2 --- /dev/null +++ b/src/include/catalog/catalog_entry/external_table_catalog_entry.h @@ -0,0 +1,36 @@ +#pragma once + +#include "table_catalog_entry.h" + +namespace kuzu { +namespace catalog { + +class ExternalTableCatalogEntry : public TableCatalogEntry { +public: + ExternalTableCatalogEntry() = default; + ExternalTableCatalogEntry(CatalogSet* set, CatalogEntryType entryType, std::string name, + std::string externalDBName, std::string externalTableName, + std::unique_ptr physicalEntry) + : TableCatalogEntry{set, entryType, std::move(name)}, + externalDBName{std::move(externalDBName)}, + externalTableName{std::move(externalTableName)}, physicalEntry{std::move(physicalEntry)} { + } + + std::string getExternalDBName() const { return externalDBName; } + std::string getExternalTableName() const { return externalTableName; } + TableCatalogEntry* getPhysicalEntry() const { return physicalEntry.get(); } + + void copyFrom(const CatalogEntry& other) override; + + void serialize(common::Serializer& serializer) const override; + static std::unique_ptr deserialize( + common::Deserializer& deserializer, CatalogEntryType type); + +protected: + std::string externalDBName; + std::string externalTableName; + std::unique_ptr physicalEntry; +}; + +} // namespace catalog +} // namespace kuzu diff --git a/src/include/catalog/catalog_entry/table_catalog_entry.h b/src/include/catalog/catalog_entry/table_catalog_entry.h index 282c3b3f678..ed6762aa311 100644 --- a/src/include/catalog/catalog_entry/table_catalog_entry.h +++ b/src/include/catalog/catalog_entry/table_catalog_entry.h @@ -58,6 +58,7 @@ class KUZU_API TableCatalogEntry : public CatalogEntry { const binder::PropertyDefinition& getProperty(const std::string& propertyName) const; const binder::PropertyDefinition& getProperty(common::idx_t idx) const; virtual common::column_id_t getColumnID(const std::string& propertyName) const; + void addProperties(const std::vector& propertyDefinitions); void addProperty(const binder::PropertyDefinition& propertyDefinition); void dropProperty(const std::string& propertyName); void renameProperty(const std::string& propertyName, const std::string& newName); diff --git a/src/include/common/distinct_vector.h b/src/include/common/distinct_vector.h new file mode 100644 index 00000000000..df89fb7ce56 --- /dev/null +++ b/src/include/common/distinct_vector.h @@ -0,0 +1,27 @@ +#pragma once + +#include +#include + +namespace kuzu { +namespace common { + +// Vector that inserts distinct element only. +template +struct DistinctVector { + std::vector values; + + void add(const T& val) { + if (set.contains(val)) { + return; + } + values.push_back(val); + set.insert(val); + } + +private: + std::unordered_set set; +}; + +} // namespace common +} // namespace kuzu diff --git a/src/include/common/enums/table_type.h b/src/include/common/enums/table_type.h index b41d9137418..a7d30ba1a0a 100644 --- a/src/include/common/enums/table_type.h +++ b/src/include/common/enums/table_type.h @@ -14,6 +14,7 @@ enum class TableType : uint8_t { RDF = 3, REL_GROUP = 4, FOREIGN = 5, + EXTERNAL_NODE = 6, }; struct TableTypeUtils { diff --git a/src/include/function/table/bind_data.h b/src/include/function/table/bind_data.h index 78eccc9a45e..00b118aaf87 100644 --- a/src/include/function/table/bind_data.h +++ b/src/include/function/table/bind_data.h @@ -26,6 +26,7 @@ struct TableFuncBindData { virtual ~TableFuncBindData() = default; common::idx_t getNumColumns() const { return columnTypes.size(); } + bool hasColumnSkips() const { return !columnSkips.empty(); } void setColumnSkips(std::vector skips) { columnSkips = std::move(skips); } KUZU_API std::vector getColumnSkips() const; diff --git a/src/include/optimizer/filter_push_down_optimizer.h b/src/include/optimizer/filter_push_down_optimizer.h index b4def5cf1f6..45c80ee2fe4 100644 --- a/src/include/optimizer/filter_push_down_optimizer.h +++ b/src/include/optimizer/filter_push_down_optimizer.h @@ -74,9 +74,6 @@ class FilterPushDownOptimizer { const binder::expression_vector& predicates, std::shared_ptr child); - std::shared_ptr appendScanNodeTable( - std::shared_ptr nodeID, std::vector nodeTableIDs, - binder::expression_vector properties, std::shared_ptr child); std::shared_ptr appendFilter( std::shared_ptr predicate, std::shared_ptr child); diff --git a/src/include/parser/ddl/create_table.h b/src/include/parser/ddl/create_table.h index 722a37584d8..ec606dab6e0 100644 --- a/src/include/parser/ddl/create_table.h +++ b/src/include/parser/ddl/create_table.h @@ -7,11 +7,12 @@ namespace kuzu { namespace parser { class CreateTable final : public Statement { + static constexpr common::StatementType statementType_ = common::StatementType::CREATE_TABLE; + public: - explicit CreateTable(CreateTableInfo info) - : Statement{common::StatementType::CREATE_TABLE}, info{std::move(info)} {} + explicit CreateTable(CreateTableInfo info) : Statement{statementType_}, info{std::move(info)} {} - inline const CreateTableInfo* getInfo() const { return &info; } + const CreateTableInfo& getInfo() const { return info; } private: CreateTableInfo info; diff --git a/src/include/parser/ddl/create_table_info.h b/src/include/parser/ddl/create_table_info.h index 408563e9cc1..8eec0cff1ec 100644 --- a/src/include/parser/ddl/create_table_info.h +++ b/src/include/parser/ddl/create_table_info.h @@ -28,6 +28,9 @@ struct CreateTableInfo { std::unique_ptr extraInfo; common::ConflictAction onConflict; + CreateTableInfo(common::TableType tableType, std::string tableName) + : tableType{tableType}, tableName{std::move(tableName)}, extraInfo{nullptr}, + onConflict{common::ConflictAction::ON_CONFLICT_THROW} {} CreateTableInfo(common::TableType tableType, std::string tableName, common::ConflictAction onConflict) : tableType{tableType}, tableName{std::move(tableName)}, extraInfo{nullptr}, @@ -41,6 +44,15 @@ struct ExtraCreateNodeTableInfo : public ExtraCreateTableInfo { explicit ExtraCreateNodeTableInfo(std::string pKName) : pKName{std::move(pKName)} {} }; +struct ExtraCreateExternalNodeTableInfo : public ExtraCreateTableInfo { + std::string dbName; + std::string tableName; + std::string pkName; + + ExtraCreateExternalNodeTableInfo(std::string dbName, std::string tableName, std::string pkName) + : dbName{std::move(dbName)}, tableName{std::move(tableName)}, pkName{std::move(pkName)} {} +}; + struct ExtraCreateRelTableInfo : public ExtraCreateTableInfo { std::string relMultiplicity; std::string srcTableName; diff --git a/src/include/parser/transformer.h b/src/include/parser/transformer.h index 5265992c382..ddbb55f2c6a 100644 --- a/src/include/parser/transformer.h +++ b/src/include/parser/transformer.h @@ -200,6 +200,8 @@ class Transformer { std::unique_ptr transformAlterTable(CypherParser::KU_AlterTableContext& ctx); std::unique_ptr transformCreateNodeTable( CypherParser::KU_CreateNodeTableContext& ctx); + std::unique_ptr transformCreateExternalNodeTable( + CypherParser::KU_CreateExternalNodeTableContext& ctx); std::unique_ptr transformCreateRelTable(CypherParser::KU_CreateRelTableContext& ctx); std::unique_ptr transformCreateRelTableGroup( CypherParser::KU_CreateRelTableGroupContext& ctx); @@ -214,7 +216,7 @@ class Transformer { std::unique_ptr transformRenameProperty(CypherParser::KU_AlterTableContext& ctx); std::unique_ptr transformCommentOn(CypherParser::KU_CommentOnContext& ctx); std::string transformDataType(CypherParser::KU_DataTypeContext& ctx); - std::string transformPrimaryKey(CypherParser::KU_CreateNodeConstraintContext& ctx); + std::string transformPrimaryKey(CypherParser::KU_PrimaryKeyContext& ctx); std::vector transformColumnDefinitions( CypherParser::KU_ColumnDefinitionsContext& ctx); ParsedColumnDefinition transformColumnDefinition(CypherParser::KU_ColumnDefinitionContext& ctx); diff --git a/src/include/planner/join_order/cardinality_estimator.h b/src/include/planner/join_order/cardinality_estimator.h index 57806f63897..bd082ce916c 100644 --- a/src/include/planner/join_order/cardinality_estimator.h +++ b/src/include/planner/join_order/cardinality_estimator.h @@ -22,8 +22,9 @@ class CardinalityEstimator { // TODO(Xiyang): revisit this init at some point. Maybe we should init while enumerating. void initNodeIDDom(const binder::QueryGraph& queryGraph, transaction::Transaction* transaction); + void addNodeIDDom(const binder::NodeExpression& node); void addNodeIDDom(const binder::Expression& nodeID, - const std::vector& tableIDs); + const std::vector& entries); uint64_t estimateScanNode(LogicalOperator* op); uint64_t estimateHashJoin(const binder::expression_vector& joinKeys, @@ -38,20 +39,18 @@ class CardinalityEstimator { const binder::NodeExpression& boundNode); private: - uint64_t atLeastOne(uint64_t x) { return x == 0 ? 1 : x; } - - uint64_t getNodeIDDom(const std::string& nodeIDName) { + common::offset_t getNodeIDDom(const std::string& nodeIDName) { KU_ASSERT(nodeIDName2dom.contains(nodeIDName)); return nodeIDName2dom.at(nodeIDName); } - uint64_t getNumNodes(const std::vector& tableIDs); + common::offset_t getNumNodes(const std::vector& entries); - uint64_t getNumRels(const std::vector& tableIDs); + common::offset_t getNumRels(const std::vector& tableIDs); private: main::ClientContext* context; // The domain of nodeID is defined as the number of unique value of nodeID, i.e. num nodes. - std::unordered_map nodeIDName2dom; + std::unordered_map nodeIDName2dom; }; } // namespace planner diff --git a/src/include/planner/operator/logical_hash_join.h b/src/include/planner/operator/logical_hash_join.h index 4856c78ff84..c0dd555f319 100644 --- a/src/include/planner/operator/logical_hash_join.h +++ b/src/include/planner/operator/logical_hash_join.h @@ -41,6 +41,8 @@ class LogicalHashJoin : public LogicalOperator { SIPInfo& getSIPInfoUnsafe() { return sipInfo; } SIPInfo getSIPInfo() const { return sipInfo; } + void vectorizeProbe() { canVectorizeProbe_ = true; } + std::unique_ptr copy() override; // Flat probe side key group in either of the following two cases: @@ -61,6 +63,7 @@ class LogicalHashJoin : public LogicalOperator { common::JoinType joinType; std::shared_ptr mark; // when joinType is Mark or Left SIPInfo sipInfo; + bool canVectorizeProbe_ = false; }; } // namespace planner diff --git a/src/include/planner/operator/scan/logical_scan_node_table.h b/src/include/planner/operator/scan/logical_scan_node_table.h index aa2d8063460..d3d4d35b776 100644 --- a/src/include/planner/operator/scan/logical_scan_node_table.h +++ b/src/include/planner/operator/scan/logical_scan_node_table.h @@ -47,15 +47,23 @@ struct PrimaryKeyScanInfo final : ExtraScanNodeTableInfo { } }; +struct LogicalNodeTableScanInfo { + common::table_id_t tableID; + std::vector columnIDs; + + LogicalNodeTableScanInfo(common::table_id_t tableID, std::vector columnIDs) + : tableID{tableID}, columnIDs{std::move(columnIDs)} {} +}; + class LogicalScanNodeTable final : public LogicalOperator { static constexpr LogicalOperatorType type_ = LogicalOperatorType::SCAN_NODE_TABLE; static constexpr LogicalScanNodeTableType defaultScanType = LogicalScanNodeTableType::SCAN; public: LogicalScanNodeTable(std::shared_ptr nodeID, - std::vector nodeTableIDs, binder::expression_vector properties) + binder::expression_vector properties, std::vector tableScanInfos) : LogicalOperator{type_}, scanType{defaultScanType}, nodeID{std::move(nodeID)}, - nodeTableIDs{std::move(nodeTableIDs)}, properties{std::move(properties)} {} + properties{std::move(properties)}, tableScanInfos{std::move(tableScanInfos)} {} LogicalScanNodeTable(const LogicalScanNodeTable& other); void computeFactorizedSchema() override; @@ -69,7 +77,11 @@ class LogicalScanNodeTable final : public LogicalOperator { void setScanType(LogicalScanNodeTableType scanType_) { scanType = scanType_; } std::shared_ptr getNodeID() const { return nodeID; } - std::vector getTableIDs() const { return nodeTableIDs; } + + const std::vector& getTableScanInfos() const { + return tableScanInfos; + } + std::vector getTableIDs() const; binder::expression_vector getProperties() const { return properties; } void setPropertyPredicates(std::vector predicates) { @@ -88,8 +100,8 @@ class LogicalScanNodeTable final : public LogicalOperator { private: LogicalScanNodeTableType scanType; std::shared_ptr nodeID; - std::vector nodeTableIDs; binder::expression_vector properties; + std::vector tableScanInfos; std::vector propertyPredicates; std::unique_ptr extraInfo; }; diff --git a/src/include/planner/planner.h b/src/include/planner/planner.h index a46a507f8d3..d8fc10f5ab7 100644 --- a/src/include/planner/planner.h +++ b/src/include/planner/planner.h @@ -26,6 +26,7 @@ class BoundProjectionBody; namespace planner { struct LogicalInsertInfo; +struct LogicalNodeTableScanInfo; enum class SubqueryType : uint8_t { NONE = 0, @@ -49,6 +50,7 @@ class PropertyExprCollection { public: void addProperties(const std::string& patternName, std::shared_ptr property); + bool contains(const binder::Expression& pattern, const std::string propertyName) const; binder::expression_vector getProperties(const binder::Expression& pattern) const; binder::expression_vector getProperties() const; @@ -233,9 +235,14 @@ class Planner { // Append scan operators void appendExpressionsScan(const binder::expression_vector& expressions, LogicalPlan& plan); + void appendScanNodeTable(const binder::Expression& node, + const binder::expression_vector& properties, LogicalPlan& plan); void appendScanNodeTable(std::shared_ptr nodeID, - std::vector tableIDs, const binder::expression_vector& properties, - LogicalPlan& plan); + const binder::expression_vector& properties, + const std::vector& entries, LogicalPlan& plan); + void appendScanNodeTable(std::shared_ptr nodeID, + const binder::expression_vector& properties, + const std::vector& tableScanInfos, LogicalPlan& plan); // Append extend operators void appendNonRecursiveExtend(const std::shared_ptr& boundNode, @@ -259,6 +266,9 @@ class Planner { std::unordered_set tableIDSet, LogicalPlan& plan); // Append Join operators + void appendHashJoin(const std::vector& joinConditions, + common::JoinType joinType, std::shared_ptr mark, LogicalPlan& probePlan, + LogicalPlan& buildPlan, LogicalPlan& resultPlan); void appendHashJoin(const binder::expression_vector& joinNodeIDs, common::JoinType joinType, LogicalPlan& probePlan, LogicalPlan& buildPlan, LogicalPlan& resultPlan); void appendHashJoin(const binder::expression_vector& joinNodeIDs, common::JoinType joinType, diff --git a/src/include/storage/storage_manager.h b/src/include/storage/storage_manager.h index 995e16ea218..b81d4a836ca 100644 --- a/src/include/storage/storage_manager.h +++ b/src/include/storage/storage_manager.h @@ -29,18 +29,14 @@ class StorageManager { void checkpoint(main::ClientContext& clientContext); - PrimaryKeyIndex* getPKIndex(common::table_id_t tableID); - - Table* getTable(common::table_id_t tableID) { - std::lock_guard lck{mtx}; - KU_ASSERT(tables.contains(tableID)); - return tables.at(tableID).get(); - } + Table* getTable(common::table_id_t tableID); WAL& getWAL() const; ShadowFile& getShadowFile() const; + FileHandle* getDataFH() const { return dataFH; } FileHandle* getMetadataFH() const { return metadataFH; } + std::string getDatabasePath() const { return databasePath; } bool isReadOnly() const { return readOnly; } bool compressionEnabled() const { return enableCompression; } diff --git a/src/optimizer/filter_push_down_optimizer.cpp b/src/optimizer/filter_push_down_optimizer.cpp index 72ccf15a416..15b5d432ec6 100644 --- a/src/optimizer/filter_push_down_optimizer.cpp +++ b/src/optimizer/filter_push_down_optimizer.cpp @@ -237,18 +237,6 @@ std::shared_ptr FilterPushDownOptimizer::finishPushDown( return root; } -std::shared_ptr FilterPushDownOptimizer::appendScanNodeTable( - std::shared_ptr nodeID, std::vector nodeTableIDs, - binder::expression_vector properties, std::shared_ptr child) { - if (properties.empty()) { - return child; - } - auto scanNodeTable = std::make_shared(std::move(nodeID), - std::move(nodeTableIDs), std::move(properties)); - scanNodeTable->computeFlatSchema(); - return scanNodeTable; -} - std::shared_ptr FilterPushDownOptimizer::appendFilters( const expression_vector& predicates, std::shared_ptr child) { if (predicates.empty()) { diff --git a/src/optimizer/projection_push_down_optimizer.cpp b/src/optimizer/projection_push_down_optimizer.cpp index 3d3ad02c2bd..3f78e03ebc9 100644 --- a/src/optimizer/projection_push_down_optimizer.cpp +++ b/src/optimizer/projection_push_down_optimizer.cpp @@ -233,6 +233,12 @@ void ProjectionPushDownOptimizer::visitCopyFrom(LogicalOperator* op) { void ProjectionPushDownOptimizer::visitTableFunctionCall(LogicalOperator* op) { auto& tableFunctionCall = op->cast(); + // We have an interesting problem here. By default, we scan from external sources, columns are + // bound as variables. So in projection push down, we check "variablesInUse". + // When try to execute cypher over external sources directly, TODO: fnish + if (tableFunctionCall.getBindData()->hasColumnSkips()) { + return; + } std::vector columnSkips; for (auto& column : tableFunctionCall.getColumns()) { columnSkips.push_back(!variablesInUse.contains(column)); diff --git a/src/parser/transform/transform_ddl.cpp b/src/parser/transform/transform_ddl.cpp index c86fa73f11b..4b98535e742 100644 --- a/src/parser/transform/transform_ddl.cpp +++ b/src/parser/transform/transform_ddl.cpp @@ -30,18 +30,31 @@ std::unique_ptr Transformer::transformCreateNodeTable( CypherParser::KU_CreateNodeTableContext& ctx) { auto tableName = transformSchemaName(*ctx.oC_SchemaName()); std::string pkName; - if (ctx.kU_CreateNodeConstraint()) { - pkName = transformPrimaryKey(*ctx.kU_CreateNodeConstraint()); + if (ctx.kU_PrimaryKey()) { + pkName = transformPrimaryKey(*ctx.kU_PrimaryKey()); + } + auto createTableInfo = CreateTableInfo(TableType::NODE, tableName); + if (ctx.kU_IfNotExists()) { + createTableInfo.onConflict = ConflictAction::ON_CONFLICT_DO_NOTHING; } - auto createTableInfo = CreateTableInfo(TableType::NODE, tableName, - ctx.kU_IfNotExists() ? common::ConflictAction::ON_CONFLICT_DO_NOTHING : - common::ConflictAction::ON_CONFLICT_THROW); createTableInfo.propertyDefinitions = transformPropertyDefinitions(*ctx.kU_PropertyDefinitions()); createTableInfo.extraInfo = std::make_unique(pkName); return std::make_unique(std::move(createTableInfo)); } +std::unique_ptr Transformer::transformCreateExternalNodeTable( + CypherParser::KU_CreateExternalNodeTableContext& ctx) { + auto tableName = transformSchemaName(*ctx.oC_SchemaName(0)); + auto createTableInfo = CreateTableInfo(TableType::EXTERNAL_NODE, tableName); + auto dbName = transformSchemaName(*ctx.oC_SchemaName(1)); + auto externalTableName = transformSchemaName(*ctx.kU_TableLookup()->oC_SchemaName()); + auto primaryKeyName = transformPrimaryKey(*ctx.kU_PrimaryKey()); + createTableInfo.extraInfo = std::make_unique(dbName, + externalTableName, primaryKeyName); + return std::make_unique(std::move(createTableInfo)); +} + std::unique_ptr Transformer::transformCreateRelTable( CypherParser::KU_CreateRelTableContext& ctx) { auto tableName = transformSchemaName(*ctx.oC_SchemaName()); @@ -281,7 +294,7 @@ std::string Transformer::transformDataType(CypherParser::KU_DataTypeContext& ctx return ctx.getText(); } -std::string Transformer::transformPrimaryKey(CypherParser::KU_CreateNodeConstraintContext& ctx) { +std::string Transformer::transformPrimaryKey(CypherParser::KU_PrimaryKeyContext& ctx) { return transformPropertyKeyName(*ctx.oC_PropertyKeyName()); } diff --git a/src/parser/transformer.cpp b/src/parser/transformer.cpp index bff5747d6f3..1eb1e8d445f 100644 --- a/src/parser/transformer.cpp +++ b/src/parser/transformer.cpp @@ -32,6 +32,8 @@ std::unique_ptr Transformer::transformStatement(CypherParser::OC_Stat return transformQuery(*ctx.oC_Query()); } else if (ctx.kU_CreateNodeTable()) { return transformCreateNodeTable(*ctx.kU_CreateNodeTable()); + } else if (ctx.kU_CreateExternalNodeTable()) { + return transformCreateExternalNodeTable(*ctx.kU_CreateExternalNodeTable()); } else if (ctx.kU_CreateRelTable()) { return transformCreateRelTable(*ctx.kU_CreateRelTable()); } else if (ctx.kU_CreateRelTableGroup()) { diff --git a/src/planner/join_order/cardinality_estimator.cpp b/src/planner/join_order/cardinality_estimator.cpp index 3afa92359ca..43d3d7abfd7 100644 --- a/src/planner/join_order/cardinality_estimator.cpp +++ b/src/planner/join_order/cardinality_estimator.cpp @@ -1,6 +1,7 @@ #include "planner/join_order/cardinality_estimator.h" #include "binder/expression/property_expression.h" +#include "catalog/catalog_entry/external_table_catalog_entry.h" #include "main/client_context.h" #include "planner/join_order/join_order_util.h" #include "planner/operator/scan/logical_scan_node_table.h" @@ -9,30 +10,38 @@ using namespace kuzu::binder; using namespace kuzu::common; +using namespace kuzu::catalog; using namespace kuzu::transaction; namespace kuzu { namespace planner { +static uint64_t atLeastOne(uint64_t x) { + return x == 0 ? 1 : x; +} + void CardinalityEstimator::initNodeIDDom(const QueryGraph& queryGraph, Transaction*) { for (auto i = 0u; i < queryGraph.getNumQueryNodes(); ++i) { auto node = queryGraph.getQueryNode(i).get(); - addNodeIDDom(*node->getInternalID(), node->getTableIDs()); + addNodeIDDom(*node); } for (auto i = 0u; i < queryGraph.getNumQueryRels(); ++i) { auto rel = queryGraph.getQueryRel(i); if (QueryRelTypeUtils::isRecursive(rel->getRelType())) { - auto node = rel->getRecursiveInfo()->node.get(); - addNodeIDDom(*node->getInternalID(), node->getTableIDs()); + addNodeIDDom(*rel->getRecursiveInfo()->node); } } } -void CardinalityEstimator::addNodeIDDom(const binder::Expression& nodeID, - const std::vector& tableIDs) { +void CardinalityEstimator::addNodeIDDom(const NodeExpression& node) { + addNodeIDDom(*node.getInternalID(), node.getEntries()); +} + +void CardinalityEstimator::addNodeIDDom(const Expression& nodeID, + const std::vector& entries) { auto key = nodeID.getUniqueName(); if (!nodeIDName2dom.contains(key)) { - nodeIDName2dom.insert({key, getNumNodes(tableIDs)}); + nodeIDName2dom.insert({key, getNumNodes(entries)}); } } @@ -106,26 +115,31 @@ uint64_t CardinalityEstimator::estimateFilter(const LogicalPlan& childPlan, } } -uint64_t CardinalityEstimator::getNumNodes(const std::vector& tableIDs) { +uint64_t CardinalityEstimator::getNumNodes(const std::vector& entries) { auto numNodes = 1u; - for (auto& tableID : tableIDs) { + for (auto entry : entries) { + auto tableID = entry->getTableID(); + if (entry->getType() == CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY) { + tableID = + entry->constCast().getPhysicalEntry()->getTableID(); + } numNodes += context->getStorageManager()->getTable(tableID)->getNumRows(); } return atLeastOne(numNodes); } -uint64_t CardinalityEstimator::getNumRels(const std::vector& tableIDs) { +uint64_t CardinalityEstimator::getNumRels(const std::vector& entries) { auto numRels = 1u; - for (auto tableID : tableIDs) { - numRels += context->getStorageManager()->getTable(tableID)->getNumRows(); + for (auto entry : entries) { + numRels += context->getStorageManager()->getTable(entry->getTableID())->getNumRows(); } return atLeastOne(numRels); } double CardinalityEstimator::getExtensionRate(const RelExpression& rel, const NodeExpression& boundNode) { - auto numBoundNodes = (double)getNumNodes(boundNode.getTableIDs()); - auto numRels = (double)getNumRels(rel.getTableIDs()); + auto numBoundNodes = (double)getNumNodes(boundNode.getEntries()); + auto numRels = (double)getNumRels(rel.getEntries()); auto oneHopExtensionRate = numRels / numBoundNodes; switch (rel.getRelType()) { case QueryRelType::NON_RECURSIVE: { diff --git a/src/planner/join_order/join_plan_solver.cpp b/src/planner/join_order/join_plan_solver.cpp index 901c6d918ad..029f77d1ab9 100644 --- a/src/planner/join_order/join_plan_solver.cpp +++ b/src/planner/join_order/join_plan_solver.cpp @@ -58,8 +58,8 @@ LogicalPlan JoinPlanSolver::solveNodeScanTreeNode(const JoinTreeNode& treeNode) auto& nodeInfo = *extraInfo.nodeInfo; auto boundNode = std::static_pointer_cast(nodeInfo.nodeOrRel); auto plan = LogicalPlan(); - planner->appendScanNodeTable(boundNode->getInternalID(), boundNode->getTableIDs(), - nodeInfo.properties, plan); + planner->appendScanNodeTable(boundNode->getInternalID(), nodeInfo.properties, + boundNode->getEntries(), plan); planner->appendFilters(nodeInfo.predicates, plan); for (auto& relInfo : extraInfo.relInfos) { auto rel = std::static_pointer_cast(relInfo.nodeOrRel); @@ -100,8 +100,8 @@ LogicalPlan JoinPlanSolver::solveRelScanTreeNode(const JoinTreeNode& treeNode, } auto direction = getExtendDirection(*rel, *boundNode); auto plan = LogicalPlan(); - planner->appendScanNodeTable(boundNode->getInternalID(), boundNode->getTableIDs(), - expression_vector{}, plan); + planner->appendScanNodeTable(boundNode->getInternalID(), expression_vector{}, + boundNode->getEntries(), plan); planner->appendExtend(boundNode, nbrNode, rel, direction, relInfo.properties, plan); planner->appendFilters(relInfo.predicates, plan); return plan; diff --git a/src/planner/operator/logical_hash_join.cpp b/src/planner/operator/logical_hash_join.cpp index 22d57959dff..8a084a6601a 100644 --- a/src/planner/operator/logical_hash_join.cpp +++ b/src/planner/operator/logical_hash_join.cpp @@ -138,6 +138,7 @@ std::unique_ptr LogicalHashJoin::copy() { auto op = std::make_unique(joinConditions, joinType, mark, children[0]->copy(), children[1]->copy()); op->sipInfo = sipInfo; + op->canVectorizeProbe_ = canVectorizeProbe_; return op; } @@ -161,6 +162,10 @@ binder::expression_vector LogicalHashJoin::getJoinNodeIDs() const { } bool LogicalHashJoin::requireFlatProbeKeys() { + // Overwrite subsequent checks. This happens when we try to join + if (canVectorizeProbe_) { + return false; + } // Flatten for multiple join keys. if (joinConditions.size() > 1) { return true; diff --git a/src/planner/operator/scan/logical_scan_node_table.cpp b/src/planner/operator/scan/logical_scan_node_table.cpp index f87f1036e97..c9c6b256f5b 100644 --- a/src/planner/operator/scan/logical_scan_node_table.cpp +++ b/src/planner/operator/scan/logical_scan_node_table.cpp @@ -5,13 +5,21 @@ namespace planner { LogicalScanNodeTable::LogicalScanNodeTable(const LogicalScanNodeTable& other) : LogicalOperator{type_}, scanType{other.scanType}, nodeID{other.nodeID}, - nodeTableIDs{other.nodeTableIDs}, properties{other.properties}, + properties{other.properties}, tableScanInfos{other.tableScanInfos}, propertyPredicates{copyVector(other.propertyPredicates)} { if (other.extraInfo != nullptr) { setExtraInfo(other.extraInfo->copy()); } } +std::vector LogicalScanNodeTable::getTableIDs() const { + std::vector tableIDs; + for (auto& info : tableScanInfos) { + tableIDs.push_back(info.tableID); + } + return tableIDs; +} + void LogicalScanNodeTable::computeFactorizedSchema() { createEmptySchema(); const auto groupPos = schema->createGroup(); diff --git a/src/planner/plan/append_extend.cpp b/src/planner/plan/append_extend.cpp index 74f217e23a2..9ca06258a36 100644 --- a/src/planner/plan/append_extend.cpp +++ b/src/planner/plan/append_extend.cpp @@ -134,8 +134,8 @@ void Planner::appendNonRecursiveExtend(const std::shared_ptr& bo auto rdfInfo = rel->getRdfPredicateInfo(); // Append hash join for remaining properties auto tmpPlan = std::make_unique(); - cardinalityEstimator.addNodeIDDom(*rdfInfo->predicateID, rdfInfo->resourceTableIDs); - appendScanNodeTable(rdfInfo->predicateID, rdfInfo->resourceTableIDs, expression_vector{iri}, + cardinalityEstimator.addNodeIDDom(*rdfInfo->predicateID, rdfInfo->resourceEntries); + appendScanNodeTable(rdfInfo->predicateID, expression_vector{iri}, rdfInfo->resourceEntries, *tmpPlan); appendHashJoin(expression_vector{rdfInfo->predicateID}, JoinType::INNER, plan, *tmpPlan, plan); @@ -217,8 +217,8 @@ void Planner::createRecursivePlan(const RecursiveInfo& recursiveInfo, ExtendDire auto nbrNode = recursiveInfo.nodeCopy; auto rel = recursiveInfo.rel; auto nodeProperties = collectPropertiesToRead(recursiveInfo.nodePredicate); - appendScanNodeTable(boundNode->getInternalID(), boundNode->getTableIDs(), - ExpressionUtil::removeDuplication(nodeProperties), plan); + appendScanNodeTable(boundNode->getInternalID(), + ExpressionUtil::removeDuplication(nodeProperties), boundNode->getEntries(), plan); auto& scan = plan.getLastOperator()->cast(); scan.setScanType(LogicalScanNodeTableType::OFFSET_SCAN); scan.setExtraInfo(std::make_unique(recursiveInfo.nodePredicateExecFlag)); @@ -237,7 +237,7 @@ void Planner::createRecursivePlan(const RecursiveInfo& recursiveInfo, ExtendDire appendNonRecursiveExtend(boundNode, nbrNode, rel, direction, extendFromSource, ExpressionUtil::removeDuplication(relProperties), plan); auto rdfInfo = rel->getRdfPredicateInfo(); - appendScanNodeTable(rdfInfo->predicateID, rdfInfo->resourceTableIDs, expression_vector{iri}, + appendScanNodeTable(rdfInfo->predicateID, expression_vector{iri}, rdfInfo->resourceEntries, plan); } else { appendNonRecursiveExtend(boundNode, nbrNode, rel, direction, extendFromSource, @@ -250,14 +250,14 @@ void Planner::createRecursivePlan(const RecursiveInfo& recursiveInfo, ExtendDire void Planner::createPathNodePropertyScanPlan(const std::shared_ptr& node, const expression_vector& properties, LogicalPlan& plan) { - appendScanNodeTable(node->getInternalID(), node->getTableIDs(), properties, plan); + appendScanNodeTable(node->getInternalID(), properties, node->getEntries(), plan); } void Planner::createPathRelPropertyScanPlan(const std::shared_ptr& boundNode, const std::shared_ptr& nbrNode, const std::shared_ptr& rel, ExtendDirection direction, bool extendFromSource, const expression_vector& properties, LogicalPlan& plan) { - appendScanNodeTable(boundNode->getInternalID(), boundNode->getTableIDs(), {}, plan); + appendScanNodeTable(boundNode->getInternalID(), {}, boundNode->getEntries(), plan); appendNonRecursiveExtend(boundNode, nbrNode, rel, direction, extendFromSource, properties, plan); appendProjection(properties, plan); diff --git a/src/planner/plan/append_join.cpp b/src/planner/plan/append_join.cpp index bfd4f3a7072..900083a6a3d 100644 --- a/src/planner/plan/append_join.cpp +++ b/src/planner/plan/append_join.cpp @@ -14,13 +14,9 @@ void Planner::appendHashJoin(const expression_vector& joinNodeIDs, JoinType join appendHashJoin(joinNodeIDs, joinType, nullptr /* mark */, probePlan, buildPlan, resultPlan); } -void Planner::appendHashJoin(const expression_vector& joinNodeIDs, JoinType joinType, +void Planner::appendHashJoin(const std::vector& joinConditions, JoinType joinType, std::shared_ptr mark, LogicalPlan& probePlan, LogicalPlan& buildPlan, LogicalPlan& resultPlan) { - std::vector joinConditions; - for (auto& joinNodeID : joinNodeIDs) { - joinConditions.emplace_back(joinNodeID, joinNodeID); - } auto hashJoin = make_shared(joinConditions, joinType, mark, probePlan.getLastOperator(), buildPlan.getLastOperator()); // Apply flattening to probe side @@ -36,12 +32,22 @@ void Planner::appendHashJoin(const expression_vector& joinNodeIDs, JoinType join if (ratio > PlannerKnobs::SIP_RATIO) { hashJoin->getSIPInfoUnsafe().position = SemiMaskPosition::PROHIBIT_PROBE_TO_BUILD; } + resultPlan.setLastOperator(std::move(hashJoin)); +} + +void Planner::appendHashJoin(const expression_vector& joinNodeIDs, JoinType joinType, + std::shared_ptr mark, LogicalPlan& probePlan, LogicalPlan& buildPlan, + LogicalPlan& resultPlan) { + std::vector joinConditions; + for (auto& joinNodeID : joinNodeIDs) { + joinConditions.emplace_back(joinNodeID, joinNodeID); + } + appendHashJoin(joinConditions, joinType, mark, probePlan, buildPlan, resultPlan); // Update cost resultPlan.setCost(CostModel::computeHashJoinCost(joinNodeIDs, probePlan, buildPlan)); // Update cardinality resultPlan.setCardinality( cardinalityEstimator.estimateHashJoin(joinNodeIDs, probePlan, buildPlan)); - resultPlan.setLastOperator(std::move(hashJoin)); } void Planner::appendAccHashJoin(const expression_vector& joinNodeIDs, JoinType joinType, diff --git a/src/planner/plan/append_scan_node_table.cpp b/src/planner/plan/append_scan_node_table.cpp index ca03121d975..b2413e851e4 100644 --- a/src/planner/plan/append_scan_node_table.cpp +++ b/src/planner/plan/append_scan_node_table.cpp @@ -1,8 +1,15 @@ +#include "binder/copy/bound_table_scan_info.h" #include "binder/expression/property_expression.h" +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" +#include "catalog/catalog_entry/node_table_catalog_entry.h" +#include "main/client_context.h" +#include "planner/operator/logical_hash_join.h" +#include "planner/operator/logical_table_function_call.h" #include "planner/operator/scan/logical_scan_node_table.h" #include "planner/planner.h" using namespace kuzu::common; +using namespace kuzu::catalog; using namespace kuzu::binder; namespace kuzu { @@ -19,11 +26,76 @@ static expression_vector removeInternalIDProperty(const expression_vector& expre return result; } +void Planner::appendScanNodeTable(const Expression& expr, const expression_vector& properties, + LogicalPlan& plan) { + auto& node = expr.constCast(); + if (node.hasExternalEntry()) { + auto entry = node.getSingleEntry()->ptrCast(); + // Scan from physical storage the primary key column + auto buildPlan = LogicalPlan(); + auto physicalEntry = entry->getPhysicalEntry()->ptrCast(); + auto pkName = physicalEntry->getPrimaryKeyName(); + auto pkExpr = node.getPropertyExpression(pkName); + std::vector tableScanInfos; + tableScanInfos.emplace_back(physicalEntry->getTableID(), + std::vector{physicalEntry->getColumnID(pkName)}); + appendScanNodeTable(node.getInternalID(), {pkExpr}, tableScanInfos, buildPlan); + // Scan from external table + auto externalEntry = node.getExternalEntry(); + auto scanFunc = externalEntry->getScanFunction(); + auto bindInput = function::ScanTableFuncBindInput(); + auto bindData = scanFunc.bindFunc(clientContext, &bindInput); + auto scanInfo = + BoundTableScanSourceInfo(scanFunc, std::move(bindData), node.getPropertyExprs()); + appendTableFunctionCall(scanInfo, plan); + auto& tableFunctionCall = plan.getLastOperator()->cast(); + std::vector columnSkips; + for (auto i = 0u; i < entry->getNumProperties(); ++i) { + columnSkips.push_back( + !propertyExprCollection.contains(expr, entry->getProperty(i).getName())); + } + tableFunctionCall.setColumnSkips(columnSkips); + // Join external table with internal table. + auto joinCondition = std::make_pair(pkExpr, pkExpr); + std::vector joinConditions; + joinConditions.push_back(joinCondition); + appendHashJoin(joinConditions, JoinType::INNER, nullptr, plan, buildPlan, plan); + plan.getLastOperator()->cast().vectorizeProbe(); + return; + } + appendScanNodeTable(node.getInternalID(), properties, node.getEntries(), plan); +} + +static std::vector getColumnIDs(const TableCatalogEntry& entry, + const expression_vector& properties) { + std::vector columnIDs; + for (auto& expr : properties) { + auto& property = expr->constCast(); + if (!property.hasProperty(entry.getTableID())) { + columnIDs.push_back(INVALID_COLUMN_ID); + continue; + } + columnIDs.push_back(entry.getColumnID(property.getPropertyName())); + } + return columnIDs; +} + void Planner::appendScanNodeTable(std::shared_ptr nodeID, - std::vector tableIDs, const expression_vector& properties, LogicalPlan& plan) { + const expression_vector& properties, const std::vector& entries, + LogicalPlan& plan) { auto propertiesToScan_ = removeInternalIDProperty(properties); - auto scan = make_shared(std::move(nodeID), std::move(tableIDs), - propertiesToScan_); + std::vector tableScanInfos; + for (auto& entry : entries) { + tableScanInfos.emplace_back(entry->getTableID(), getColumnIDs(*entry, propertiesToScan_)); + } + appendScanNodeTable(nodeID, propertiesToScan_, tableScanInfos, plan); +} + +void Planner::appendScanNodeTable(std::shared_ptr nodeID, + const expression_vector& properties, + const std::vector& tableScanInfos, LogicalPlan& plan) { + auto scan = + std::make_shared(std::move(nodeID), properties, tableScanInfos); scan->computeFactorizedSchema(); plan.setCardinality(cardinalityEstimator.estimateScanNode(scan.get())); plan.setLastOperator(std::move(scan)); diff --git a/src/planner/plan/plan_join_order.cpp b/src/planner/plan/plan_join_order.cpp index a9a10926b79..ec434f589a9 100644 --- a/src/planner/plan/plan_join_order.cpp +++ b/src/planner/plan/plan_join_order.cpp @@ -248,7 +248,7 @@ void Planner::planNodeScan(uint32_t nodePos) { newSubgraph.addQueryNode(nodePos); auto plan = std::make_unique(); auto properties = getProperties(*node); - appendScanNodeTable(node->getInternalID(), node->getTableIDs(), properties, *plan); + appendScanNodeTable(*node, properties, *plan); auto predicates = getNewlyMatchedExprs(context.getEmptySubqueryGraph(), newSubgraph, context.getWhereExpressions()); appendFilters(predicates, *plan); @@ -260,7 +260,7 @@ void Planner::planNodeIDScan(uint32_t nodePos) { auto newSubgraph = context.getEmptySubqueryGraph(); newSubgraph.addQueryNode(nodePos); auto plan = std::make_unique(); - appendScanNodeTable(node->getInternalID(), node->getTableIDs(), {}, *plan); + appendScanNodeTable(node->getInternalID(), {}, node->getEntries(), *plan); context.addPlan(newSubgraph, std::move(plan)); } @@ -296,7 +296,7 @@ void Planner::planRelScan(uint32_t relPos) { auto plan = std::make_unique(); auto [boundNode, nbrNode] = getBoundAndNbrNodes(*rel, direction); const auto extendDirection = getExtendDirection(*rel, *boundNode); - appendScanNodeTable(boundNode->getInternalID(), boundNode->getTableIDs(), {}, *plan); + appendScanNodeTable(boundNode->getInternalID(), {}, boundNode->getEntries(), *plan); appendExtend(boundNode, nbrNode, rel, extendDirection, getProperties(*rel), *plan); appendFilters(predicates, *plan); context.addPlan(newSubgraph, std::move(plan)); diff --git a/src/planner/plan/plan_read.cpp b/src/planner/plan/plan_read.cpp index 9c757c72b48..b5713b08a51 100644 --- a/src/planner/plan/plan_read.cpp +++ b/src/planner/plan/plan_read.cpp @@ -153,9 +153,9 @@ void Planner::planGDSCall(const BoundReadingClause& readingClause, if (bindData->hasNodeOutput()) { auto& node = bindData->getNodeOutput()->constCast(); auto scanPlan = LogicalPlan(); - cardinalityEstimator.addNodeIDDom(*node.getInternalID(), node.getTableIDs()); + cardinalityEstimator.addNodeIDDom(node); auto properties = node.getPropertyExprs(); - appendScanNodeTable(node.getInternalID(), node.getTableIDs(), properties, scanPlan); + appendScanNodeTable(node.getInternalID(), properties, node.getEntries(), scanPlan); expression_vector joinConditions; joinConditions.push_back(node.getInternalID()); for (auto& plan : plans) { diff --git a/src/planner/planner.cpp b/src/planner/planner.cpp index 6d022f458b0..7b296f27adc 100644 --- a/src/planner/planner.cpp +++ b/src/planner/planner.cpp @@ -1,6 +1,7 @@ #include "planner/planner.h" #include "binder/bound_explain.h" +#include "binder/expression/property_expression.h" #include "main/client_context.h" using namespace kuzu::binder; @@ -11,6 +12,19 @@ using namespace kuzu::storage; namespace kuzu { namespace planner { +bool PropertyExprCollection::contains(const Expression& pattern, + const std::string propertyName) const { + if (!patternNameToProperties.contains(pattern.getUniqueName())) { + return false; + } + for (auto& expr : patternNameToProperties.at(pattern.getUniqueName())) { + if (expr->constCast().getPropertyName() == propertyName) { + return true; + } + } + return false; +} + expression_vector PropertyExprCollection::getProperties(const Expression& pattern) const { if (!patternNameToProperties.contains(pattern.getUniqueName())) { return binder::expression_vector{}; diff --git a/src/processor/map/map_scan_node_table.cpp b/src/processor/map/map_scan_node_table.cpp index 220c329f899..4a1cee0a83a 100644 --- a/src/processor/map/map_scan_node_table.cpp +++ b/src/processor/map/map_scan_node_table.cpp @@ -14,9 +14,7 @@ namespace kuzu { namespace processor { std::unique_ptr PlanMapper::mapScanNodeTable(LogicalOperator* logicalOperator) { - auto catalog = clientContext->getCatalog(); auto storageManager = clientContext->getStorageManager(); - auto transaction = clientContext->getTx(); auto& scan = logicalOperator->constCast(); const auto outSchema = scan.getSchema(); auto nodeIDPos = getDataPos(*scan.getNodeID(), *outSchema); @@ -25,32 +23,18 @@ std::unique_ptr PlanMapper::mapScanNodeTable(LogicalOperator* outVectorsPos.emplace_back(getDataPos(*expression, *outSchema)); } auto scanInfo = ScanTableInfo(nodeIDPos, outVectorsPos); - const auto tableIDs = scan.getTableIDs(); std::vector tableInfos; std::vector tableNames; - for (const auto& tableID : tableIDs) { - std::vector columnIDs; - for (auto& expression : scan.getProperties()) { - auto& property = expression->constCast(); - if (!property.hasProperty(tableID)) { - columnIDs.push_back(UINT32_MAX); - } else { - auto tableEntry = catalog->getTableCatalogEntry(transaction, tableID); - columnIDs.push_back(tableEntry->getColumnID(property.getPropertyName())); - } - } + std::vector> sharedStates; + for (auto& info : scan.getTableScanInfos()) { + auto tableID = info.tableID; auto table = storageManager->getTable(tableID)->ptrCast(); - tableInfos.emplace_back(table, std::move(columnIDs), + tableInfos.emplace_back(table, std::move(info.columnIDs), copyVector(scan.getPropertyPredicates())); tableNames.push_back(table->getTableName()); - } - std::vector> sharedStates; - for (auto& tableID : tableIDs) { - auto table = storageManager->getTable(tableID)->ptrCast(); auto semiMask = std::make_unique(tableID, table->getNumRows()); sharedStates.push_back(std::make_shared(std::move(semiMask))); } - switch (scan.getScanType()) { case LogicalScanNodeTableType::SCAN: { auto printInfo = std::make_unique(tableNames, scan.getProperties()); diff --git a/src/processor/operator/ddl/create_table.cpp b/src/processor/operator/ddl/create_table.cpp index 2b0806a856a..3d242e04b26 100644 --- a/src/processor/operator/ddl/create_table.cpp +++ b/src/processor/operator/ddl/create_table.cpp @@ -81,7 +81,7 @@ void CreateTable::executeDDLInternal(ExecutionContext* context) { default: break; } - auto newTableID = catalog->createTableSchema(context->clientContext->getTx(), info); + auto newTableID = catalog->createTableEntry(context->clientContext->getTx(), info); tableCreated = true; auto storageManager = context->clientContext->getStorageManager(); storageManager->createTable(newTableID, catalog, context->clientContext); diff --git a/src/storage/storage_manager.cpp b/src/storage/storage_manager.cpp index a5d61b3669e..be43aa508a2 100644 --- a/src/storage/storage_manager.cpp +++ b/src/storage/storage_manager.cpp @@ -1,5 +1,6 @@ #include "storage/storage_manager.h" +#include "catalog/catalog_entry/external_node_table_catalog_entry.h" #include "catalog/catalog_entry/node_table_catalog_entry.h" #include "catalog/catalog_entry/rdf_graph_catalog_entry.h" #include "catalog/catalog_entry/rel_group_catalog_entry.h" @@ -172,6 +173,11 @@ void StorageManager::createTable(table_id_t tableID, const Catalog* catalog, case TableType::NODE: { createNodeTable(tableID, tableEntry->ptrCast(), context); } break; + case TableType::EXTERNAL_NODE: { + auto externalEntry = tableEntry->ptrCast(); + auto nodeEntry = externalEntry->getPhysicalEntry()->ptrCast(); + createNodeTable(nodeEntry->getTableID(), nodeEntry, context); + } break; case TableType::REL: { createRelTable(tableID, tableEntry->ptrCast(), catalog, context->getTx()); @@ -189,12 +195,10 @@ void StorageManager::createTable(table_id_t tableID, const Catalog* catalog, } } -PrimaryKeyIndex* StorageManager::getPKIndex(table_id_t tableID) { +Table* StorageManager::getTable(table_id_t tableID) { std::lock_guard lck{mtx}; KU_ASSERT(tables.contains(tableID)); - KU_ASSERT(tables.at(tableID)->getTableType() == TableType::NODE); - const auto table = ku_dynamic_cast(tables.at(tableID).get()); - return table->getPKIndex(); + return tables.at(tableID).get(); } WAL& StorageManager::getWAL() const { diff --git a/src/storage/wal_replayer.cpp b/src/storage/wal_replayer.cpp index 732f9a3b915..a5c2374a011 100644 --- a/src/storage/wal_replayer.cpp +++ b/src/storage/wal_replayer.cpp @@ -126,7 +126,7 @@ void WALReplayer::replayWALRecord(const WALRecord& walRecord) { void WALReplayer::replayCreateTableEntryRecord(const WALRecord& walRecord) const { auto& createTableEntryRecord = walRecord.constCast(); KU_ASSERT(clientContext.getCatalog()); - auto tableID = clientContext.getCatalog()->createTableSchema(clientContext.getTx(), + auto tableID = clientContext.getCatalog()->createTableEntry(clientContext.getTx(), createTableEntryRecord.boundCreateTableInfo); KU_ASSERT(clientContext.getStorageManager()); clientContext.getStorageManager()->createTable(tableID, clientContext.getCatalog(), diff --git a/src/transaction/transaction.cpp b/src/transaction/transaction.cpp index 9df599a58aa..b60ce9bdaf2 100644 --- a/src/transaction/transaction.cpp +++ b/src/transaction/transaction.cpp @@ -66,6 +66,7 @@ void Transaction::pushCatalogEntry(CatalogSet& catalogSet, CatalogEntry& catalog const auto newCatalogEntry = catalogEntry.getNext(); switch (newCatalogEntry->getType()) { case CatalogEntryType::NODE_TABLE_ENTRY: + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: case CatalogEntryType::REL_TABLE_ENTRY: case CatalogEntryType::REL_GROUP_ENTRY: case CatalogEntryType::RDF_GRAPH_ENTRY: { @@ -107,6 +108,7 @@ void Transaction::pushCatalogEntry(CatalogSet& catalogSet, CatalogEntry& catalog switch (catalogEntry.getType()) { // Eventually we probably want to merge these case CatalogEntryType::NODE_TABLE_ENTRY: + case CatalogEntryType::EXTERNAL_NODE_TABLE_ENTRY: case CatalogEntryType::REL_TABLE_ENTRY: case CatalogEntryType::REL_GROUP_ENTRY: case CatalogEntryType::RDF_GRAPH_ENTRY: { diff --git a/third_party/antlr4_cypher/cypher_lexer.cpp b/third_party/antlr4_cypher/cypher_lexer.cpp index a440b05a173..ada8e0c5d7d 100644 --- a/third_party/antlr4_cypher/cypher_lexer.cpp +++ b/third_party/antlr4_cypher/cypher_lexer.cpp @@ -68,22 +68,23 @@ void cypherlexerLexerInitialize() { "CONTAINS", "COPY", "COUNT", "CREATE", "CYCLE", "DATABASE", "DBTYPE", "DEFAULT", "DELETE", "DESC", "DESCENDING", "DETACH", "DISTINCT", "DROP", "ELSE", "END", "ENDS", "EXISTS", "EXPLAIN", "EXPORT", "EXTENSION", - "FALSE", "FROM", "GLOB", "GRAPH", "GROUP", "HEADERS", "HINT", "IMPORT", - "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN", "KEY", "LIMIT", - "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", "MINVALUE", "MULTI_JOIN", - "NO", "NODE", "NOT", "NONE", "NULL", "ON", "ONLY", "OPTIONAL", "OR", - "ORDER", "PRIMARY", "PROFILE", "PROJECT", "RDFGRAPH", "READ", "REL", - "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", "SEQUENCE", - "SET", "SHORTEST", "START", "STARTS", "TABLE", "THEN", "TO", "TRANSACTION", - "TRUE", "TYPE", "UNION", "UNWIND", "USE", "WHEN", "WHERE", "WITH", - "WRITE", "XOR", "SINGLE", "DECIMAL", "STAR", "L_SKIP", "INVALID_NOT_EQUAL", - "MINUS", "FACTORIAL", "COLON", "StringLiteral", "EscapedChar", "DecimalInteger", - "HexLetter", "HexDigit", "Digit", "NonZeroDigit", "NonZeroOctDigit", - "ZeroDigit", "RegularDecimalReal", "UnescapedSymbolicName", "IdentifierStart", - "IdentifierPart", "EscapedSymbolicName", "SP", "WHITESPACE", "CypherComment", - "FF", "EscapedSymbolicName_0", "RS", "ID_Continue", "Comment_1", "StringLiteral_1", - "Comment_3", "Comment_2", "GS", "FS", "CR", "Sc", "SPACE", "Pc", "TAB", - "StringLiteral_0", "LF", "VT", "US", "ID_Start", "Unknown" + "EXTERNAL", "FALSE", "FROM", "GLOB", "GRAPH", "GROUP", "HEADERS", + "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN", + "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", "MINVALUE", + "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", "ONLY", "OPTIONAL", + "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", "RDFGRAPH", "READ", + "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", + "SEQUENCE", "SET", "SHORTEST", "START", "STARTS", "TABLE", "THEN", + "TO", "TRANSACTION", "TRUE", "TYPE", "UNION", "UNWIND", "USE", "WHEN", + "WHERE", "WITH", "WRITE", "XOR", "SINGLE", "DECIMAL", "STAR", "L_SKIP", + "INVALID_NOT_EQUAL", "MINUS", "FACTORIAL", "COLON", "StringLiteral", + "EscapedChar", "DecimalInteger", "HexLetter", "HexDigit", "Digit", + "NonZeroDigit", "NonZeroOctDigit", "ZeroDigit", "RegularDecimalReal", + "UnescapedSymbolicName", "IdentifierStart", "IdentifierPart", "EscapedSymbolicName", + "SP", "WHITESPACE", "CypherComment", "FF", "EscapedSymbolicName_0", + "RS", "ID_Continue", "Comment_1", "StringLiteral_1", "Comment_3", + "Comment_2", "GS", "FS", "CR", "Sc", "SPACE", "Pc", "TAB", "StringLiteral_0", + "LF", "VT", "US", "ID_Start", "Unknown" }, std::vector{ "DEFAULT_TOKEN_CHANNEL", "HIDDEN" @@ -104,8 +105,8 @@ void cypherlexerLexerInitialize() { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", - "", "", "'*'", "", "'!='", "'-'", "'!'", "':'", "", "", "", "", "", - "", "", "", "'0'" + "", "", "", "'*'", "", "'!='", "'-'", "'!'", "':'", "", "", "", "", + "", "", "", "", "'0'" }, std::vector{ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", @@ -116,12 +117,12 @@ void cypherlexerLexerInitialize() { "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", "GLOB", "GRAPH", "GROUP", "HEADERS", - "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN", - "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", "MINVALUE", - "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", "ONLY", "OPTIONAL", - "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", "RDFGRAPH", "READ", - "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", + "EXTENSION", "EXTERNAL", "FALSE", "FROM", "GLOB", "GRAPH", "GROUP", + "HEADERS", "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", + "JOIN", "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", + "MINVALUE", "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", + "ONLY", "OPTIONAL", "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", + "RDFGRAPH", "READ", "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", "SEQUENCE", "SET", "SHORTEST", "START", "STARTS", "TABLE", "THEN", "TO", "TRANSACTION", "TRUE", "TYPE", "UNION", "UNWIND", "USE", "WHEN", "WHERE", "WITH", "WRITE", "XOR", "SINGLE", "DECIMAL", "STAR", "L_SKIP", @@ -133,7 +134,7 @@ void cypherlexerLexerInitialize() { } ); static const int32_t serializedATNSegment[] = { - 4,0,173,1382,6,-1,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, + 4,0,174,1393,6,-1,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, @@ -162,685 +163,688 @@ void cypherlexerLexerInitialize() { 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,2,186,7,186,2,187,7,187,2,188, - 7,188,2,189,7,189,2,190,7,190,2,191,7,191,2,192,7,192,1,0,1,0,1,1,1,1, - 1,2,1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1,9,1,9,1,10, - 1,10,1,11,1,11,1,11,1,12,1,12,1,12,1,13,1,13,1,14,1,14,1,14,1,15,1,15, - 1,16,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19,1,20,1,20,1,21, - 1,21,1,22,1,22,1,23,1,23,1,24,1,24,1,24,1,25,1,25,1,26,1,26,1,27,1,27, - 1,28,1,28,1,29,1,29,1,30,1,30,1,31,1,31,1,32,1,32,1,33,1,33,1,34,1,34, - 1,35,1,35,1,36,1,36,1,37,1,37,1,38,1,38,1,39,1,39,1,40,1,40,1,41,1,41, - 1,42,1,42,1,43,1,43,1,44,1,44,1,45,1,45,1,45,1,45,1,46,1,46,1,46,1,46, - 1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,1,48,1,49,1,49,1,49,1,49, - 1,50,1,50,1,50,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,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,54,1,54,1,54,1,54, - 1,54,1,54,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,57,1,57,1,57,1,57, - 1,57,1,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59, - 1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,61,1,61,1,61,1,61, - 1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,63,1,63,1,63, + 7,188,2,189,7,189,2,190,7,190,2,191,7,191,2,192,7,192,2,193,7,193,1,0, + 1,0,1,1,1,1,1,2,1,2,1,3,1,3,1,4,1,4,1,5,1,5,1,6,1,6,1,7,1,7,1,8,1,8,1, + 9,1,9,1,10,1,10,1,11,1,11,1,11,1,12,1,12,1,12,1,13,1,13,1,14,1,14,1,14, + 1,15,1,15,1,16,1,16,1,16,1,17,1,17,1,18,1,18,1,18,1,19,1,19,1,19,1,20, + 1,20,1,21,1,21,1,22,1,22,1,23,1,23,1,24,1,24,1,24,1,25,1,25,1,26,1,26, + 1,27,1,27,1,28,1,28,1,29,1,29,1,30,1,30,1,31,1,31,1,32,1,32,1,33,1,33, + 1,34,1,34,1,35,1,35,1,36,1,36,1,37,1,37,1,38,1,38,1,39,1,39,1,40,1,40, + 1,41,1,41,1,42,1,42,1,43,1,43,1,44,1,44,1,45,1,45,1,45,1,45,1,46,1,46, + 1,46,1,46,1,47,1,47,1,47,1,47,1,48,1,48,1,48,1,48,1,48,1,48,1,49,1,49, + 1,49,1,49,1,50,1,50,1,50,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,52,1,52,1,53,1,53,1,53,1,53,1,53,1,53,1,53,1,54,1,54, + 1,54,1,54,1,54,1,54,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,57,1,57, + 1,57,1,57,1,57,1,58,1,58,1,58,1,58,1,58,1,59,1,59,1,59,1,59,1,59,1,59, + 1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,61,1,61, + 1,61,1,61,1,61,1,61,1,61,1,61,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,63, 1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63, - 1,63,1,63,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,64,1,64,1,64,1,64, - 1,64,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,66,1,67,1,67, - 1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68,1,69,1,69,1,69, - 1,69,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70,1,70,1,71, - 1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72,1,72,1,72, - 1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74,1,74, - 1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76,1,76,1,76, - 1,76,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78,1,78,1,78, - 1,79,1,79,1,79,1,79,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,81,1,81,1,81, - 1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,83,1,83,1,83,1,83, - 1,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,85, - 1,85,1,85,1,85,1,85,1,85,1,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1,87, - 1,87,1,88,1,88,1,88,1,88,1,88,1,88,1,89,1,89,1,89,1,89,1,89,1,89,1,90, - 1,90,1,90,1,90,1,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91,1,91,1,92,1,92, - 1,92,1,92,1,92,1,92,1,92,1,93,1,93,1,93,1,94,1,94,1,94,1,95,1,95,1,95, - 1,95,1,95,1,95,1,95,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96,1,96, - 1,96,1,97,1,97,1,97,1,98,1,98,1,98,1,98,1,98,1,99,1,99,1,99,1,99,1,100, - 1,100,1,100,1,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,102,1,102, - 1,102,1,102,1,102,1,102,1,103,1,103,1,103,1,103,1,103,1,103,1,104,1,104, - 1,104,1,104,1,104,1,104,1,104,1,104,1,104,1,105,1,105,1,105,1,105,1,105, - 1,105,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,107,1,107, - 1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,108,1,108,1,108, - 1,109,1,109,1,109,1,109,1,109,1,110,1,110,1,110,1,110,1,111,1,111,1,111, - 1,111,1,111,1,112,1,112,1,112,1,112,1,112,1,113,1,113,1,113,1,114,1,114, - 1,114,1,114,1,114,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115,1,115, - 1,116,1,116,1,116,1,117,1,117,1,117,1,117,1,117,1,117,1,118,1,118,1,118, - 1,118,1,118,1,118,1,118,1,118,1,119,1,119,1,119,1,119,1,119,1,119,1,119, - 1,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,121,1,121,1,121, - 1,121,1,121,1,121,1,121,1,121,1,121,1,122,1,122,1,122,1,122,1,122,1,123, - 1,123,1,123,1,123,1,124,1,124,1,124,1,124,1,124,1,124,1,124,1,125,1,125, - 1,125,1,125,1,125,1,125,1,125,1,126,1,126,1,126,1,126,1,126,1,126,1,126, - 1,126,1,126,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127, - 1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127, - 1,127,1,127,1,127,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, - 1,129,1,129,1,129,1,129,1,130,1,130,1,130,1,130,1,130,1,130,1,130,1,130, - 1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,132,1,132,1,132,1,132,1,132, - 1,132,1,132,1,133,1,133,1,133,1,133,1,133,1,133,1,134,1,134,1,134,1,134, - 1,134,1,135,1,135,1,135,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136, - 1,136,1,136,1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,138,1,138,1,138, - 1,138,1,138,1,139,1,139,1,139,1,139,1,139,1,139,1,140,1,140,1,140,1,140, - 1,140,1,140,1,140,1,141,1,141,1,141,1,141,1,142,1,142,1,142,1,142,1,142, - 1,143,1,143,1,143,1,143,1,143,1,143,1,144,1,144,1,144,1,144,1,144,1,145, - 1,145,1,145,1,145,1,145,1,145,1,146,1,146,1,146,1,146,1,147,1,147,1,147, - 1,147,1,147,1,147,1,147,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148, - 1,149,1,149,1,150,1,150,1,150,1,150,1,150,1,151,1,151,1,151,1,152,1,152, - 1,153,1,153,1,154,1,154,1,155,1,155,1,155,5,155,1186,8,155,10,155,12, - 155,1189,9,155,1,155,1,155,1,155,1,155,5,155,1195,8,155,10,155,12,155, - 1198,9,155,1,155,3,155,1201,8,155,1,156,1,156,1,156,1,156,1,156,1,156, - 1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156, - 3,156,1221,8,156,1,157,1,157,1,157,5,157,1226,8,157,10,157,12,157,1229, - 9,157,3,157,1231,8,157,1,158,3,158,1234,8,158,1,159,1,159,3,159,1238, - 8,159,1,160,1,160,3,160,1242,8,160,1,161,1,161,3,161,1246,8,161,1,162, - 1,162,1,163,1,163,1,164,5,164,1253,8,164,10,164,12,164,1256,9,164,1,164, - 1,164,4,164,1260,8,164,11,164,12,164,1261,1,165,1,165,5,165,1266,8,165, - 10,165,12,165,1269,9,165,1,166,1,166,3,166,1273,8,166,1,167,1,167,3,167, - 1277,8,167,1,168,1,168,5,168,1281,8,168,10,168,12,168,1284,9,168,1,168, - 4,168,1287,8,168,11,168,12,168,1288,1,169,4,169,1292,8,169,11,169,12, - 169,1293,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170,1,170, - 1,170,1,170,3,170,1308,8,170,1,171,1,171,1,171,1,171,1,171,1,171,5,171, - 1316,8,171,10,171,12,171,1319,9,171,1,171,1,171,1,171,1,171,1,171,1,171, - 5,171,1327,8,171,10,171,12,171,1330,9,171,1,171,3,171,1333,8,171,1,171, - 1,171,3,171,1337,8,171,3,171,1339,8,171,1,172,1,172,1,173,1,173,1,174, - 1,174,1,175,1,175,1,176,1,176,1,177,1,177,1,178,1,178,1,179,1,179,1,180, - 1,180,1,181,1,181,1,182,1,182,1,183,1,183,1,184,1,184,1,185,1,185,1,186, - 1,186,1,187,1,187,1,188,1,188,1,189,1,189,1,190,1,190,1,191,1,191,1,192, - 1,192,0,0,193,1,1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23, - 12,25,13,27,14,29,15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23, - 47,24,49,25,51,26,53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34,69, - 35,71,36,73,37,75,38,77,39,79,40,81,41,83,42,85,43,87,44,89,45,91,46, - 93,47,95,48,97,49,99,50,101,51,103,52,105,53,107,54,109,55,111,56,113, - 57,115,58,117,59,119,60,121,61,123,62,125,63,127,64,129,65,131,66,133, - 67,135,68,137,69,139,70,141,71,143,72,145,73,147,74,149,75,151,76,153, - 77,155,78,157,79,159,80,161,81,163,82,165,83,167,84,169,85,171,86,173, - 87,175,88,177,89,179,90,181,91,183,92,185,93,187,94,189,95,191,96,193, - 97,195,98,197,99,199,100,201,101,203,102,205,103,207,104,209,105,211, - 106,213,107,215,108,217,109,219,110,221,111,223,112,225,113,227,114,229, - 115,231,116,233,117,235,118,237,119,239,120,241,121,243,122,245,123,247, - 124,249,125,251,126,253,127,255,128,257,129,259,130,261,131,263,132,265, - 133,267,134,269,135,271,136,273,137,275,138,277,139,279,140,281,141,283, - 142,285,143,287,144,289,145,291,146,293,147,295,148,297,149,299,150,301, - 151,303,152,305,153,307,154,309,155,311,156,313,157,315,158,317,159,319, - 160,321,161,323,162,325,163,327,164,329,165,331,166,333,167,335,168,337, - 169,339,170,341,171,343,172,345,0,347,0,349,0,351,0,353,0,355,0,357,0, - 359,0,361,0,363,0,365,0,367,0,369,0,371,0,373,0,375,0,377,0,379,0,381, - 0,383,0,385,173,1,0,48,2,0,65,65,97,97,2,0,78,78,110,110,2,0,89,89,121, - 121,2,0,68,68,100,100,2,0,76,76,108,108,2,0,84,84,116,116,2,0,69,69,101, - 101,2,0,82,82,114,114,2,0,83,83,115,115,2,0,67,67,99,99,2,0,73,73,105, - 105,2,0,71,71,103,103,2,0,72,72,104,104,2,0,66,66,98,98,2,0,75,75,107, - 107,2,0,80,80,112,112,2,0,79,79,111,111,2,0,85,85,117,117,2,0,77,77,109, - 109,2,0,70,70,102,102,2,0,88,88,120,120,2,0,74,74,106,106,2,0,86,86,118, - 118,2,0,81,81,113,113,2,0,87,87,119,119,13,0,34,34,39,39,66,66,70,70, - 78,78,82,82,84,84,92,92,98,98,102,102,110,110,114,114,116,116,2,0,65, - 70,97,102,8,0,160,160,5760,5760,6158,6158,8192,8202,8232,8233,8239,8239, - 8287,8287,12288,12288,1,0,12,12,1,0,96,96,1,0,30,30,768,0,48,57,65,90, - 95,95,97,122,170,170,181,181,183,183,186,186,192,214,216,246,248,705, - 710,721,736,740,748,748,750,750,768,884,886,887,890,893,895,895,902,906, - 908,908,910,929,931,1013,1015,1153,1155,1159,1162,1327,1329,1366,1369, - 1369,1376,1416,1425,1469,1471,1471,1473,1474,1476,1477,1479,1479,1488, - 1514,1519,1522,1552,1562,1568,1641,1646,1747,1749,1756,1759,1768,1770, - 1788,1791,1791,1808,1866,1869,1969,1984,2037,2042,2042,2045,2045,2048, - 2093,2112,2139,2144,2154,2160,2183,2185,2190,2200,2273,2275,2403,2406, - 2415,2417,2435,2437,2444,2447,2448,2451,2472,2474,2480,2482,2482,2486, - 2489,2492,2500,2503,2504,2507,2510,2519,2519,2524,2525,2527,2531,2534, - 2545,2556,2556,2558,2558,2561,2563,2565,2570,2575,2576,2579,2600,2602, - 2608,2610,2611,2613,2614,2616,2617,2620,2620,2622,2626,2631,2632,2635, - 2637,2641,2641,2649,2652,2654,2654,2662,2677,2689,2691,2693,2701,2703, - 2705,2707,2728,2730,2736,2738,2739,2741,2745,2748,2757,2759,2761,2763, - 2765,2768,2768,2784,2787,2790,2799,2809,2815,2817,2819,2821,2828,2831, - 2832,2835,2856,2858,2864,2866,2867,2869,2873,2876,2884,2887,2888,2891, - 2893,2901,2903,2908,2909,2911,2915,2918,2927,2929,2929,2946,2947,2949, - 2954,2958,2960,2962,2965,2969,2970,2972,2972,2974,2975,2979,2980,2984, - 2986,2990,3001,3006,3010,3014,3016,3018,3021,3024,3024,3031,3031,3046, - 3055,3072,3084,3086,3088,3090,3112,3114,3129,3132,3140,3142,3144,3146, - 3149,3157,3158,3160,3162,3165,3165,3168,3171,3174,3183,3200,3203,3205, - 3212,3214,3216,3218,3240,3242,3251,3253,3257,3260,3268,3270,3272,3274, - 3277,3285,3286,3293,3294,3296,3299,3302,3311,3313,3315,3328,3340,3342, - 3344,3346,3396,3398,3400,3402,3406,3412,3415,3423,3427,3430,3439,3450, - 3455,3457,3459,3461,3478,3482,3505,3507,3515,3517,3517,3520,3526,3530, - 3530,3535,3540,3542,3542,3544,3551,3558,3567,3570,3571,3585,3642,3648, - 3662,3664,3673,3713,3714,3716,3716,3718,3722,3724,3747,3749,3749,3751, - 3773,3776,3780,3782,3782,3784,3790,3792,3801,3804,3807,3840,3840,3864, - 3865,3872,3881,3893,3893,3895,3895,3897,3897,3902,3911,3913,3948,3953, - 3972,3974,3991,3993,4028,4038,4038,4096,4169,4176,4253,4256,4293,4295, - 4295,4301,4301,4304,4346,4348,4680,4682,4685,4688,4694,4696,4696,4698, - 4701,4704,4744,4746,4749,4752,4784,4786,4789,4792,4798,4800,4800,4802, - 4805,4808,4822,4824,4880,4882,4885,4888,4954,4957,4959,4969,4977,4992, - 5007,5024,5109,5112,5117,5121,5740,5743,5759,5761,5786,5792,5866,5870, - 5880,5888,5909,5919,5940,5952,5971,5984,5996,5998,6000,6002,6003,6016, - 6099,6103,6103,6108,6109,6112,6121,6155,6157,6159,6169,6176,6264,6272, - 6314,6320,6389,6400,6430,6432,6443,6448,6459,6470,6509,6512,6516,6528, - 6571,6576,6601,6608,6618,6656,6683,6688,6750,6752,6780,6783,6793,6800, - 6809,6823,6823,6832,6845,6847,6862,6912,6988,6992,7001,7019,7027,7040, - 7155,7168,7223,7232,7241,7245,7293,7296,7304,7312,7354,7357,7359,7376, - 7378,7380,7418,7424,7957,7960,7965,7968,8005,8008,8013,8016,8023,8025, - 8025,8027,8027,8029,8029,8031,8061,8064,8116,8118,8124,8126,8126,8130, - 8132,8134,8140,8144,8147,8150,8155,8160,8172,8178,8180,8182,8188,8255, - 8256,8276,8276,8305,8305,8319,8319,8336,8348,8400,8412,8417,8417,8421, - 8432,8450,8450,8455,8455,8458,8467,8469,8469,8472,8477,8484,8484,8486, - 8486,8488,8488,8490,8505,8508,8511,8517,8521,8526,8526,8544,8584,11264, - 11492,11499,11507,11520,11557,11559,11559,11565,11565,11568,11623,11631, - 11631,11647,11670,11680,11686,11688,11694,11696,11702,11704,11710,11712, - 11718,11720,11726,11728,11734,11736,11742,11744,11775,12293,12295,12321, - 12335,12337,12341,12344,12348,12353,12438,12441,12447,12449,12538,12540, - 12543,12549,12591,12593,12686,12704,12735,12784,12799,13312,19903,19968, - 42124,42192,42237,42240,42508,42512,42539,42560,42607,42612,42621,42623, - 42737,42775,42783,42786,42888,42891,42954,42960,42961,42963,42963,42965, - 42969,42994,43047,43052,43052,43072,43123,43136,43205,43216,43225,43232, - 43255,43259,43259,43261,43309,43312,43347,43360,43388,43392,43456,43471, - 43481,43488,43518,43520,43574,43584,43597,43600,43609,43616,43638,43642, - 43714,43739,43741,43744,43759,43762,43766,43777,43782,43785,43790,43793, - 43798,43808,43814,43816,43822,43824,43866,43868,43881,43888,44010,44012, - 44013,44016,44025,44032,55203,55216,55238,55243,55291,63744,64109,64112, - 64217,64256,64262,64275,64279,64285,64296,64298,64310,64312,64316,64318, + 1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,64,1,64, + 1,64,1,64,1,64,1,65,1,65,1,65,1,65,1,65,1,66,1,66,1,66,1,66,1,66,1,66, + 1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,1,68,1,69, + 1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,1,70,1,70,1,70,1,70,1,70,1,70, + 1,70,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,71,1,72,1,72,1,72,1,72,1,72, + 1,72,1,72,1,73,1,73,1,73,1,73,1,73,1,74,1,74,1,74,1,74,1,74,1,74,1,74, + 1,74,1,74,1,74,1,74,1,75,1,75,1,75,1,75,1,75,1,75,1,75,1,76,1,76,1,76, + 1,76,1,76,1,76,1,76,1,76,1,76,1,77,1,77,1,77,1,77,1,77,1,78,1,78,1,78, + 1,78,1,78,1,79,1,79,1,79,1,79,1,80,1,80,1,80,1,80,1,80,1,81,1,81,1,81, + 1,81,1,81,1,81,1,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,83,1,83, + 1,83,1,83,1,83,1,83,1,83,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84, + 1,84,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,85,1,86,1,86,1,86,1,86, + 1,86,1,86,1,87,1,87,1,87,1,87,1,87,1,88,1,88,1,88,1,88,1,88,1,89,1,89, + 1,89,1,89,1,89,1,89,1,90,1,90,1,90,1,90,1,90,1,90,1,91,1,91,1,91,1,91, + 1,91,1,91,1,91,1,91,1,92,1,92,1,92,1,92,1,92,1,93,1,93,1,93,1,93,1,93, + 1,93,1,93,1,94,1,94,1,94,1,95,1,95,1,95,1,96,1,96,1,96,1,96,1,96,1,96, + 1,96,1,96,1,96,1,96,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,97,1,98,1,98, + 1,98,1,99,1,99,1,99,1,99,1,99,1,100,1,100,1,100,1,100,1,101,1,101,1,101, + 1,101,1,101,1,101,1,102,1,102,1,102,1,102,1,102,1,103,1,103,1,103,1,103, + 1,103,1,103,1,104,1,104,1,104,1,104,1,104,1,104,1,105,1,105,1,105,1,105, + 1,105,1,105,1,105,1,105,1,105,1,106,1,106,1,106,1,106,1,106,1,106,1,107, + 1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,107,1,108,1,108,1,108,1,108, + 1,108,1,108,1,108,1,108,1,108,1,108,1,108,1,109,1,109,1,109,1,110,1,110, + 1,110,1,110,1,110,1,111,1,111,1,111,1,111,1,112,1,112,1,112,1,112,1,112, + 1,113,1,113,1,113,1,113,1,113,1,114,1,114,1,114,1,115,1,115,1,115,1,115, + 1,115,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,116,1,117,1,117, + 1,117,1,118,1,118,1,118,1,118,1,118,1,118,1,119,1,119,1,119,1,119,1,119, + 1,119,1,119,1,119,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,120,1,121, + 1,121,1,121,1,121,1,121,1,121,1,121,1,121,1,122,1,122,1,122,1,122,1,122, + 1,122,1,122,1,122,1,122,1,123,1,123,1,123,1,123,1,123,1,124,1,124,1,124, + 1,124,1,125,1,125,1,125,1,125,1,125,1,125,1,125,1,126,1,126,1,126,1,126, + 1,126,1,126,1,126,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127,1,127, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128, + 1,128,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,129,1,130,1,130, + 1,130,1,130,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,131,1,132, + 1,132,1,132,1,132,1,132,1,132,1,133,1,133,1,133,1,133,1,133,1,133,1,133, + 1,134,1,134,1,134,1,134,1,134,1,134,1,135,1,135,1,135,1,135,1,135,1,136, + 1,136,1,136,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137, + 1,137,1,137,1,138,1,138,1,138,1,138,1,138,1,139,1,139,1,139,1,139,1,139, + 1,140,1,140,1,140,1,140,1,140,1,140,1,141,1,141,1,141,1,141,1,141,1,141, + 1,141,1,142,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,144,1,144, + 1,144,1,144,1,144,1,144,1,145,1,145,1,145,1,145,1,145,1,146,1,146,1,146, + 1,146,1,146,1,146,1,147,1,147,1,147,1,147,1,148,1,148,1,148,1,148,1,148, + 1,148,1,148,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,149,1,150,1,150, + 1,151,1,151,1,151,1,151,1,151,1,152,1,152,1,152,1,153,1,153,1,154,1,154, + 1,155,1,155,1,156,1,156,1,156,5,156,1197,8,156,10,156,12,156,1200,9,156, + 1,156,1,156,1,156,1,156,5,156,1206,8,156,10,156,12,156,1209,9,156,1,156, + 3,156,1212,8,156,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157, + 1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157,1,157,3,157,1232,8,157, + 1,158,1,158,1,158,5,158,1237,8,158,10,158,12,158,1240,9,158,3,158,1242, + 8,158,1,159,3,159,1245,8,159,1,160,1,160,3,160,1249,8,160,1,161,1,161, + 3,161,1253,8,161,1,162,1,162,3,162,1257,8,162,1,163,1,163,1,164,1,164, + 1,165,5,165,1264,8,165,10,165,12,165,1267,9,165,1,165,1,165,4,165,1271, + 8,165,11,165,12,165,1272,1,166,1,166,5,166,1277,8,166,10,166,12,166,1280, + 9,166,1,167,1,167,3,167,1284,8,167,1,168,1,168,3,168,1288,8,168,1,169, + 1,169,5,169,1292,8,169,10,169,12,169,1295,9,169,1,169,4,169,1298,8,169, + 11,169,12,169,1299,1,170,4,170,1303,8,170,11,170,12,170,1304,1,171,1, + 171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,3,171, + 1319,8,171,1,172,1,172,1,172,1,172,1,172,1,172,5,172,1327,8,172,10,172, + 12,172,1330,9,172,1,172,1,172,1,172,1,172,1,172,1,172,5,172,1338,8,172, + 10,172,12,172,1341,9,172,1,172,3,172,1344,8,172,1,172,1,172,3,172,1348, + 8,172,3,172,1350,8,172,1,173,1,173,1,174,1,174,1,175,1,175,1,176,1,176, + 1,177,1,177,1,178,1,178,1,179,1,179,1,180,1,180,1,181,1,181,1,182,1,182, + 1,183,1,183,1,184,1,184,1,185,1,185,1,186,1,186,1,187,1,187,1,188,1,188, + 1,189,1,189,1,190,1,190,1,191,1,191,1,192,1,192,1,193,1,193,0,0,194,1, + 1,3,2,5,3,7,4,9,5,11,6,13,7,15,8,17,9,19,10,21,11,23,12,25,13,27,14,29, + 15,31,16,33,17,35,18,37,19,39,20,41,21,43,22,45,23,47,24,49,25,51,26, + 53,27,55,28,57,29,59,30,61,31,63,32,65,33,67,34,69,35,71,36,73,37,75, + 38,77,39,79,40,81,41,83,42,85,43,87,44,89,45,91,46,93,47,95,48,97,49, + 99,50,101,51,103,52,105,53,107,54,109,55,111,56,113,57,115,58,117,59, + 119,60,121,61,123,62,125,63,127,64,129,65,131,66,133,67,135,68,137,69, + 139,70,141,71,143,72,145,73,147,74,149,75,151,76,153,77,155,78,157,79, + 159,80,161,81,163,82,165,83,167,84,169,85,171,86,173,87,175,88,177,89, + 179,90,181,91,183,92,185,93,187,94,189,95,191,96,193,97,195,98,197,99, + 199,100,201,101,203,102,205,103,207,104,209,105,211,106,213,107,215,108, + 217,109,219,110,221,111,223,112,225,113,227,114,229,115,231,116,233,117, + 235,118,237,119,239,120,241,121,243,122,245,123,247,124,249,125,251,126, + 253,127,255,128,257,129,259,130,261,131,263,132,265,133,267,134,269,135, + 271,136,273,137,275,138,277,139,279,140,281,141,283,142,285,143,287,144, + 289,145,291,146,293,147,295,148,297,149,299,150,301,151,303,152,305,153, + 307,154,309,155,311,156,313,157,315,158,317,159,319,160,321,161,323,162, + 325,163,327,164,329,165,331,166,333,167,335,168,337,169,339,170,341,171, + 343,172,345,173,347,0,349,0,351,0,353,0,355,0,357,0,359,0,361,0,363,0, + 365,0,367,0,369,0,371,0,373,0,375,0,377,0,379,0,381,0,383,0,385,0,387, + 174,1,0,48,2,0,65,65,97,97,2,0,78,78,110,110,2,0,89,89,121,121,2,0,68, + 68,100,100,2,0,76,76,108,108,2,0,84,84,116,116,2,0,69,69,101,101,2,0, + 82,82,114,114,2,0,83,83,115,115,2,0,67,67,99,99,2,0,73,73,105,105,2,0, + 71,71,103,103,2,0,72,72,104,104,2,0,66,66,98,98,2,0,75,75,107,107,2,0, + 80,80,112,112,2,0,79,79,111,111,2,0,85,85,117,117,2,0,77,77,109,109,2, + 0,70,70,102,102,2,0,88,88,120,120,2,0,74,74,106,106,2,0,86,86,118,118, + 2,0,81,81,113,113,2,0,87,87,119,119,13,0,34,34,39,39,66,66,70,70,78,78, + 82,82,84,84,92,92,98,98,102,102,110,110,114,114,116,116,2,0,65,70,97, + 102,8,0,160,160,5760,5760,6158,6158,8192,8202,8232,8233,8239,8239,8287, + 8287,12288,12288,1,0,12,12,1,0,96,96,1,0,30,30,768,0,48,57,65,90,95,95, + 97,122,170,170,181,181,183,183,186,186,192,214,216,246,248,705,710,721, + 736,740,748,748,750,750,768,884,886,887,890,893,895,895,902,906,908,908, + 910,929,931,1013,1015,1153,1155,1159,1162,1327,1329,1366,1369,1369,1376, + 1416,1425,1469,1471,1471,1473,1474,1476,1477,1479,1479,1488,1514,1519, + 1522,1552,1562,1568,1641,1646,1747,1749,1756,1759,1768,1770,1788,1791, + 1791,1808,1866,1869,1969,1984,2037,2042,2042,2045,2045,2048,2093,2112, + 2139,2144,2154,2160,2183,2185,2190,2200,2273,2275,2403,2406,2415,2417, + 2435,2437,2444,2447,2448,2451,2472,2474,2480,2482,2482,2486,2489,2492, + 2500,2503,2504,2507,2510,2519,2519,2524,2525,2527,2531,2534,2545,2556, + 2556,2558,2558,2561,2563,2565,2570,2575,2576,2579,2600,2602,2608,2610, + 2611,2613,2614,2616,2617,2620,2620,2622,2626,2631,2632,2635,2637,2641, + 2641,2649,2652,2654,2654,2662,2677,2689,2691,2693,2701,2703,2705,2707, + 2728,2730,2736,2738,2739,2741,2745,2748,2757,2759,2761,2763,2765,2768, + 2768,2784,2787,2790,2799,2809,2815,2817,2819,2821,2828,2831,2832,2835, + 2856,2858,2864,2866,2867,2869,2873,2876,2884,2887,2888,2891,2893,2901, + 2903,2908,2909,2911,2915,2918,2927,2929,2929,2946,2947,2949,2954,2958, + 2960,2962,2965,2969,2970,2972,2972,2974,2975,2979,2980,2984,2986,2990, + 3001,3006,3010,3014,3016,3018,3021,3024,3024,3031,3031,3046,3055,3072, + 3084,3086,3088,3090,3112,3114,3129,3132,3140,3142,3144,3146,3149,3157, + 3158,3160,3162,3165,3165,3168,3171,3174,3183,3200,3203,3205,3212,3214, + 3216,3218,3240,3242,3251,3253,3257,3260,3268,3270,3272,3274,3277,3285, + 3286,3293,3294,3296,3299,3302,3311,3313,3315,3328,3340,3342,3344,3346, + 3396,3398,3400,3402,3406,3412,3415,3423,3427,3430,3439,3450,3455,3457, + 3459,3461,3478,3482,3505,3507,3515,3517,3517,3520,3526,3530,3530,3535, + 3540,3542,3542,3544,3551,3558,3567,3570,3571,3585,3642,3648,3662,3664, + 3673,3713,3714,3716,3716,3718,3722,3724,3747,3749,3749,3751,3773,3776, + 3780,3782,3782,3784,3790,3792,3801,3804,3807,3840,3840,3864,3865,3872, + 3881,3893,3893,3895,3895,3897,3897,3902,3911,3913,3948,3953,3972,3974, + 3991,3993,4028,4038,4038,4096,4169,4176,4253,4256,4293,4295,4295,4301, + 4301,4304,4346,4348,4680,4682,4685,4688,4694,4696,4696,4698,4701,4704, + 4744,4746,4749,4752,4784,4786,4789,4792,4798,4800,4800,4802,4805,4808, + 4822,4824,4880,4882,4885,4888,4954,4957,4959,4969,4977,4992,5007,5024, + 5109,5112,5117,5121,5740,5743,5759,5761,5786,5792,5866,5870,5880,5888, + 5909,5919,5940,5952,5971,5984,5996,5998,6000,6002,6003,6016,6099,6103, + 6103,6108,6109,6112,6121,6155,6157,6159,6169,6176,6264,6272,6314,6320, + 6389,6400,6430,6432,6443,6448,6459,6470,6509,6512,6516,6528,6571,6576, + 6601,6608,6618,6656,6683,6688,6750,6752,6780,6783,6793,6800,6809,6823, + 6823,6832,6845,6847,6862,6912,6988,6992,7001,7019,7027,7040,7155,7168, + 7223,7232,7241,7245,7293,7296,7304,7312,7354,7357,7359,7376,7378,7380, + 7418,7424,7957,7960,7965,7968,8005,8008,8013,8016,8023,8025,8025,8027, + 8027,8029,8029,8031,8061,8064,8116,8118,8124,8126,8126,8130,8132,8134, + 8140,8144,8147,8150,8155,8160,8172,8178,8180,8182,8188,8255,8256,8276, + 8276,8305,8305,8319,8319,8336,8348,8400,8412,8417,8417,8421,8432,8450, + 8450,8455,8455,8458,8467,8469,8469,8472,8477,8484,8484,8486,8486,8488, + 8488,8490,8505,8508,8511,8517,8521,8526,8526,8544,8584,11264,11492,11499, + 11507,11520,11557,11559,11559,11565,11565,11568,11623,11631,11631,11647, + 11670,11680,11686,11688,11694,11696,11702,11704,11710,11712,11718,11720, + 11726,11728,11734,11736,11742,11744,11775,12293,12295,12321,12335,12337, + 12341,12344,12348,12353,12438,12441,12447,12449,12538,12540,12543,12549, + 12591,12593,12686,12704,12735,12784,12799,13312,19903,19968,42124,42192, + 42237,42240,42508,42512,42539,42560,42607,42612,42621,42623,42737,42775, + 42783,42786,42888,42891,42954,42960,42961,42963,42963,42965,42969,42994, + 43047,43052,43052,43072,43123,43136,43205,43216,43225,43232,43255,43259, + 43259,43261,43309,43312,43347,43360,43388,43392,43456,43471,43481,43488, + 43518,43520,43574,43584,43597,43600,43609,43616,43638,43642,43714,43739, + 43741,43744,43759,43762,43766,43777,43782,43785,43790,43793,43798,43808, + 43814,43816,43822,43824,43866,43868,43881,43888,44010,44012,44013,44016, + 44025,44032,55203,55216,55238,55243,55291,63744,64109,64112,64217,64256, + 64262,64275,64279,64285,64296,64298,64310,64312,64316,64318,64318,64320, + 64321,64323,64324,64326,64433,64467,64829,64848,64911,64914,64967,65008, + 65019,65024,65039,65056,65071,65075,65076,65101,65103,65136,65140,65142, + 65276,65296,65305,65313,65338,65343,65343,65345,65370,65382,65470,65474, + 65479,65482,65487,65490,65495,65498,65500,65536,65547,65549,65574,65576, + 65594,65596,65597,65599,65613,65616,65629,65664,65786,65856,65908,66045, + 66045,66176,66204,66208,66256,66272,66272,66304,66335,66349,66378,66384, + 66426,66432,66461,66464,66499,66504,66511,66513,66517,66560,66717,66720, + 66729,66736,66771,66776,66811,66816,66855,66864,66915,66928,66938,66940, + 66954,66956,66962,66964,66965,66967,66977,66979,66993,66995,67001,67003, + 67004,67072,67382,67392,67413,67424,67431,67456,67461,67463,67504,67506, + 67514,67584,67589,67592,67592,67594,67637,67639,67640,67644,67644,67647, + 67669,67680,67702,67712,67742,67808,67826,67828,67829,67840,67861,67872, + 67897,67968,68023,68030,68031,68096,68099,68101,68102,68108,68115,68117, + 68119,68121,68149,68152,68154,68159,68159,68192,68220,68224,68252,68288, + 68295,68297,68326,68352,68405,68416,68437,68448,68466,68480,68497,68608, + 68680,68736,68786,68800,68850,68864,68903,68912,68921,69248,69289,69291, + 69292,69296,69297,69373,69404,69415,69415,69424,69456,69488,69509,69552, + 69572,69600,69622,69632,69702,69734,69749,69759,69818,69826,69826,69840, + 69864,69872,69881,69888,69940,69942,69951,69956,69959,69968,70003,70006, + 70006,70016,70084,70089,70092,70094,70106,70108,70108,70144,70161,70163, + 70199,70206,70209,70272,70278,70280,70280,70282,70285,70287,70301,70303, + 70312,70320,70378,70384,70393,70400,70403,70405,70412,70415,70416,70419, + 70440,70442,70448,70450,70451,70453,70457,70459,70468,70471,70472,70475, + 70477,70480,70480,70487,70487,70493,70499,70502,70508,70512,70516,70656, + 70730,70736,70745,70750,70753,70784,70853,70855,70855,70864,70873,71040, + 71093,71096,71104,71128,71133,71168,71232,71236,71236,71248,71257,71296, + 71352,71360,71369,71424,71450,71453,71467,71472,71481,71488,71494,71680, + 71738,71840,71913,71935,71942,71945,71945,71948,71955,71957,71958,71960, + 71989,71991,71992,71995,72003,72016,72025,72096,72103,72106,72151,72154, + 72161,72163,72164,72192,72254,72263,72263,72272,72345,72349,72349,72368, + 72440,72704,72712,72714,72758,72760,72768,72784,72793,72818,72847,72850, + 72871,72873,72886,72960,72966,72968,72969,72971,73014,73018,73018,73020, + 73021,73023,73031,73040,73049,73056,73061,73063,73064,73066,73102,73104, + 73105,73107,73112,73120,73129,73440,73462,73472,73488,73490,73530,73534, + 73538,73552,73561,73648,73648,73728,74649,74752,74862,74880,75075,77712, + 77808,77824,78895,78912,78933,82944,83526,92160,92728,92736,92766,92768, + 92777,92784,92862,92864,92873,92880,92909,92912,92916,92928,92982,92992, + 92995,93008,93017,93027,93047,93053,93071,93760,93823,93952,94026,94031, + 94087,94095,94111,94176,94177,94179,94180,94192,94193,94208,100343,100352, + 101589,101632,101640,110576,110579,110581,110587,110589,110590,110592, + 110882,110898,110898,110928,110930,110933,110933,110948,110951,110960, + 111355,113664,113770,113776,113788,113792,113800,113808,113817,113821, + 113822,118528,118573,118576,118598,119141,119145,119149,119154,119163, + 119170,119173,119179,119210,119213,119362,119364,119808,119892,119894, + 119964,119966,119967,119970,119970,119973,119974,119977,119980,119982, + 119993,119995,119995,119997,120003,120005,120069,120071,120074,120077, + 120084,120086,120092,120094,120121,120123,120126,120128,120132,120134, + 120134,120138,120144,120146,120485,120488,120512,120514,120538,120540, + 120570,120572,120596,120598,120628,120630,120654,120656,120686,120688, + 120712,120714,120744,120746,120770,120772,120779,120782,120831,121344, + 121398,121403,121452,121461,121461,121476,121476,121499,121503,121505, + 121519,122624,122654,122661,122666,122880,122886,122888,122904,122907, + 122913,122915,122916,122918,122922,122928,122989,123023,123023,123136, + 123180,123184,123197,123200,123209,123214,123214,123536,123566,123584, + 123641,124112,124153,124896,124902,124904,124907,124909,124910,124912, + 124926,124928,125124,125136,125142,125184,125259,125264,125273,126464, + 126467,126469,126495,126497,126498,126500,126500,126503,126503,126505, + 126514,126516,126519,126521,126521,126523,126523,126530,126530,126535, + 126535,126537,126537,126539,126539,126541,126543,126545,126546,126548, + 126548,126551,126551,126553,126553,126555,126555,126557,126557,126559, + 126559,126561,126562,126564,126564,126567,126570,126572,126578,126580, + 126583,126585,126588,126590,126590,126592,126601,126603,126619,126625, + 126627,126629,126633,126635,126651,130032,130041,131072,173791,173824, + 177977,177984,178205,178208,183969,183984,191456,194560,195101,196608, + 201546,201552,205743,917760,917999,1,0,42,42,2,0,39,39,92,92,2,0,10,10, + 13,13,1,0,47,47,1,0,29,29,1,0,28,28,1,0,13,13,21,0,36,36,162,165,1423, + 1423,1547,1547,2046,2047,2546,2547,2555,2555,2801,2801,3065,3065,3647, + 3647,6107,6107,8352,8384,43064,43064,65020,65020,65129,65129,65284,65284, + 65504,65505,65509,65510,73693,73696,123647,123647,126128,126128,1,0,32, + 32,6,0,95,95,8255,8256,8276,8276,65075,65076,65101,65103,65343,65343, + 1,0,9,9,2,0,34,34,92,92,1,0,10,10,1,0,11,11,1,0,31,31,659,0,65,90,97, + 122,170,170,181,181,186,186,192,214,216,246,248,705,710,721,736,740,748, + 748,750,750,880,884,886,887,890,893,895,895,902,902,904,906,908,908,910, + 929,931,1013,1015,1153,1162,1327,1329,1366,1369,1369,1376,1416,1488,1514, + 1519,1522,1568,1610,1646,1647,1649,1747,1749,1749,1765,1766,1774,1775, + 1786,1788,1791,1791,1808,1808,1810,1839,1869,1957,1969,1969,1994,2026, + 2036,2037,2042,2042,2048,2069,2074,2074,2084,2084,2088,2088,2112,2136, + 2144,2154,2160,2183,2185,2190,2208,2249,2308,2361,2365,2365,2384,2384, + 2392,2401,2417,2432,2437,2444,2447,2448,2451,2472,2474,2480,2482,2482, + 2486,2489,2493,2493,2510,2510,2524,2525,2527,2529,2544,2545,2556,2556, + 2565,2570,2575,2576,2579,2600,2602,2608,2610,2611,2613,2614,2616,2617, + 2649,2652,2654,2654,2674,2676,2693,2701,2703,2705,2707,2728,2730,2736, + 2738,2739,2741,2745,2749,2749,2768,2768,2784,2785,2809,2809,2821,2828, + 2831,2832,2835,2856,2858,2864,2866,2867,2869,2873,2877,2877,2908,2909, + 2911,2913,2929,2929,2947,2947,2949,2954,2958,2960,2962,2965,2969,2970, + 2972,2972,2974,2975,2979,2980,2984,2986,2990,3001,3024,3024,3077,3084, + 3086,3088,3090,3112,3114,3129,3133,3133,3160,3162,3165,3165,3168,3169, + 3200,3200,3205,3212,3214,3216,3218,3240,3242,3251,3253,3257,3261,3261, + 3293,3294,3296,3297,3313,3314,3332,3340,3342,3344,3346,3386,3389,3389, + 3406,3406,3412,3414,3423,3425,3450,3455,3461,3478,3482,3505,3507,3515, + 3517,3517,3520,3526,3585,3632,3634,3635,3648,3654,3713,3714,3716,3716, + 3718,3722,3724,3747,3749,3749,3751,3760,3762,3763,3773,3773,3776,3780, + 3782,3782,3804,3807,3840,3840,3904,3911,3913,3948,3976,3980,4096,4138, + 4159,4159,4176,4181,4186,4189,4193,4193,4197,4198,4206,4208,4213,4225, + 4238,4238,4256,4293,4295,4295,4301,4301,4304,4346,4348,4680,4682,4685, + 4688,4694,4696,4696,4698,4701,4704,4744,4746,4749,4752,4784,4786,4789, + 4792,4798,4800,4800,4802,4805,4808,4822,4824,4880,4882,4885,4888,4954, + 4992,5007,5024,5109,5112,5117,5121,5740,5743,5759,5761,5786,5792,5866, + 5870,5880,5888,5905,5919,5937,5952,5969,5984,5996,5998,6000,6016,6067, + 6103,6103,6108,6108,6176,6264,6272,6312,6314,6314,6320,6389,6400,6430, + 6480,6509,6512,6516,6528,6571,6576,6601,6656,6678,6688,6740,6823,6823, + 6917,6963,6981,6988,7043,7072,7086,7087,7098,7141,7168,7203,7245,7247, + 7258,7293,7296,7304,7312,7354,7357,7359,7401,7404,7406,7411,7413,7414, + 7418,7418,7424,7615,7680,7957,7960,7965,7968,8005,8008,8013,8016,8023, + 8025,8025,8027,8027,8029,8029,8031,8061,8064,8116,8118,8124,8126,8126, + 8130,8132,8134,8140,8144,8147,8150,8155,8160,8172,8178,8180,8182,8188, + 8305,8305,8319,8319,8336,8348,8450,8450,8455,8455,8458,8467,8469,8469, + 8472,8477,8484,8484,8486,8486,8488,8488,8490,8505,8508,8511,8517,8521, + 8526,8526,8544,8584,11264,11492,11499,11502,11506,11507,11520,11557,11559, + 11559,11565,11565,11568,11623,11631,11631,11648,11670,11680,11686,11688, + 11694,11696,11702,11704,11710,11712,11718,11720,11726,11728,11734,11736, + 11742,12293,12295,12321,12329,12337,12341,12344,12348,12353,12438,12443, + 12447,12449,12538,12540,12543,12549,12591,12593,12686,12704,12735,12784, + 12799,13312,19903,19968,42124,42192,42237,42240,42508,42512,42527,42538, + 42539,42560,42606,42623,42653,42656,42735,42775,42783,42786,42888,42891, + 42954,42960,42961,42963,42963,42965,42969,42994,43009,43011,43013,43015, + 43018,43020,43042,43072,43123,43138,43187,43250,43255,43259,43259,43261, + 43262,43274,43301,43312,43334,43360,43388,43396,43442,43471,43471,43488, + 43492,43494,43503,43514,43518,43520,43560,43584,43586,43588,43595,43616, + 43638,43642,43642,43646,43695,43697,43697,43701,43702,43705,43709,43712, + 43712,43714,43714,43739,43741,43744,43754,43762,43764,43777,43782,43785, + 43790,43793,43798,43808,43814,43816,43822,43824,43866,43868,43881,43888, + 44002,44032,55203,55216,55238,55243,55291,63744,64109,64112,64217,64256, + 64262,64275,64279,64285,64285,64287,64296,64298,64310,64312,64316,64318, 64318,64320,64321,64323,64324,64326,64433,64467,64829,64848,64911,64914, - 64967,65008,65019,65024,65039,65056,65071,65075,65076,65101,65103,65136, - 65140,65142,65276,65296,65305,65313,65338,65343,65343,65345,65370,65382, + 64967,65008,65019,65136,65140,65142,65276,65313,65338,65345,65370,65382, 65470,65474,65479,65482,65487,65490,65495,65498,65500,65536,65547,65549, 65574,65576,65594,65596,65597,65599,65613,65616,65629,65664,65786,65856, - 65908,66045,66045,66176,66204,66208,66256,66272,66272,66304,66335,66349, - 66378,66384,66426,66432,66461,66464,66499,66504,66511,66513,66517,66560, - 66717,66720,66729,66736,66771,66776,66811,66816,66855,66864,66915,66928, - 66938,66940,66954,66956,66962,66964,66965,66967,66977,66979,66993,66995, - 67001,67003,67004,67072,67382,67392,67413,67424,67431,67456,67461,67463, - 67504,67506,67514,67584,67589,67592,67592,67594,67637,67639,67640,67644, - 67644,67647,67669,67680,67702,67712,67742,67808,67826,67828,67829,67840, - 67861,67872,67897,67968,68023,68030,68031,68096,68099,68101,68102,68108, - 68115,68117,68119,68121,68149,68152,68154,68159,68159,68192,68220,68224, - 68252,68288,68295,68297,68326,68352,68405,68416,68437,68448,68466,68480, - 68497,68608,68680,68736,68786,68800,68850,68864,68903,68912,68921,69248, - 69289,69291,69292,69296,69297,69373,69404,69415,69415,69424,69456,69488, - 69509,69552,69572,69600,69622,69632,69702,69734,69749,69759,69818,69826, - 69826,69840,69864,69872,69881,69888,69940,69942,69951,69956,69959,69968, - 70003,70006,70006,70016,70084,70089,70092,70094,70106,70108,70108,70144, - 70161,70163,70199,70206,70209,70272,70278,70280,70280,70282,70285,70287, - 70301,70303,70312,70320,70378,70384,70393,70400,70403,70405,70412,70415, - 70416,70419,70440,70442,70448,70450,70451,70453,70457,70459,70468,70471, - 70472,70475,70477,70480,70480,70487,70487,70493,70499,70502,70508,70512, - 70516,70656,70730,70736,70745,70750,70753,70784,70853,70855,70855,70864, - 70873,71040,71093,71096,71104,71128,71133,71168,71232,71236,71236,71248, - 71257,71296,71352,71360,71369,71424,71450,71453,71467,71472,71481,71488, - 71494,71680,71738,71840,71913,71935,71942,71945,71945,71948,71955,71957, - 71958,71960,71989,71991,71992,71995,72003,72016,72025,72096,72103,72106, - 72151,72154,72161,72163,72164,72192,72254,72263,72263,72272,72345,72349, - 72349,72368,72440,72704,72712,72714,72758,72760,72768,72784,72793,72818, - 72847,72850,72871,72873,72886,72960,72966,72968,72969,72971,73014,73018, - 73018,73020,73021,73023,73031,73040,73049,73056,73061,73063,73064,73066, - 73102,73104,73105,73107,73112,73120,73129,73440,73462,73472,73488,73490, - 73530,73534,73538,73552,73561,73648,73648,73728,74649,74752,74862,74880, - 75075,77712,77808,77824,78895,78912,78933,82944,83526,92160,92728,92736, - 92766,92768,92777,92784,92862,92864,92873,92880,92909,92912,92916,92928, - 92982,92992,92995,93008,93017,93027,93047,93053,93071,93760,93823,93952, - 94026,94031,94087,94095,94111,94176,94177,94179,94180,94192,94193,94208, - 100343,100352,101589,101632,101640,110576,110579,110581,110587,110589, - 110590,110592,110882,110898,110898,110928,110930,110933,110933,110948, - 110951,110960,111355,113664,113770,113776,113788,113792,113800,113808, - 113817,113821,113822,118528,118573,118576,118598,119141,119145,119149, - 119154,119163,119170,119173,119179,119210,119213,119362,119364,119808, - 119892,119894,119964,119966,119967,119970,119970,119973,119974,119977, - 119980,119982,119993,119995,119995,119997,120003,120005,120069,120071, - 120074,120077,120084,120086,120092,120094,120121,120123,120126,120128, - 120132,120134,120134,120138,120144,120146,120485,120488,120512,120514, - 120538,120540,120570,120572,120596,120598,120628,120630,120654,120656, - 120686,120688,120712,120714,120744,120746,120770,120772,120779,120782, - 120831,121344,121398,121403,121452,121461,121461,121476,121476,121499, - 121503,121505,121519,122624,122654,122661,122666,122880,122886,122888, - 122904,122907,122913,122915,122916,122918,122922,122928,122989,123023, - 123023,123136,123180,123184,123197,123200,123209,123214,123214,123536, - 123566,123584,123641,124112,124153,124896,124902,124904,124907,124909, - 124910,124912,124926,124928,125124,125136,125142,125184,125259,125264, - 125273,126464,126467,126469,126495,126497,126498,126500,126500,126503, - 126503,126505,126514,126516,126519,126521,126521,126523,126523,126530, - 126530,126535,126535,126537,126537,126539,126539,126541,126543,126545, - 126546,126548,126548,126551,126551,126553,126553,126555,126555,126557, - 126557,126559,126559,126561,126562,126564,126564,126567,126570,126572, - 126578,126580,126583,126585,126588,126590,126590,126592,126601,126603, - 126619,126625,126627,126629,126633,126635,126651,130032,130041,131072, - 173791,173824,177977,177984,178205,178208,183969,183984,191456,194560, - 195101,196608,201546,201552,205743,917760,917999,1,0,42,42,2,0,39,39, - 92,92,2,0,10,10,13,13,1,0,47,47,1,0,29,29,1,0,28,28,1,0,13,13,21,0,36, - 36,162,165,1423,1423,1547,1547,2046,2047,2546,2547,2555,2555,2801,2801, - 3065,3065,3647,3647,6107,6107,8352,8384,43064,43064,65020,65020,65129, - 65129,65284,65284,65504,65505,65509,65510,73693,73696,123647,123647,126128, - 126128,1,0,32,32,6,0,95,95,8255,8256,8276,8276,65075,65076,65101,65103, - 65343,65343,1,0,9,9,2,0,34,34,92,92,1,0,10,10,1,0,11,11,1,0,31,31,659, - 0,65,90,97,122,170,170,181,181,186,186,192,214,216,246,248,705,710,721, - 736,740,748,748,750,750,880,884,886,887,890,893,895,895,902,902,904,906, - 908,908,910,929,931,1013,1015,1153,1162,1327,1329,1366,1369,1369,1376, - 1416,1488,1514,1519,1522,1568,1610,1646,1647,1649,1747,1749,1749,1765, - 1766,1774,1775,1786,1788,1791,1791,1808,1808,1810,1839,1869,1957,1969, - 1969,1994,2026,2036,2037,2042,2042,2048,2069,2074,2074,2084,2084,2088, - 2088,2112,2136,2144,2154,2160,2183,2185,2190,2208,2249,2308,2361,2365, - 2365,2384,2384,2392,2401,2417,2432,2437,2444,2447,2448,2451,2472,2474, - 2480,2482,2482,2486,2489,2493,2493,2510,2510,2524,2525,2527,2529,2544, - 2545,2556,2556,2565,2570,2575,2576,2579,2600,2602,2608,2610,2611,2613, - 2614,2616,2617,2649,2652,2654,2654,2674,2676,2693,2701,2703,2705,2707, - 2728,2730,2736,2738,2739,2741,2745,2749,2749,2768,2768,2784,2785,2809, - 2809,2821,2828,2831,2832,2835,2856,2858,2864,2866,2867,2869,2873,2877, - 2877,2908,2909,2911,2913,2929,2929,2947,2947,2949,2954,2958,2960,2962, - 2965,2969,2970,2972,2972,2974,2975,2979,2980,2984,2986,2990,3001,3024, - 3024,3077,3084,3086,3088,3090,3112,3114,3129,3133,3133,3160,3162,3165, - 3165,3168,3169,3200,3200,3205,3212,3214,3216,3218,3240,3242,3251,3253, - 3257,3261,3261,3293,3294,3296,3297,3313,3314,3332,3340,3342,3344,3346, - 3386,3389,3389,3406,3406,3412,3414,3423,3425,3450,3455,3461,3478,3482, - 3505,3507,3515,3517,3517,3520,3526,3585,3632,3634,3635,3648,3654,3713, - 3714,3716,3716,3718,3722,3724,3747,3749,3749,3751,3760,3762,3763,3773, - 3773,3776,3780,3782,3782,3804,3807,3840,3840,3904,3911,3913,3948,3976, - 3980,4096,4138,4159,4159,4176,4181,4186,4189,4193,4193,4197,4198,4206, - 4208,4213,4225,4238,4238,4256,4293,4295,4295,4301,4301,4304,4346,4348, - 4680,4682,4685,4688,4694,4696,4696,4698,4701,4704,4744,4746,4749,4752, - 4784,4786,4789,4792,4798,4800,4800,4802,4805,4808,4822,4824,4880,4882, - 4885,4888,4954,4992,5007,5024,5109,5112,5117,5121,5740,5743,5759,5761, - 5786,5792,5866,5870,5880,5888,5905,5919,5937,5952,5969,5984,5996,5998, - 6000,6016,6067,6103,6103,6108,6108,6176,6264,6272,6312,6314,6314,6320, - 6389,6400,6430,6480,6509,6512,6516,6528,6571,6576,6601,6656,6678,6688, - 6740,6823,6823,6917,6963,6981,6988,7043,7072,7086,7087,7098,7141,7168, - 7203,7245,7247,7258,7293,7296,7304,7312,7354,7357,7359,7401,7404,7406, - 7411,7413,7414,7418,7418,7424,7615,7680,7957,7960,7965,7968,8005,8008, - 8013,8016,8023,8025,8025,8027,8027,8029,8029,8031,8061,8064,8116,8118, - 8124,8126,8126,8130,8132,8134,8140,8144,8147,8150,8155,8160,8172,8178, - 8180,8182,8188,8305,8305,8319,8319,8336,8348,8450,8450,8455,8455,8458, - 8467,8469,8469,8472,8477,8484,8484,8486,8486,8488,8488,8490,8505,8508, - 8511,8517,8521,8526,8526,8544,8584,11264,11492,11499,11502,11506,11507, - 11520,11557,11559,11559,11565,11565,11568,11623,11631,11631,11648,11670, - 11680,11686,11688,11694,11696,11702,11704,11710,11712,11718,11720,11726, - 11728,11734,11736,11742,12293,12295,12321,12329,12337,12341,12344,12348, - 12353,12438,12443,12447,12449,12538,12540,12543,12549,12591,12593,12686, - 12704,12735,12784,12799,13312,19903,19968,42124,42192,42237,42240,42508, - 42512,42527,42538,42539,42560,42606,42623,42653,42656,42735,42775,42783, - 42786,42888,42891,42954,42960,42961,42963,42963,42965,42969,42994,43009, - 43011,43013,43015,43018,43020,43042,43072,43123,43138,43187,43250,43255, - 43259,43259,43261,43262,43274,43301,43312,43334,43360,43388,43396,43442, - 43471,43471,43488,43492,43494,43503,43514,43518,43520,43560,43584,43586, - 43588,43595,43616,43638,43642,43642,43646,43695,43697,43697,43701,43702, - 43705,43709,43712,43712,43714,43714,43739,43741,43744,43754,43762,43764, - 43777,43782,43785,43790,43793,43798,43808,43814,43816,43822,43824,43866, - 43868,43881,43888,44002,44032,55203,55216,55238,55243,55291,63744,64109, - 64112,64217,64256,64262,64275,64279,64285,64285,64287,64296,64298,64310, - 64312,64316,64318,64318,64320,64321,64323,64324,64326,64433,64467,64829, - 64848,64911,64914,64967,65008,65019,65136,65140,65142,65276,65313,65338, - 65345,65370,65382,65470,65474,65479,65482,65487,65490,65495,65498,65500, - 65536,65547,65549,65574,65576,65594,65596,65597,65599,65613,65616,65629, - 65664,65786,65856,65908,66176,66204,66208,66256,66304,66335,66349,66378, - 66384,66421,66432,66461,66464,66499,66504,66511,66513,66517,66560,66717, - 66736,66771,66776,66811,66816,66855,66864,66915,66928,66938,66940,66954, - 66956,66962,66964,66965,66967,66977,66979,66993,66995,67001,67003,67004, - 67072,67382,67392,67413,67424,67431,67456,67461,67463,67504,67506,67514, - 67584,67589,67592,67592,67594,67637,67639,67640,67644,67644,67647,67669, - 67680,67702,67712,67742,67808,67826,67828,67829,67840,67861,67872,67897, - 67968,68023,68030,68031,68096,68096,68112,68115,68117,68119,68121,68149, - 68192,68220,68224,68252,68288,68295,68297,68324,68352,68405,68416,68437, - 68448,68466,68480,68497,68608,68680,68736,68786,68800,68850,68864,68899, - 69248,69289,69296,69297,69376,69404,69415,69415,69424,69445,69488,69505, - 69552,69572,69600,69622,69635,69687,69745,69746,69749,69749,69763,69807, - 69840,69864,69891,69926,69956,69956,69959,69959,69968,70002,70006,70006, - 70019,70066,70081,70084,70106,70106,70108,70108,70144,70161,70163,70187, - 70207,70208,70272,70278,70280,70280,70282,70285,70287,70301,70303,70312, - 70320,70366,70405,70412,70415,70416,70419,70440,70442,70448,70450,70451, - 70453,70457,70461,70461,70480,70480,70493,70497,70656,70708,70727,70730, - 70751,70753,70784,70831,70852,70853,70855,70855,71040,71086,71128,71131, - 71168,71215,71236,71236,71296,71338,71352,71352,71424,71450,71488,71494, - 71680,71723,71840,71903,71935,71942,71945,71945,71948,71955,71957,71958, - 71960,71983,71999,71999,72001,72001,72096,72103,72106,72144,72161,72161, - 72163,72163,72192,72192,72203,72242,72250,72250,72272,72272,72284,72329, - 72349,72349,72368,72440,72704,72712,72714,72750,72768,72768,72818,72847, - 72960,72966,72968,72969,72971,73008,73030,73030,73056,73061,73063,73064, - 73066,73097,73112,73112,73440,73458,73474,73474,73476,73488,73490,73523, - 73648,73648,73728,74649,74752,74862,74880,75075,77712,77808,77824,78895, - 78913,78918,82944,83526,92160,92728,92736,92766,92784,92862,92880,92909, - 92928,92975,92992,92995,93027,93047,93053,93071,93760,93823,93952,94026, - 94032,94032,94099,94111,94176,94177,94179,94179,94208,100343,100352,101589, - 101632,101640,110576,110579,110581,110587,110589,110590,110592,110882, - 110898,110898,110928,110930,110933,110933,110948,110951,110960,111355, - 113664,113770,113776,113788,113792,113800,113808,113817,119808,119892, - 119894,119964,119966,119967,119970,119970,119973,119974,119977,119980, - 119982,119993,119995,119995,119997,120003,120005,120069,120071,120074, - 120077,120084,120086,120092,120094,120121,120123,120126,120128,120132, - 120134,120134,120138,120144,120146,120485,120488,120512,120514,120538, - 120540,120570,120572,120596,120598,120628,120630,120654,120656,120686, - 120688,120712,120714,120744,120746,120770,120772,120779,122624,122654, - 122661,122666,122928,122989,123136,123180,123191,123197,123214,123214, - 123536,123565,123584,123627,124112,124139,124896,124902,124904,124907, - 124909,124910,124912,124926,124928,125124,125184,125251,125259,125259, - 126464,126467,126469,126495,126497,126498,126500,126500,126503,126503, - 126505,126514,126516,126519,126521,126521,126523,126523,126530,126530, - 126535,126535,126537,126537,126539,126539,126541,126543,126545,126546, - 126548,126548,126551,126551,126553,126553,126555,126555,126557,126557, - 126559,126559,126561,126562,126564,126564,126567,126570,126572,126578, - 126580,126583,126585,126588,126590,126590,126592,126601,126603,126619, - 126625,126627,126629,126633,126635,126651,131072,173791,173824,177977, - 177984,178205,178208,183969,183984,191456,194560,195101,196608,201546, - 201552,205743,1398,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0, - 9,1,0,0,0,0,11,1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1, - 0,0,0,0,21,1,0,0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0, - 0,0,31,1,0,0,0,0,33,1,0,0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0, - 41,1,0,0,0,0,43,1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1, - 0,0,0,0,53,1,0,0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0, - 0,0,63,1,0,0,0,0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0, - 73,1,0,0,0,0,75,1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1, - 0,0,0,0,85,1,0,0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,0, - 0,0,95,1,0,0,0,0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0, - 0,105,1,0,0,0,0,107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0, - 0,115,1,0,0,0,0,117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0,0,0, - 0,125,1,0,0,0,0,127,1,0,0,0,0,129,1,0,0,0,0,131,1,0,0,0,0,133,1,0,0,0, - 0,135,1,0,0,0,0,137,1,0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0, - 0,145,1,0,0,0,0,147,1,0,0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0, - 0,155,1,0,0,0,0,157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0, - 0,165,1,0,0,0,0,167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0, - 0,175,1,0,0,0,0,177,1,0,0,0,0,179,1,0,0,0,0,181,1,0,0,0,0,183,1,0,0,0, - 0,185,1,0,0,0,0,187,1,0,0,0,0,189,1,0,0,0,0,191,1,0,0,0,0,193,1,0,0,0, - 0,195,1,0,0,0,0,197,1,0,0,0,0,199,1,0,0,0,0,201,1,0,0,0,0,203,1,0,0,0, - 0,205,1,0,0,0,0,207,1,0,0,0,0,209,1,0,0,0,0,211,1,0,0,0,0,213,1,0,0,0, - 0,215,1,0,0,0,0,217,1,0,0,0,0,219,1,0,0,0,0,221,1,0,0,0,0,223,1,0,0,0, - 0,225,1,0,0,0,0,227,1,0,0,0,0,229,1,0,0,0,0,231,1,0,0,0,0,233,1,0,0,0, - 0,235,1,0,0,0,0,237,1,0,0,0,0,239,1,0,0,0,0,241,1,0,0,0,0,243,1,0,0,0, - 0,245,1,0,0,0,0,247,1,0,0,0,0,249,1,0,0,0,0,251,1,0,0,0,0,253,1,0,0,0, - 0,255,1,0,0,0,0,257,1,0,0,0,0,259,1,0,0,0,0,261,1,0,0,0,0,263,1,0,0,0, - 0,265,1,0,0,0,0,267,1,0,0,0,0,269,1,0,0,0,0,271,1,0,0,0,0,273,1,0,0,0, - 0,275,1,0,0,0,0,277,1,0,0,0,0,279,1,0,0,0,0,281,1,0,0,0,0,283,1,0,0,0, - 0,285,1,0,0,0,0,287,1,0,0,0,0,289,1,0,0,0,0,291,1,0,0,0,0,293,1,0,0,0, - 0,295,1,0,0,0,0,297,1,0,0,0,0,299,1,0,0,0,0,301,1,0,0,0,0,303,1,0,0,0, - 0,305,1,0,0,0,0,307,1,0,0,0,0,309,1,0,0,0,0,311,1,0,0,0,0,313,1,0,0,0, - 0,315,1,0,0,0,0,317,1,0,0,0,0,319,1,0,0,0,0,321,1,0,0,0,0,323,1,0,0,0, - 0,325,1,0,0,0,0,327,1,0,0,0,0,329,1,0,0,0,0,331,1,0,0,0,0,333,1,0,0,0, - 0,335,1,0,0,0,0,337,1,0,0,0,0,339,1,0,0,0,0,341,1,0,0,0,0,343,1,0,0,0, - 0,385,1,0,0,0,1,387,1,0,0,0,3,389,1,0,0,0,5,391,1,0,0,0,7,393,1,0,0,0, - 9,395,1,0,0,0,11,397,1,0,0,0,13,399,1,0,0,0,15,401,1,0,0,0,17,403,1,0, - 0,0,19,405,1,0,0,0,21,407,1,0,0,0,23,409,1,0,0,0,25,412,1,0,0,0,27,415, - 1,0,0,0,29,417,1,0,0,0,31,420,1,0,0,0,33,422,1,0,0,0,35,425,1,0,0,0,37, - 427,1,0,0,0,39,430,1,0,0,0,41,433,1,0,0,0,43,435,1,0,0,0,45,437,1,0,0, - 0,47,439,1,0,0,0,49,441,1,0,0,0,51,444,1,0,0,0,53,446,1,0,0,0,55,448, - 1,0,0,0,57,450,1,0,0,0,59,452,1,0,0,0,61,454,1,0,0,0,63,456,1,0,0,0,65, - 458,1,0,0,0,67,460,1,0,0,0,69,462,1,0,0,0,71,464,1,0,0,0,73,466,1,0,0, - 0,75,468,1,0,0,0,77,470,1,0,0,0,79,472,1,0,0,0,81,474,1,0,0,0,83,476, - 1,0,0,0,85,478,1,0,0,0,87,480,1,0,0,0,89,482,1,0,0,0,91,484,1,0,0,0,93, - 488,1,0,0,0,95,492,1,0,0,0,97,496,1,0,0,0,99,502,1,0,0,0,101,506,1,0, - 0,0,103,509,1,0,0,0,105,513,1,0,0,0,107,523,1,0,0,0,109,530,1,0,0,0,111, - 536,1,0,0,0,113,539,1,0,0,0,115,544,1,0,0,0,117,549,1,0,0,0,119,554,1, - 0,0,0,121,565,1,0,0,0,123,572,1,0,0,0,125,580,1,0,0,0,127,587,1,0,0,0, - 129,610,1,0,0,0,131,619,1,0,0,0,133,624,1,0,0,0,135,630,1,0,0,0,137,637, - 1,0,0,0,139,643,1,0,0,0,141,652,1,0,0,0,143,659,1,0,0,0,145,667,1,0,0, - 0,147,674,1,0,0,0,149,679,1,0,0,0,151,690,1,0,0,0,153,697,1,0,0,0,155, - 706,1,0,0,0,157,711,1,0,0,0,159,716,1,0,0,0,161,720,1,0,0,0,163,725,1, - 0,0,0,165,732,1,0,0,0,167,740,1,0,0,0,169,747,1,0,0,0,171,757,1,0,0,0, - 173,763,1,0,0,0,175,768,1,0,0,0,177,773,1,0,0,0,179,779,1,0,0,0,181,785, - 1,0,0,0,183,793,1,0,0,0,185,798,1,0,0,0,187,805,1,0,0,0,189,808,1,0,0, - 0,191,811,1,0,0,0,193,821,1,0,0,0,195,829,1,0,0,0,197,832,1,0,0,0,199, - 837,1,0,0,0,201,841,1,0,0,0,203,847,1,0,0,0,205,852,1,0,0,0,207,858,1, - 0,0,0,209,864,1,0,0,0,211,873,1,0,0,0,213,879,1,0,0,0,215,888,1,0,0,0, - 217,899,1,0,0,0,219,902,1,0,0,0,221,907,1,0,0,0,223,911,1,0,0,0,225,916, - 1,0,0,0,227,921,1,0,0,0,229,924,1,0,0,0,231,929,1,0,0,0,233,938,1,0,0, - 0,235,941,1,0,0,0,237,947,1,0,0,0,239,955,1,0,0,0,241,963,1,0,0,0,243, - 971,1,0,0,0,245,980,1,0,0,0,247,985,1,0,0,0,249,989,1,0,0,0,251,996,1, - 0,0,0,253,1003,1,0,0,0,255,1012,1,0,0,0,257,1037,1,0,0,0,259,1046,1,0, - 0,0,261,1050,1,0,0,0,263,1059,1,0,0,0,265,1065,1,0,0,0,267,1072,1,0,0, - 0,269,1078,1,0,0,0,271,1083,1,0,0,0,273,1086,1,0,0,0,275,1098,1,0,0,0, - 277,1103,1,0,0,0,279,1108,1,0,0,0,281,1114,1,0,0,0,283,1121,1,0,0,0,285, - 1125,1,0,0,0,287,1130,1,0,0,0,289,1136,1,0,0,0,291,1141,1,0,0,0,293,1147, - 1,0,0,0,295,1151,1,0,0,0,297,1158,1,0,0,0,299,1166,1,0,0,0,301,1168,1, - 0,0,0,303,1173,1,0,0,0,305,1176,1,0,0,0,307,1178,1,0,0,0,309,1180,1,0, - 0,0,311,1200,1,0,0,0,313,1202,1,0,0,0,315,1230,1,0,0,0,317,1233,1,0,0, - 0,319,1237,1,0,0,0,321,1241,1,0,0,0,323,1245,1,0,0,0,325,1247,1,0,0,0, - 327,1249,1,0,0,0,329,1254,1,0,0,0,331,1263,1,0,0,0,333,1272,1,0,0,0,335, - 1276,1,0,0,0,337,1286,1,0,0,0,339,1291,1,0,0,0,341,1307,1,0,0,0,343,1338, - 1,0,0,0,345,1340,1,0,0,0,347,1342,1,0,0,0,349,1344,1,0,0,0,351,1346,1, - 0,0,0,353,1348,1,0,0,0,355,1350,1,0,0,0,357,1352,1,0,0,0,359,1354,1,0, - 0,0,361,1356,1,0,0,0,363,1358,1,0,0,0,365,1360,1,0,0,0,367,1362,1,0,0, - 0,369,1364,1,0,0,0,371,1366,1,0,0,0,373,1368,1,0,0,0,375,1370,1,0,0,0, - 377,1372,1,0,0,0,379,1374,1,0,0,0,381,1376,1,0,0,0,383,1378,1,0,0,0,385, - 1380,1,0,0,0,387,388,5,59,0,0,388,2,1,0,0,0,389,390,5,40,0,0,390,4,1, - 0,0,0,391,392,5,44,0,0,392,6,1,0,0,0,393,394,5,41,0,0,394,8,1,0,0,0,395, - 396,5,46,0,0,396,10,1,0,0,0,397,398,5,61,0,0,398,12,1,0,0,0,399,400,5, - 91,0,0,400,14,1,0,0,0,401,402,5,93,0,0,402,16,1,0,0,0,403,404,5,123,0, - 0,404,18,1,0,0,0,405,406,5,125,0,0,406,20,1,0,0,0,407,408,5,124,0,0,408, - 22,1,0,0,0,409,410,5,46,0,0,410,411,5,46,0,0,411,24,1,0,0,0,412,413,5, - 60,0,0,413,414,5,62,0,0,414,26,1,0,0,0,415,416,5,60,0,0,416,28,1,0,0, - 0,417,418,5,60,0,0,418,419,5,61,0,0,419,30,1,0,0,0,420,421,5,62,0,0,421, - 32,1,0,0,0,422,423,5,62,0,0,423,424,5,61,0,0,424,34,1,0,0,0,425,426,5, - 38,0,0,426,36,1,0,0,0,427,428,5,62,0,0,428,429,5,62,0,0,429,38,1,0,0, - 0,430,431,5,60,0,0,431,432,5,60,0,0,432,40,1,0,0,0,433,434,5,43,0,0,434, - 42,1,0,0,0,435,436,5,47,0,0,436,44,1,0,0,0,437,438,5,37,0,0,438,46,1, - 0,0,0,439,440,5,94,0,0,440,48,1,0,0,0,441,442,5,61,0,0,442,443,5,126, - 0,0,443,50,1,0,0,0,444,445,5,36,0,0,445,52,1,0,0,0,446,447,5,10216,0, - 0,447,54,1,0,0,0,448,449,5,12296,0,0,449,56,1,0,0,0,450,451,5,65124,0, - 0,451,58,1,0,0,0,452,453,5,65308,0,0,453,60,1,0,0,0,454,455,5,10217,0, - 0,455,62,1,0,0,0,456,457,5,12297,0,0,457,64,1,0,0,0,458,459,5,65125,0, - 0,459,66,1,0,0,0,460,461,5,65310,0,0,461,68,1,0,0,0,462,463,5,173,0,0, - 463,70,1,0,0,0,464,465,5,8208,0,0,465,72,1,0,0,0,466,467,5,8209,0,0,467, - 74,1,0,0,0,468,469,5,8210,0,0,469,76,1,0,0,0,470,471,5,8211,0,0,471,78, - 1,0,0,0,472,473,5,8212,0,0,473,80,1,0,0,0,474,475,5,8213,0,0,475,82,1, - 0,0,0,476,477,5,8722,0,0,477,84,1,0,0,0,478,479,5,65112,0,0,479,86,1, - 0,0,0,480,481,5,65123,0,0,481,88,1,0,0,0,482,483,5,65293,0,0,483,90,1, - 0,0,0,484,485,7,0,0,0,485,486,7,1,0,0,486,487,7,2,0,0,487,92,1,0,0,0, - 488,489,7,0,0,0,489,490,7,3,0,0,490,491,7,3,0,0,491,94,1,0,0,0,492,493, - 7,0,0,0,493,494,7,4,0,0,494,495,7,4,0,0,495,96,1,0,0,0,496,497,7,0,0, - 0,497,498,7,4,0,0,498,499,7,5,0,0,499,500,7,6,0,0,500,501,7,7,0,0,501, - 98,1,0,0,0,502,503,7,0,0,0,503,504,7,1,0,0,504,505,7,3,0,0,505,100,1, - 0,0,0,506,507,7,0,0,0,507,508,7,8,0,0,508,102,1,0,0,0,509,510,7,0,0,0, - 510,511,7,8,0,0,511,512,7,9,0,0,512,104,1,0,0,0,513,514,7,0,0,0,514,515, - 7,8,0,0,515,516,7,9,0,0,516,517,7,6,0,0,517,518,7,1,0,0,518,519,7,3,0, - 0,519,520,7,10,0,0,520,521,7,1,0,0,521,522,7,11,0,0,522,106,1,0,0,0,523, - 524,7,0,0,0,524,525,7,5,0,0,525,526,7,5,0,0,526,527,7,0,0,0,527,528,7, - 9,0,0,528,529,7,12,0,0,529,108,1,0,0,0,530,531,7,13,0,0,531,532,7,6,0, - 0,532,533,7,11,0,0,533,534,7,10,0,0,534,535,7,1,0,0,535,110,1,0,0,0,536, - 537,7,13,0,0,537,538,7,2,0,0,538,112,1,0,0,0,539,540,7,9,0,0,540,541, - 7,0,0,0,541,542,7,4,0,0,542,543,7,4,0,0,543,114,1,0,0,0,544,545,7,9,0, - 0,545,546,7,0,0,0,546,547,7,8,0,0,547,548,7,6,0,0,548,116,1,0,0,0,549, - 550,7,9,0,0,550,551,7,0,0,0,551,552,7,8,0,0,552,553,7,5,0,0,553,118,1, - 0,0,0,554,555,7,9,0,0,555,556,7,12,0,0,556,557,7,6,0,0,557,558,7,9,0, - 0,558,559,7,14,0,0,559,560,7,15,0,0,560,561,7,16,0,0,561,562,7,10,0,0, - 562,563,7,1,0,0,563,564,7,5,0,0,564,120,1,0,0,0,565,566,7,9,0,0,566,567, - 7,16,0,0,567,568,7,4,0,0,568,569,7,17,0,0,569,570,7,18,0,0,570,571,7, - 1,0,0,571,122,1,0,0,0,572,573,7,9,0,0,573,574,7,16,0,0,574,575,7,18,0, - 0,575,576,7,18,0,0,576,577,7,6,0,0,577,578,7,1,0,0,578,579,7,5,0,0,579, - 124,1,0,0,0,580,581,7,9,0,0,581,582,7,16,0,0,582,583,7,18,0,0,583,584, - 7,18,0,0,584,585,7,10,0,0,585,586,7,5,0,0,586,126,1,0,0,0,587,588,7,9, - 0,0,588,589,7,16,0,0,589,590,7,18,0,0,590,591,7,18,0,0,591,592,7,10,0, - 0,592,593,7,5,0,0,593,594,5,95,0,0,594,595,7,8,0,0,595,596,7,14,0,0,596, - 597,7,10,0,0,597,598,7,15,0,0,598,599,5,95,0,0,599,600,7,9,0,0,600,601, - 7,12,0,0,601,602,7,6,0,0,602,603,7,9,0,0,603,604,7,14,0,0,604,605,7,15, - 0,0,605,606,7,16,0,0,606,607,7,10,0,0,607,608,7,1,0,0,608,609,7,5,0,0, - 609,128,1,0,0,0,610,611,7,9,0,0,611,612,7,16,0,0,612,613,7,1,0,0,613, - 614,7,5,0,0,614,615,7,0,0,0,615,616,7,10,0,0,616,617,7,1,0,0,617,618, - 7,8,0,0,618,130,1,0,0,0,619,620,7,9,0,0,620,621,7,16,0,0,621,622,7,15, - 0,0,622,623,7,2,0,0,623,132,1,0,0,0,624,625,7,9,0,0,625,626,7,16,0,0, - 626,627,7,17,0,0,627,628,7,1,0,0,628,629,7,5,0,0,629,134,1,0,0,0,630, - 631,7,9,0,0,631,632,7,7,0,0,632,633,7,6,0,0,633,634,7,0,0,0,634,635,7, - 5,0,0,635,636,7,6,0,0,636,136,1,0,0,0,637,638,7,9,0,0,638,639,7,2,0,0, - 639,640,7,9,0,0,640,641,7,4,0,0,641,642,7,6,0,0,642,138,1,0,0,0,643,644, - 7,3,0,0,644,645,7,0,0,0,645,646,7,5,0,0,646,647,7,0,0,0,647,648,7,13, - 0,0,648,649,7,0,0,0,649,650,7,8,0,0,650,651,7,6,0,0,651,140,1,0,0,0,652, - 653,7,3,0,0,653,654,7,13,0,0,654,655,7,5,0,0,655,656,7,2,0,0,656,657, - 7,15,0,0,657,658,7,6,0,0,658,142,1,0,0,0,659,660,7,3,0,0,660,661,7,6, - 0,0,661,662,7,19,0,0,662,663,7,0,0,0,663,664,7,17,0,0,664,665,7,4,0,0, - 665,666,7,5,0,0,666,144,1,0,0,0,667,668,7,3,0,0,668,669,7,6,0,0,669,670, - 7,4,0,0,670,671,7,6,0,0,671,672,7,5,0,0,672,673,7,6,0,0,673,146,1,0,0, - 0,674,675,7,3,0,0,675,676,7,6,0,0,676,677,7,8,0,0,677,678,7,9,0,0,678, - 148,1,0,0,0,679,680,7,3,0,0,680,681,7,6,0,0,681,682,7,8,0,0,682,683,7, - 9,0,0,683,684,7,6,0,0,684,685,7,1,0,0,685,686,7,3,0,0,686,687,7,10,0, - 0,687,688,7,1,0,0,688,689,7,11,0,0,689,150,1,0,0,0,690,691,7,3,0,0,691, - 692,7,6,0,0,692,693,7,5,0,0,693,694,7,0,0,0,694,695,7,9,0,0,695,696,7, - 12,0,0,696,152,1,0,0,0,697,698,7,3,0,0,698,699,7,10,0,0,699,700,7,8,0, - 0,700,701,7,5,0,0,701,702,7,10,0,0,702,703,7,1,0,0,703,704,7,9,0,0,704, - 705,7,5,0,0,705,154,1,0,0,0,706,707,7,3,0,0,707,708,7,7,0,0,708,709,7, - 16,0,0,709,710,7,15,0,0,710,156,1,0,0,0,711,712,7,6,0,0,712,713,7,4,0, - 0,713,714,7,8,0,0,714,715,7,6,0,0,715,158,1,0,0,0,716,717,7,6,0,0,717, - 718,7,1,0,0,718,719,7,3,0,0,719,160,1,0,0,0,720,721,7,6,0,0,721,722,7, - 1,0,0,722,723,7,3,0,0,723,724,7,8,0,0,724,162,1,0,0,0,725,726,7,6,0,0, - 726,727,7,20,0,0,727,728,7,10,0,0,728,729,7,8,0,0,729,730,7,5,0,0,730, - 731,7,8,0,0,731,164,1,0,0,0,732,733,7,6,0,0,733,734,7,20,0,0,734,735, - 7,15,0,0,735,736,7,4,0,0,736,737,7,0,0,0,737,738,7,10,0,0,738,739,7,1, - 0,0,739,166,1,0,0,0,740,741,7,6,0,0,741,742,7,20,0,0,742,743,7,15,0,0, - 743,744,7,16,0,0,744,745,7,7,0,0,745,746,7,5,0,0,746,168,1,0,0,0,747, - 748,7,6,0,0,748,749,7,20,0,0,749,750,7,5,0,0,750,751,7,6,0,0,751,752, - 7,1,0,0,752,753,7,8,0,0,753,754,7,10,0,0,754,755,7,16,0,0,755,756,7,1, - 0,0,756,170,1,0,0,0,757,758,7,19,0,0,758,759,7,0,0,0,759,760,7,4,0,0, - 760,761,7,8,0,0,761,762,7,6,0,0,762,172,1,0,0,0,763,764,7,19,0,0,764, - 765,7,7,0,0,765,766,7,16,0,0,766,767,7,18,0,0,767,174,1,0,0,0,768,769, - 7,11,0,0,769,770,7,4,0,0,770,771,7,16,0,0,771,772,7,13,0,0,772,176,1, - 0,0,0,773,774,7,11,0,0,774,775,7,7,0,0,775,776,7,0,0,0,776,777,7,15,0, - 0,777,778,7,12,0,0,778,178,1,0,0,0,779,780,7,11,0,0,780,781,7,7,0,0,781, - 782,7,16,0,0,782,783,7,17,0,0,783,784,7,15,0,0,784,180,1,0,0,0,785,786, - 7,12,0,0,786,787,7,6,0,0,787,788,7,0,0,0,788,789,7,3,0,0,789,790,7,6, - 0,0,790,791,7,7,0,0,791,792,7,8,0,0,792,182,1,0,0,0,793,794,7,12,0,0, - 794,795,7,10,0,0,795,796,7,1,0,0,796,797,7,5,0,0,797,184,1,0,0,0,798, - 799,7,10,0,0,799,800,7,18,0,0,800,801,7,15,0,0,801,802,7,16,0,0,802,803, - 7,7,0,0,803,804,7,5,0,0,804,186,1,0,0,0,805,806,7,10,0,0,806,807,7,19, - 0,0,807,188,1,0,0,0,808,809,7,10,0,0,809,810,7,1,0,0,810,190,1,0,0,0, - 811,812,7,10,0,0,812,813,7,1,0,0,813,814,7,9,0,0,814,815,7,7,0,0,815, - 816,7,6,0,0,816,817,7,18,0,0,817,818,7,6,0,0,818,819,7,1,0,0,819,820, - 7,5,0,0,820,192,1,0,0,0,821,822,7,10,0,0,822,823,7,1,0,0,823,824,7,8, - 0,0,824,825,7,5,0,0,825,826,7,0,0,0,826,827,7,4,0,0,827,828,7,4,0,0,828, - 194,1,0,0,0,829,830,7,10,0,0,830,831,7,8,0,0,831,196,1,0,0,0,832,833, - 7,21,0,0,833,834,7,16,0,0,834,835,7,10,0,0,835,836,7,1,0,0,836,198,1, - 0,0,0,837,838,7,14,0,0,838,839,7,6,0,0,839,840,7,2,0,0,840,200,1,0,0, - 0,841,842,7,4,0,0,842,843,7,10,0,0,843,844,7,18,0,0,844,845,7,10,0,0, - 845,846,7,5,0,0,846,202,1,0,0,0,847,848,7,4,0,0,848,849,7,16,0,0,849, - 850,7,0,0,0,850,851,7,3,0,0,851,204,1,0,0,0,852,853,7,18,0,0,853,854, - 7,0,0,0,854,855,7,9,0,0,855,856,7,7,0,0,856,857,7,16,0,0,857,206,1,0, - 0,0,858,859,7,18,0,0,859,860,7,0,0,0,860,861,7,5,0,0,861,862,7,9,0,0, - 862,863,7,12,0,0,863,208,1,0,0,0,864,865,7,18,0,0,865,866,7,0,0,0,866, - 867,7,20,0,0,867,868,7,22,0,0,868,869,7,0,0,0,869,870,7,4,0,0,870,871, - 7,17,0,0,871,872,7,6,0,0,872,210,1,0,0,0,873,874,7,18,0,0,874,875,7,6, - 0,0,875,876,7,7,0,0,876,877,7,11,0,0,877,878,7,6,0,0,878,212,1,0,0,0, - 879,880,7,18,0,0,880,881,7,10,0,0,881,882,7,1,0,0,882,883,7,22,0,0,883, - 884,7,0,0,0,884,885,7,4,0,0,885,886,7,17,0,0,886,887,7,6,0,0,887,214, - 1,0,0,0,888,889,7,18,0,0,889,890,7,17,0,0,890,891,7,4,0,0,891,892,7,5, - 0,0,892,893,7,10,0,0,893,894,5,95,0,0,894,895,7,21,0,0,895,896,7,16,0, - 0,896,897,7,10,0,0,897,898,7,1,0,0,898,216,1,0,0,0,899,900,7,1,0,0,900, - 901,7,16,0,0,901,218,1,0,0,0,902,903,7,1,0,0,903,904,7,16,0,0,904,905, - 7,3,0,0,905,906,7,6,0,0,906,220,1,0,0,0,907,908,7,1,0,0,908,909,7,16, - 0,0,909,910,7,5,0,0,910,222,1,0,0,0,911,912,7,1,0,0,912,913,7,16,0,0, - 913,914,7,1,0,0,914,915,7,6,0,0,915,224,1,0,0,0,916,917,7,1,0,0,917,918, - 7,17,0,0,918,919,7,4,0,0,919,920,7,4,0,0,920,226,1,0,0,0,921,922,7,16, - 0,0,922,923,7,1,0,0,923,228,1,0,0,0,924,925,7,16,0,0,925,926,7,1,0,0, - 926,927,7,4,0,0,927,928,7,2,0,0,928,230,1,0,0,0,929,930,7,16,0,0,930, - 931,7,15,0,0,931,932,7,5,0,0,932,933,7,10,0,0,933,934,7,16,0,0,934,935, - 7,1,0,0,935,936,7,0,0,0,936,937,7,4,0,0,937,232,1,0,0,0,938,939,7,16, - 0,0,939,940,7,7,0,0,940,234,1,0,0,0,941,942,7,16,0,0,942,943,7,7,0,0, - 943,944,7,3,0,0,944,945,7,6,0,0,945,946,7,7,0,0,946,236,1,0,0,0,947,948, - 7,15,0,0,948,949,7,7,0,0,949,950,7,10,0,0,950,951,7,18,0,0,951,952,7, - 0,0,0,952,953,7,7,0,0,953,954,7,2,0,0,954,238,1,0,0,0,955,956,7,15,0, - 0,956,957,7,7,0,0,957,958,7,16,0,0,958,959,7,19,0,0,959,960,7,10,0,0, - 960,961,7,4,0,0,961,962,7,6,0,0,962,240,1,0,0,0,963,964,7,15,0,0,964, - 965,7,7,0,0,965,966,7,16,0,0,966,967,7,21,0,0,967,968,7,6,0,0,968,969, - 7,9,0,0,969,970,7,5,0,0,970,242,1,0,0,0,971,972,7,7,0,0,972,973,7,3,0, - 0,973,974,7,19,0,0,974,975,7,11,0,0,975,976,7,7,0,0,976,977,7,0,0,0,977, - 978,7,15,0,0,978,979,7,12,0,0,979,244,1,0,0,0,980,981,7,7,0,0,981,982, - 7,6,0,0,982,983,7,0,0,0,983,984,7,3,0,0,984,246,1,0,0,0,985,986,7,7,0, - 0,986,987,7,6,0,0,987,988,7,4,0,0,988,248,1,0,0,0,989,990,7,7,0,0,990, - 991,7,6,0,0,991,992,7,1,0,0,992,993,7,0,0,0,993,994,7,18,0,0,994,995, - 7,6,0,0,995,250,1,0,0,0,996,997,7,7,0,0,997,998,7,6,0,0,998,999,7,5,0, - 0,999,1000,7,17,0,0,1000,1001,7,7,0,0,1001,1002,7,1,0,0,1002,252,1,0, - 0,0,1003,1004,7,7,0,0,1004,1005,7,16,0,0,1005,1006,7,4,0,0,1006,1007, - 7,4,0,0,1007,1008,7,13,0,0,1008,1009,7,0,0,0,1009,1010,7,9,0,0,1010,1011, - 7,14,0,0,1011,254,1,0,0,0,1012,1013,7,7,0,0,1013,1014,7,16,0,0,1014,1015, - 7,4,0,0,1015,1016,7,4,0,0,1016,1017,7,13,0,0,1017,1018,7,0,0,0,1018,1019, - 7,9,0,0,1019,1020,7,14,0,0,1020,1021,5,95,0,0,1021,1022,7,8,0,0,1022, - 1023,7,14,0,0,1023,1024,7,10,0,0,1024,1025,7,15,0,0,1025,1026,5,95,0, - 0,1026,1027,7,9,0,0,1027,1028,7,12,0,0,1028,1029,7,6,0,0,1029,1030,7, - 9,0,0,1030,1031,7,14,0,0,1031,1032,7,15,0,0,1032,1033,7,16,0,0,1033,1034, - 7,10,0,0,1034,1035,7,1,0,0,1035,1036,7,5,0,0,1036,256,1,0,0,0,1037,1038, - 7,8,0,0,1038,1039,7,6,0,0,1039,1040,7,23,0,0,1040,1041,7,17,0,0,1041, - 1042,7,6,0,0,1042,1043,7,1,0,0,1043,1044,7,9,0,0,1044,1045,7,6,0,0,1045, - 258,1,0,0,0,1046,1047,7,8,0,0,1047,1048,7,6,0,0,1048,1049,7,5,0,0,1049, - 260,1,0,0,0,1050,1051,7,8,0,0,1051,1052,7,12,0,0,1052,1053,7,16,0,0,1053, - 1054,7,7,0,0,1054,1055,7,5,0,0,1055,1056,7,6,0,0,1056,1057,7,8,0,0,1057, - 1058,7,5,0,0,1058,262,1,0,0,0,1059,1060,7,8,0,0,1060,1061,7,5,0,0,1061, - 1062,7,0,0,0,1062,1063,7,7,0,0,1063,1064,7,5,0,0,1064,264,1,0,0,0,1065, - 1066,7,8,0,0,1066,1067,7,5,0,0,1067,1068,7,0,0,0,1068,1069,7,7,0,0,1069, - 1070,7,5,0,0,1070,1071,7,8,0,0,1071,266,1,0,0,0,1072,1073,7,5,0,0,1073, - 1074,7,0,0,0,1074,1075,7,13,0,0,1075,1076,7,4,0,0,1076,1077,7,6,0,0,1077, - 268,1,0,0,0,1078,1079,7,5,0,0,1079,1080,7,12,0,0,1080,1081,7,6,0,0,1081, - 1082,7,1,0,0,1082,270,1,0,0,0,1083,1084,7,5,0,0,1084,1085,7,16,0,0,1085, - 272,1,0,0,0,1086,1087,7,5,0,0,1087,1088,7,7,0,0,1088,1089,7,0,0,0,1089, - 1090,7,1,0,0,1090,1091,7,8,0,0,1091,1092,7,0,0,0,1092,1093,7,9,0,0,1093, - 1094,7,5,0,0,1094,1095,7,10,0,0,1095,1096,7,16,0,0,1096,1097,7,1,0,0, - 1097,274,1,0,0,0,1098,1099,7,5,0,0,1099,1100,7,7,0,0,1100,1101,7,17,0, - 0,1101,1102,7,6,0,0,1102,276,1,0,0,0,1103,1104,7,5,0,0,1104,1105,7,2, - 0,0,1105,1106,7,15,0,0,1106,1107,7,6,0,0,1107,278,1,0,0,0,1108,1109,7, - 17,0,0,1109,1110,7,1,0,0,1110,1111,7,10,0,0,1111,1112,7,16,0,0,1112,1113, - 7,1,0,0,1113,280,1,0,0,0,1114,1115,7,17,0,0,1115,1116,7,1,0,0,1116,1117, - 7,24,0,0,1117,1118,7,10,0,0,1118,1119,7,1,0,0,1119,1120,7,3,0,0,1120, - 282,1,0,0,0,1121,1122,7,17,0,0,1122,1123,7,8,0,0,1123,1124,7,6,0,0,1124, - 284,1,0,0,0,1125,1126,7,24,0,0,1126,1127,7,12,0,0,1127,1128,7,6,0,0,1128, - 1129,7,1,0,0,1129,286,1,0,0,0,1130,1131,7,24,0,0,1131,1132,7,12,0,0,1132, - 1133,7,6,0,0,1133,1134,7,7,0,0,1134,1135,7,6,0,0,1135,288,1,0,0,0,1136, - 1137,7,24,0,0,1137,1138,7,10,0,0,1138,1139,7,5,0,0,1139,1140,7,12,0,0, - 1140,290,1,0,0,0,1141,1142,7,24,0,0,1142,1143,7,7,0,0,1143,1144,7,10, - 0,0,1144,1145,7,5,0,0,1145,1146,7,6,0,0,1146,292,1,0,0,0,1147,1148,7, - 20,0,0,1148,1149,7,16,0,0,1149,1150,7,7,0,0,1150,294,1,0,0,0,1151,1152, - 7,8,0,0,1152,1153,7,10,0,0,1153,1154,7,1,0,0,1154,1155,7,11,0,0,1155, - 1156,7,4,0,0,1156,1157,7,6,0,0,1157,296,1,0,0,0,1158,1159,7,3,0,0,1159, - 1160,7,6,0,0,1160,1161,7,9,0,0,1161,1162,7,10,0,0,1162,1163,7,18,0,0, - 1163,1164,7,0,0,0,1164,1165,7,4,0,0,1165,298,1,0,0,0,1166,1167,5,42,0, - 0,1167,300,1,0,0,0,1168,1169,7,8,0,0,1169,1170,7,14,0,0,1170,1171,7,10, - 0,0,1171,1172,7,15,0,0,1172,302,1,0,0,0,1173,1174,5,33,0,0,1174,1175, - 5,61,0,0,1175,304,1,0,0,0,1176,1177,5,45,0,0,1177,306,1,0,0,0,1178,1179, - 5,33,0,0,1179,308,1,0,0,0,1180,1181,5,58,0,0,1181,310,1,0,0,0,1182,1187, - 5,34,0,0,1183,1186,3,375,187,0,1184,1186,3,313,156,0,1185,1183,1,0,0, - 0,1185,1184,1,0,0,0,1186,1189,1,0,0,0,1187,1185,1,0,0,0,1187,1188,1,0, - 0,0,1188,1190,1,0,0,0,1189,1187,1,0,0,0,1190,1201,5,34,0,0,1191,1196, - 5,39,0,0,1192,1195,3,355,177,0,1193,1195,3,313,156,0,1194,1192,1,0,0, - 0,1194,1193,1,0,0,0,1195,1198,1,0,0,0,1196,1194,1,0,0,0,1196,1197,1,0, - 0,0,1197,1199,1,0,0,0,1198,1196,1,0,0,0,1199,1201,5,39,0,0,1200,1182, - 1,0,0,0,1200,1191,1,0,0,0,1201,312,1,0,0,0,1202,1220,5,92,0,0,1203,1221, - 7,25,0,0,1204,1205,7,17,0,0,1205,1206,3,319,159,0,1206,1207,3,319,159, - 0,1207,1208,3,319,159,0,1208,1209,3,319,159,0,1209,1221,1,0,0,0,1210, - 1211,7,17,0,0,1211,1212,3,319,159,0,1212,1213,3,319,159,0,1213,1214,3, - 319,159,0,1214,1215,3,319,159,0,1215,1216,3,319,159,0,1216,1217,3,319, - 159,0,1217,1218,3,319,159,0,1218,1219,3,319,159,0,1219,1221,1,0,0,0,1220, - 1203,1,0,0,0,1220,1204,1,0,0,0,1220,1210,1,0,0,0,1221,314,1,0,0,0,1222, - 1231,3,327,163,0,1223,1227,3,323,161,0,1224,1226,3,321,160,0,1225,1224, - 1,0,0,0,1226,1229,1,0,0,0,1227,1225,1,0,0,0,1227,1228,1,0,0,0,1228,1231, - 1,0,0,0,1229,1227,1,0,0,0,1230,1222,1,0,0,0,1230,1223,1,0,0,0,1231,316, - 1,0,0,0,1232,1234,7,26,0,0,1233,1232,1,0,0,0,1234,318,1,0,0,0,1235,1238, - 3,321,160,0,1236,1238,3,317,158,0,1237,1235,1,0,0,0,1237,1236,1,0,0,0, - 1238,320,1,0,0,0,1239,1242,3,327,163,0,1240,1242,3,323,161,0,1241,1239, - 1,0,0,0,1241,1240,1,0,0,0,1242,322,1,0,0,0,1243,1246,3,325,162,0,1244, - 1246,2,56,57,0,1245,1243,1,0,0,0,1245,1244,1,0,0,0,1246,324,1,0,0,0,1247, - 1248,2,49,55,0,1248,326,1,0,0,0,1249,1250,5,48,0,0,1250,328,1,0,0,0,1251, - 1253,3,321,160,0,1252,1251,1,0,0,0,1253,1256,1,0,0,0,1254,1252,1,0,0, - 0,1254,1255,1,0,0,0,1255,1257,1,0,0,0,1256,1254,1,0,0,0,1257,1259,5,46, - 0,0,1258,1260,3,321,160,0,1259,1258,1,0,0,0,1260,1261,1,0,0,0,1261,1259, - 1,0,0,0,1261,1262,1,0,0,0,1262,330,1,0,0,0,1263,1267,3,333,166,0,1264, - 1266,3,335,167,0,1265,1264,1,0,0,0,1266,1269,1,0,0,0,1267,1265,1,0,0, - 0,1267,1268,1,0,0,0,1268,332,1,0,0,0,1269,1267,1,0,0,0,1270,1273,3,383, - 191,0,1271,1273,3,371,185,0,1272,1270,1,0,0,0,1272,1271,1,0,0,0,1273, - 334,1,0,0,0,1274,1277,3,351,175,0,1275,1277,3,367,183,0,1276,1274,1,0, - 0,0,1276,1275,1,0,0,0,1277,336,1,0,0,0,1278,1282,5,96,0,0,1279,1281,3, - 347,173,0,1280,1279,1,0,0,0,1281,1284,1,0,0,0,1282,1280,1,0,0,0,1282, - 1283,1,0,0,0,1283,1285,1,0,0,0,1284,1282,1,0,0,0,1285,1287,5,96,0,0,1286, - 1278,1,0,0,0,1287,1288,1,0,0,0,1288,1286,1,0,0,0,1288,1289,1,0,0,0,1289, - 338,1,0,0,0,1290,1292,3,341,170,0,1291,1290,1,0,0,0,1292,1293,1,0,0,0, - 1293,1291,1,0,0,0,1293,1294,1,0,0,0,1294,340,1,0,0,0,1295,1308,3,369, - 184,0,1296,1308,3,373,186,0,1297,1308,3,377,188,0,1298,1308,3,379,189, - 0,1299,1308,3,345,172,0,1300,1308,3,365,182,0,1301,1308,3,363,181,0,1302, - 1308,3,361,180,0,1303,1308,3,349,174,0,1304,1308,3,381,190,0,1305,1308, - 7,27,0,0,1306,1308,3,343,171,0,1307,1295,1,0,0,0,1307,1296,1,0,0,0,1307, - 1297,1,0,0,0,1307,1298,1,0,0,0,1307,1299,1,0,0,0,1307,1300,1,0,0,0,1307, - 1301,1,0,0,0,1307,1302,1,0,0,0,1307,1303,1,0,0,0,1307,1304,1,0,0,0,1307, - 1305,1,0,0,0,1307,1306,1,0,0,0,1308,342,1,0,0,0,1309,1310,5,47,0,0,1310, - 1311,5,42,0,0,1311,1317,1,0,0,0,1312,1316,3,353,176,0,1313,1314,5,42, - 0,0,1314,1316,3,359,179,0,1315,1312,1,0,0,0,1315,1313,1,0,0,0,1316,1319, - 1,0,0,0,1317,1315,1,0,0,0,1317,1318,1,0,0,0,1318,1320,1,0,0,0,1319,1317, - 1,0,0,0,1320,1321,5,42,0,0,1321,1339,5,47,0,0,1322,1323,5,47,0,0,1323, - 1324,5,47,0,0,1324,1328,1,0,0,0,1325,1327,3,357,178,0,1326,1325,1,0,0, - 0,1327,1330,1,0,0,0,1328,1326,1,0,0,0,1328,1329,1,0,0,0,1329,1332,1,0, - 0,0,1330,1328,1,0,0,0,1331,1333,3,365,182,0,1332,1331,1,0,0,0,1332,1333, - 1,0,0,0,1333,1336,1,0,0,0,1334,1337,3,377,188,0,1335,1337,5,0,0,1,1336, - 1334,1,0,0,0,1336,1335,1,0,0,0,1337,1339,1,0,0,0,1338,1309,1,0,0,0,1338, - 1322,1,0,0,0,1339,344,1,0,0,0,1340,1341,7,28,0,0,1341,346,1,0,0,0,1342, - 1343,8,29,0,0,1343,348,1,0,0,0,1344,1345,7,30,0,0,1345,350,1,0,0,0,1346, - 1347,7,31,0,0,1347,352,1,0,0,0,1348,1349,8,32,0,0,1349,354,1,0,0,0,1350, - 1351,8,33,0,0,1351,356,1,0,0,0,1352,1353,8,34,0,0,1353,358,1,0,0,0,1354, - 1355,8,35,0,0,1355,360,1,0,0,0,1356,1357,7,36,0,0,1357,362,1,0,0,0,1358, - 1359,7,37,0,0,1359,364,1,0,0,0,1360,1361,7,38,0,0,1361,366,1,0,0,0,1362, - 1363,7,39,0,0,1363,368,1,0,0,0,1364,1365,7,40,0,0,1365,370,1,0,0,0,1366, - 1367,7,41,0,0,1367,372,1,0,0,0,1368,1369,7,42,0,0,1369,374,1,0,0,0,1370, - 1371,8,43,0,0,1371,376,1,0,0,0,1372,1373,7,44,0,0,1373,378,1,0,0,0,1374, - 1375,7,45,0,0,1375,380,1,0,0,0,1376,1377,7,46,0,0,1377,382,1,0,0,0,1378, - 1379,7,47,0,0,1379,384,1,0,0,0,1380,1381,9,0,0,0,1381,386,1,0,0,0,28, - 0,1185,1187,1194,1196,1200,1220,1227,1230,1233,1237,1241,1245,1254,1261, - 1267,1272,1276,1282,1288,1293,1307,1315,1317,1328,1332,1336,1338,0 + 65908,66176,66204,66208,66256,66304,66335,66349,66378,66384,66421,66432, + 66461,66464,66499,66504,66511,66513,66517,66560,66717,66736,66771,66776, + 66811,66816,66855,66864,66915,66928,66938,66940,66954,66956,66962,66964, + 66965,66967,66977,66979,66993,66995,67001,67003,67004,67072,67382,67392, + 67413,67424,67431,67456,67461,67463,67504,67506,67514,67584,67589,67592, + 67592,67594,67637,67639,67640,67644,67644,67647,67669,67680,67702,67712, + 67742,67808,67826,67828,67829,67840,67861,67872,67897,67968,68023,68030, + 68031,68096,68096,68112,68115,68117,68119,68121,68149,68192,68220,68224, + 68252,68288,68295,68297,68324,68352,68405,68416,68437,68448,68466,68480, + 68497,68608,68680,68736,68786,68800,68850,68864,68899,69248,69289,69296, + 69297,69376,69404,69415,69415,69424,69445,69488,69505,69552,69572,69600, + 69622,69635,69687,69745,69746,69749,69749,69763,69807,69840,69864,69891, + 69926,69956,69956,69959,69959,69968,70002,70006,70006,70019,70066,70081, + 70084,70106,70106,70108,70108,70144,70161,70163,70187,70207,70208,70272, + 70278,70280,70280,70282,70285,70287,70301,70303,70312,70320,70366,70405, + 70412,70415,70416,70419,70440,70442,70448,70450,70451,70453,70457,70461, + 70461,70480,70480,70493,70497,70656,70708,70727,70730,70751,70753,70784, + 70831,70852,70853,70855,70855,71040,71086,71128,71131,71168,71215,71236, + 71236,71296,71338,71352,71352,71424,71450,71488,71494,71680,71723,71840, + 71903,71935,71942,71945,71945,71948,71955,71957,71958,71960,71983,71999, + 71999,72001,72001,72096,72103,72106,72144,72161,72161,72163,72163,72192, + 72192,72203,72242,72250,72250,72272,72272,72284,72329,72349,72349,72368, + 72440,72704,72712,72714,72750,72768,72768,72818,72847,72960,72966,72968, + 72969,72971,73008,73030,73030,73056,73061,73063,73064,73066,73097,73112, + 73112,73440,73458,73474,73474,73476,73488,73490,73523,73648,73648,73728, + 74649,74752,74862,74880,75075,77712,77808,77824,78895,78913,78918,82944, + 83526,92160,92728,92736,92766,92784,92862,92880,92909,92928,92975,92992, + 92995,93027,93047,93053,93071,93760,93823,93952,94026,94032,94032,94099, + 94111,94176,94177,94179,94179,94208,100343,100352,101589,101632,101640, + 110576,110579,110581,110587,110589,110590,110592,110882,110898,110898, + 110928,110930,110933,110933,110948,110951,110960,111355,113664,113770, + 113776,113788,113792,113800,113808,113817,119808,119892,119894,119964, + 119966,119967,119970,119970,119973,119974,119977,119980,119982,119993, + 119995,119995,119997,120003,120005,120069,120071,120074,120077,120084, + 120086,120092,120094,120121,120123,120126,120128,120132,120134,120134, + 120138,120144,120146,120485,120488,120512,120514,120538,120540,120570, + 120572,120596,120598,120628,120630,120654,120656,120686,120688,120712, + 120714,120744,120746,120770,120772,120779,122624,122654,122661,122666, + 122928,122989,123136,123180,123191,123197,123214,123214,123536,123565, + 123584,123627,124112,124139,124896,124902,124904,124907,124909,124910, + 124912,124926,124928,125124,125184,125251,125259,125259,126464,126467, + 126469,126495,126497,126498,126500,126500,126503,126503,126505,126514, + 126516,126519,126521,126521,126523,126523,126530,126530,126535,126535, + 126537,126537,126539,126539,126541,126543,126545,126546,126548,126548, + 126551,126551,126553,126553,126555,126555,126557,126557,126559,126559, + 126561,126562,126564,126564,126567,126570,126572,126578,126580,126583, + 126585,126588,126590,126590,126592,126601,126603,126619,126625,126627, + 126629,126633,126635,126651,131072,173791,173824,177977,177984,178205, + 178208,183969,183984,191456,194560,195101,196608,201546,201552,205743, + 1409,0,1,1,0,0,0,0,3,1,0,0,0,0,5,1,0,0,0,0,7,1,0,0,0,0,9,1,0,0,0,0,11, + 1,0,0,0,0,13,1,0,0,0,0,15,1,0,0,0,0,17,1,0,0,0,0,19,1,0,0,0,0,21,1,0, + 0,0,0,23,1,0,0,0,0,25,1,0,0,0,0,27,1,0,0,0,0,29,1,0,0,0,0,31,1,0,0,0, + 0,33,1,0,0,0,0,35,1,0,0,0,0,37,1,0,0,0,0,39,1,0,0,0,0,41,1,0,0,0,0,43, + 1,0,0,0,0,45,1,0,0,0,0,47,1,0,0,0,0,49,1,0,0,0,0,51,1,0,0,0,0,53,1,0, + 0,0,0,55,1,0,0,0,0,57,1,0,0,0,0,59,1,0,0,0,0,61,1,0,0,0,0,63,1,0,0,0, + 0,65,1,0,0,0,0,67,1,0,0,0,0,69,1,0,0,0,0,71,1,0,0,0,0,73,1,0,0,0,0,75, + 1,0,0,0,0,77,1,0,0,0,0,79,1,0,0,0,0,81,1,0,0,0,0,83,1,0,0,0,0,85,1,0, + 0,0,0,87,1,0,0,0,0,89,1,0,0,0,0,91,1,0,0,0,0,93,1,0,0,0,0,95,1,0,0,0, + 0,97,1,0,0,0,0,99,1,0,0,0,0,101,1,0,0,0,0,103,1,0,0,0,0,105,1,0,0,0,0, + 107,1,0,0,0,0,109,1,0,0,0,0,111,1,0,0,0,0,113,1,0,0,0,0,115,1,0,0,0,0, + 117,1,0,0,0,0,119,1,0,0,0,0,121,1,0,0,0,0,123,1,0,0,0,0,125,1,0,0,0,0, + 127,1,0,0,0,0,129,1,0,0,0,0,131,1,0,0,0,0,133,1,0,0,0,0,135,1,0,0,0,0, + 137,1,0,0,0,0,139,1,0,0,0,0,141,1,0,0,0,0,143,1,0,0,0,0,145,1,0,0,0,0, + 147,1,0,0,0,0,149,1,0,0,0,0,151,1,0,0,0,0,153,1,0,0,0,0,155,1,0,0,0,0, + 157,1,0,0,0,0,159,1,0,0,0,0,161,1,0,0,0,0,163,1,0,0,0,0,165,1,0,0,0,0, + 167,1,0,0,0,0,169,1,0,0,0,0,171,1,0,0,0,0,173,1,0,0,0,0,175,1,0,0,0,0, + 177,1,0,0,0,0,179,1,0,0,0,0,181,1,0,0,0,0,183,1,0,0,0,0,185,1,0,0,0,0, + 187,1,0,0,0,0,189,1,0,0,0,0,191,1,0,0,0,0,193,1,0,0,0,0,195,1,0,0,0,0, + 197,1,0,0,0,0,199,1,0,0,0,0,201,1,0,0,0,0,203,1,0,0,0,0,205,1,0,0,0,0, + 207,1,0,0,0,0,209,1,0,0,0,0,211,1,0,0,0,0,213,1,0,0,0,0,215,1,0,0,0,0, + 217,1,0,0,0,0,219,1,0,0,0,0,221,1,0,0,0,0,223,1,0,0,0,0,225,1,0,0,0,0, + 227,1,0,0,0,0,229,1,0,0,0,0,231,1,0,0,0,0,233,1,0,0,0,0,235,1,0,0,0,0, + 237,1,0,0,0,0,239,1,0,0,0,0,241,1,0,0,0,0,243,1,0,0,0,0,245,1,0,0,0,0, + 247,1,0,0,0,0,249,1,0,0,0,0,251,1,0,0,0,0,253,1,0,0,0,0,255,1,0,0,0,0, + 257,1,0,0,0,0,259,1,0,0,0,0,261,1,0,0,0,0,263,1,0,0,0,0,265,1,0,0,0,0, + 267,1,0,0,0,0,269,1,0,0,0,0,271,1,0,0,0,0,273,1,0,0,0,0,275,1,0,0,0,0, + 277,1,0,0,0,0,279,1,0,0,0,0,281,1,0,0,0,0,283,1,0,0,0,0,285,1,0,0,0,0, + 287,1,0,0,0,0,289,1,0,0,0,0,291,1,0,0,0,0,293,1,0,0,0,0,295,1,0,0,0,0, + 297,1,0,0,0,0,299,1,0,0,0,0,301,1,0,0,0,0,303,1,0,0,0,0,305,1,0,0,0,0, + 307,1,0,0,0,0,309,1,0,0,0,0,311,1,0,0,0,0,313,1,0,0,0,0,315,1,0,0,0,0, + 317,1,0,0,0,0,319,1,0,0,0,0,321,1,0,0,0,0,323,1,0,0,0,0,325,1,0,0,0,0, + 327,1,0,0,0,0,329,1,0,0,0,0,331,1,0,0,0,0,333,1,0,0,0,0,335,1,0,0,0,0, + 337,1,0,0,0,0,339,1,0,0,0,0,341,1,0,0,0,0,343,1,0,0,0,0,345,1,0,0,0,0, + 387,1,0,0,0,1,389,1,0,0,0,3,391,1,0,0,0,5,393,1,0,0,0,7,395,1,0,0,0,9, + 397,1,0,0,0,11,399,1,0,0,0,13,401,1,0,0,0,15,403,1,0,0,0,17,405,1,0,0, + 0,19,407,1,0,0,0,21,409,1,0,0,0,23,411,1,0,0,0,25,414,1,0,0,0,27,417, + 1,0,0,0,29,419,1,0,0,0,31,422,1,0,0,0,33,424,1,0,0,0,35,427,1,0,0,0,37, + 429,1,0,0,0,39,432,1,0,0,0,41,435,1,0,0,0,43,437,1,0,0,0,45,439,1,0,0, + 0,47,441,1,0,0,0,49,443,1,0,0,0,51,446,1,0,0,0,53,448,1,0,0,0,55,450, + 1,0,0,0,57,452,1,0,0,0,59,454,1,0,0,0,61,456,1,0,0,0,63,458,1,0,0,0,65, + 460,1,0,0,0,67,462,1,0,0,0,69,464,1,0,0,0,71,466,1,0,0,0,73,468,1,0,0, + 0,75,470,1,0,0,0,77,472,1,0,0,0,79,474,1,0,0,0,81,476,1,0,0,0,83,478, + 1,0,0,0,85,480,1,0,0,0,87,482,1,0,0,0,89,484,1,0,0,0,91,486,1,0,0,0,93, + 490,1,0,0,0,95,494,1,0,0,0,97,498,1,0,0,0,99,504,1,0,0,0,101,508,1,0, + 0,0,103,511,1,0,0,0,105,515,1,0,0,0,107,525,1,0,0,0,109,532,1,0,0,0,111, + 538,1,0,0,0,113,541,1,0,0,0,115,546,1,0,0,0,117,551,1,0,0,0,119,556,1, + 0,0,0,121,567,1,0,0,0,123,574,1,0,0,0,125,582,1,0,0,0,127,589,1,0,0,0, + 129,612,1,0,0,0,131,621,1,0,0,0,133,626,1,0,0,0,135,632,1,0,0,0,137,639, + 1,0,0,0,139,645,1,0,0,0,141,654,1,0,0,0,143,661,1,0,0,0,145,669,1,0,0, + 0,147,676,1,0,0,0,149,681,1,0,0,0,151,692,1,0,0,0,153,699,1,0,0,0,155, + 708,1,0,0,0,157,713,1,0,0,0,159,718,1,0,0,0,161,722,1,0,0,0,163,727,1, + 0,0,0,165,734,1,0,0,0,167,742,1,0,0,0,169,749,1,0,0,0,171,759,1,0,0,0, + 173,768,1,0,0,0,175,774,1,0,0,0,177,779,1,0,0,0,179,784,1,0,0,0,181,790, + 1,0,0,0,183,796,1,0,0,0,185,804,1,0,0,0,187,809,1,0,0,0,189,816,1,0,0, + 0,191,819,1,0,0,0,193,822,1,0,0,0,195,832,1,0,0,0,197,840,1,0,0,0,199, + 843,1,0,0,0,201,848,1,0,0,0,203,852,1,0,0,0,205,858,1,0,0,0,207,863,1, + 0,0,0,209,869,1,0,0,0,211,875,1,0,0,0,213,884,1,0,0,0,215,890,1,0,0,0, + 217,899,1,0,0,0,219,910,1,0,0,0,221,913,1,0,0,0,223,918,1,0,0,0,225,922, + 1,0,0,0,227,927,1,0,0,0,229,932,1,0,0,0,231,935,1,0,0,0,233,940,1,0,0, + 0,235,949,1,0,0,0,237,952,1,0,0,0,239,958,1,0,0,0,241,966,1,0,0,0,243, + 974,1,0,0,0,245,982,1,0,0,0,247,991,1,0,0,0,249,996,1,0,0,0,251,1000, + 1,0,0,0,253,1007,1,0,0,0,255,1014,1,0,0,0,257,1023,1,0,0,0,259,1048,1, + 0,0,0,261,1057,1,0,0,0,263,1061,1,0,0,0,265,1070,1,0,0,0,267,1076,1,0, + 0,0,269,1083,1,0,0,0,271,1089,1,0,0,0,273,1094,1,0,0,0,275,1097,1,0,0, + 0,277,1109,1,0,0,0,279,1114,1,0,0,0,281,1119,1,0,0,0,283,1125,1,0,0,0, + 285,1132,1,0,0,0,287,1136,1,0,0,0,289,1141,1,0,0,0,291,1147,1,0,0,0,293, + 1152,1,0,0,0,295,1158,1,0,0,0,297,1162,1,0,0,0,299,1169,1,0,0,0,301,1177, + 1,0,0,0,303,1179,1,0,0,0,305,1184,1,0,0,0,307,1187,1,0,0,0,309,1189,1, + 0,0,0,311,1191,1,0,0,0,313,1211,1,0,0,0,315,1213,1,0,0,0,317,1241,1,0, + 0,0,319,1244,1,0,0,0,321,1248,1,0,0,0,323,1252,1,0,0,0,325,1256,1,0,0, + 0,327,1258,1,0,0,0,329,1260,1,0,0,0,331,1265,1,0,0,0,333,1274,1,0,0,0, + 335,1283,1,0,0,0,337,1287,1,0,0,0,339,1297,1,0,0,0,341,1302,1,0,0,0,343, + 1318,1,0,0,0,345,1349,1,0,0,0,347,1351,1,0,0,0,349,1353,1,0,0,0,351,1355, + 1,0,0,0,353,1357,1,0,0,0,355,1359,1,0,0,0,357,1361,1,0,0,0,359,1363,1, + 0,0,0,361,1365,1,0,0,0,363,1367,1,0,0,0,365,1369,1,0,0,0,367,1371,1,0, + 0,0,369,1373,1,0,0,0,371,1375,1,0,0,0,373,1377,1,0,0,0,375,1379,1,0,0, + 0,377,1381,1,0,0,0,379,1383,1,0,0,0,381,1385,1,0,0,0,383,1387,1,0,0,0, + 385,1389,1,0,0,0,387,1391,1,0,0,0,389,390,5,59,0,0,390,2,1,0,0,0,391, + 392,5,40,0,0,392,4,1,0,0,0,393,394,5,44,0,0,394,6,1,0,0,0,395,396,5,41, + 0,0,396,8,1,0,0,0,397,398,5,46,0,0,398,10,1,0,0,0,399,400,5,61,0,0,400, + 12,1,0,0,0,401,402,5,91,0,0,402,14,1,0,0,0,403,404,5,93,0,0,404,16,1, + 0,0,0,405,406,5,123,0,0,406,18,1,0,0,0,407,408,5,125,0,0,408,20,1,0,0, + 0,409,410,5,124,0,0,410,22,1,0,0,0,411,412,5,46,0,0,412,413,5,46,0,0, + 413,24,1,0,0,0,414,415,5,60,0,0,415,416,5,62,0,0,416,26,1,0,0,0,417,418, + 5,60,0,0,418,28,1,0,0,0,419,420,5,60,0,0,420,421,5,61,0,0,421,30,1,0, + 0,0,422,423,5,62,0,0,423,32,1,0,0,0,424,425,5,62,0,0,425,426,5,61,0,0, + 426,34,1,0,0,0,427,428,5,38,0,0,428,36,1,0,0,0,429,430,5,62,0,0,430,431, + 5,62,0,0,431,38,1,0,0,0,432,433,5,60,0,0,433,434,5,60,0,0,434,40,1,0, + 0,0,435,436,5,43,0,0,436,42,1,0,0,0,437,438,5,47,0,0,438,44,1,0,0,0,439, + 440,5,37,0,0,440,46,1,0,0,0,441,442,5,94,0,0,442,48,1,0,0,0,443,444,5, + 61,0,0,444,445,5,126,0,0,445,50,1,0,0,0,446,447,5,36,0,0,447,52,1,0,0, + 0,448,449,5,10216,0,0,449,54,1,0,0,0,450,451,5,12296,0,0,451,56,1,0,0, + 0,452,453,5,65124,0,0,453,58,1,0,0,0,454,455,5,65308,0,0,455,60,1,0,0, + 0,456,457,5,10217,0,0,457,62,1,0,0,0,458,459,5,12297,0,0,459,64,1,0,0, + 0,460,461,5,65125,0,0,461,66,1,0,0,0,462,463,5,65310,0,0,463,68,1,0,0, + 0,464,465,5,173,0,0,465,70,1,0,0,0,466,467,5,8208,0,0,467,72,1,0,0,0, + 468,469,5,8209,0,0,469,74,1,0,0,0,470,471,5,8210,0,0,471,76,1,0,0,0,472, + 473,5,8211,0,0,473,78,1,0,0,0,474,475,5,8212,0,0,475,80,1,0,0,0,476,477, + 5,8213,0,0,477,82,1,0,0,0,478,479,5,8722,0,0,479,84,1,0,0,0,480,481,5, + 65112,0,0,481,86,1,0,0,0,482,483,5,65123,0,0,483,88,1,0,0,0,484,485,5, + 65293,0,0,485,90,1,0,0,0,486,487,7,0,0,0,487,488,7,1,0,0,488,489,7,2, + 0,0,489,92,1,0,0,0,490,491,7,0,0,0,491,492,7,3,0,0,492,493,7,3,0,0,493, + 94,1,0,0,0,494,495,7,0,0,0,495,496,7,4,0,0,496,497,7,4,0,0,497,96,1,0, + 0,0,498,499,7,0,0,0,499,500,7,4,0,0,500,501,7,5,0,0,501,502,7,6,0,0,502, + 503,7,7,0,0,503,98,1,0,0,0,504,505,7,0,0,0,505,506,7,1,0,0,506,507,7, + 3,0,0,507,100,1,0,0,0,508,509,7,0,0,0,509,510,7,8,0,0,510,102,1,0,0,0, + 511,512,7,0,0,0,512,513,7,8,0,0,513,514,7,9,0,0,514,104,1,0,0,0,515,516, + 7,0,0,0,516,517,7,8,0,0,517,518,7,9,0,0,518,519,7,6,0,0,519,520,7,1,0, + 0,520,521,7,3,0,0,521,522,7,10,0,0,522,523,7,1,0,0,523,524,7,11,0,0,524, + 106,1,0,0,0,525,526,7,0,0,0,526,527,7,5,0,0,527,528,7,5,0,0,528,529,7, + 0,0,0,529,530,7,9,0,0,530,531,7,12,0,0,531,108,1,0,0,0,532,533,7,13,0, + 0,533,534,7,6,0,0,534,535,7,11,0,0,535,536,7,10,0,0,536,537,7,1,0,0,537, + 110,1,0,0,0,538,539,7,13,0,0,539,540,7,2,0,0,540,112,1,0,0,0,541,542, + 7,9,0,0,542,543,7,0,0,0,543,544,7,4,0,0,544,545,7,4,0,0,545,114,1,0,0, + 0,546,547,7,9,0,0,547,548,7,0,0,0,548,549,7,8,0,0,549,550,7,6,0,0,550, + 116,1,0,0,0,551,552,7,9,0,0,552,553,7,0,0,0,553,554,7,8,0,0,554,555,7, + 5,0,0,555,118,1,0,0,0,556,557,7,9,0,0,557,558,7,12,0,0,558,559,7,6,0, + 0,559,560,7,9,0,0,560,561,7,14,0,0,561,562,7,15,0,0,562,563,7,16,0,0, + 563,564,7,10,0,0,564,565,7,1,0,0,565,566,7,5,0,0,566,120,1,0,0,0,567, + 568,7,9,0,0,568,569,7,16,0,0,569,570,7,4,0,0,570,571,7,17,0,0,571,572, + 7,18,0,0,572,573,7,1,0,0,573,122,1,0,0,0,574,575,7,9,0,0,575,576,7,16, + 0,0,576,577,7,18,0,0,577,578,7,18,0,0,578,579,7,6,0,0,579,580,7,1,0,0, + 580,581,7,5,0,0,581,124,1,0,0,0,582,583,7,9,0,0,583,584,7,16,0,0,584, + 585,7,18,0,0,585,586,7,18,0,0,586,587,7,10,0,0,587,588,7,5,0,0,588,126, + 1,0,0,0,589,590,7,9,0,0,590,591,7,16,0,0,591,592,7,18,0,0,592,593,7,18, + 0,0,593,594,7,10,0,0,594,595,7,5,0,0,595,596,5,95,0,0,596,597,7,8,0,0, + 597,598,7,14,0,0,598,599,7,10,0,0,599,600,7,15,0,0,600,601,5,95,0,0,601, + 602,7,9,0,0,602,603,7,12,0,0,603,604,7,6,0,0,604,605,7,9,0,0,605,606, + 7,14,0,0,606,607,7,15,0,0,607,608,7,16,0,0,608,609,7,10,0,0,609,610,7, + 1,0,0,610,611,7,5,0,0,611,128,1,0,0,0,612,613,7,9,0,0,613,614,7,16,0, + 0,614,615,7,1,0,0,615,616,7,5,0,0,616,617,7,0,0,0,617,618,7,10,0,0,618, + 619,7,1,0,0,619,620,7,8,0,0,620,130,1,0,0,0,621,622,7,9,0,0,622,623,7, + 16,0,0,623,624,7,15,0,0,624,625,7,2,0,0,625,132,1,0,0,0,626,627,7,9,0, + 0,627,628,7,16,0,0,628,629,7,17,0,0,629,630,7,1,0,0,630,631,7,5,0,0,631, + 134,1,0,0,0,632,633,7,9,0,0,633,634,7,7,0,0,634,635,7,6,0,0,635,636,7, + 0,0,0,636,637,7,5,0,0,637,638,7,6,0,0,638,136,1,0,0,0,639,640,7,9,0,0, + 640,641,7,2,0,0,641,642,7,9,0,0,642,643,7,4,0,0,643,644,7,6,0,0,644,138, + 1,0,0,0,645,646,7,3,0,0,646,647,7,0,0,0,647,648,7,5,0,0,648,649,7,0,0, + 0,649,650,7,13,0,0,650,651,7,0,0,0,651,652,7,8,0,0,652,653,7,6,0,0,653, + 140,1,0,0,0,654,655,7,3,0,0,655,656,7,13,0,0,656,657,7,5,0,0,657,658, + 7,2,0,0,658,659,7,15,0,0,659,660,7,6,0,0,660,142,1,0,0,0,661,662,7,3, + 0,0,662,663,7,6,0,0,663,664,7,19,0,0,664,665,7,0,0,0,665,666,7,17,0,0, + 666,667,7,4,0,0,667,668,7,5,0,0,668,144,1,0,0,0,669,670,7,3,0,0,670,671, + 7,6,0,0,671,672,7,4,0,0,672,673,7,6,0,0,673,674,7,5,0,0,674,675,7,6,0, + 0,675,146,1,0,0,0,676,677,7,3,0,0,677,678,7,6,0,0,678,679,7,8,0,0,679, + 680,7,9,0,0,680,148,1,0,0,0,681,682,7,3,0,0,682,683,7,6,0,0,683,684,7, + 8,0,0,684,685,7,9,0,0,685,686,7,6,0,0,686,687,7,1,0,0,687,688,7,3,0,0, + 688,689,7,10,0,0,689,690,7,1,0,0,690,691,7,11,0,0,691,150,1,0,0,0,692, + 693,7,3,0,0,693,694,7,6,0,0,694,695,7,5,0,0,695,696,7,0,0,0,696,697,7, + 9,0,0,697,698,7,12,0,0,698,152,1,0,0,0,699,700,7,3,0,0,700,701,7,10,0, + 0,701,702,7,8,0,0,702,703,7,5,0,0,703,704,7,10,0,0,704,705,7,1,0,0,705, + 706,7,9,0,0,706,707,7,5,0,0,707,154,1,0,0,0,708,709,7,3,0,0,709,710,7, + 7,0,0,710,711,7,16,0,0,711,712,7,15,0,0,712,156,1,0,0,0,713,714,7,6,0, + 0,714,715,7,4,0,0,715,716,7,8,0,0,716,717,7,6,0,0,717,158,1,0,0,0,718, + 719,7,6,0,0,719,720,7,1,0,0,720,721,7,3,0,0,721,160,1,0,0,0,722,723,7, + 6,0,0,723,724,7,1,0,0,724,725,7,3,0,0,725,726,7,8,0,0,726,162,1,0,0,0, + 727,728,7,6,0,0,728,729,7,20,0,0,729,730,7,10,0,0,730,731,7,8,0,0,731, + 732,7,5,0,0,732,733,7,8,0,0,733,164,1,0,0,0,734,735,7,6,0,0,735,736,7, + 20,0,0,736,737,7,15,0,0,737,738,7,4,0,0,738,739,7,0,0,0,739,740,7,10, + 0,0,740,741,7,1,0,0,741,166,1,0,0,0,742,743,7,6,0,0,743,744,7,20,0,0, + 744,745,7,15,0,0,745,746,7,16,0,0,746,747,7,7,0,0,747,748,7,5,0,0,748, + 168,1,0,0,0,749,750,7,6,0,0,750,751,7,20,0,0,751,752,7,5,0,0,752,753, + 7,6,0,0,753,754,7,1,0,0,754,755,7,8,0,0,755,756,7,10,0,0,756,757,7,16, + 0,0,757,758,7,1,0,0,758,170,1,0,0,0,759,760,7,6,0,0,760,761,7,20,0,0, + 761,762,7,5,0,0,762,763,7,6,0,0,763,764,7,7,0,0,764,765,7,1,0,0,765,766, + 7,0,0,0,766,767,7,4,0,0,767,172,1,0,0,0,768,769,7,19,0,0,769,770,7,0, + 0,0,770,771,7,4,0,0,771,772,7,8,0,0,772,773,7,6,0,0,773,174,1,0,0,0,774, + 775,7,19,0,0,775,776,7,7,0,0,776,777,7,16,0,0,777,778,7,18,0,0,778,176, + 1,0,0,0,779,780,7,11,0,0,780,781,7,4,0,0,781,782,7,16,0,0,782,783,7,13, + 0,0,783,178,1,0,0,0,784,785,7,11,0,0,785,786,7,7,0,0,786,787,7,0,0,0, + 787,788,7,15,0,0,788,789,7,12,0,0,789,180,1,0,0,0,790,791,7,11,0,0,791, + 792,7,7,0,0,792,793,7,16,0,0,793,794,7,17,0,0,794,795,7,15,0,0,795,182, + 1,0,0,0,796,797,7,12,0,0,797,798,7,6,0,0,798,799,7,0,0,0,799,800,7,3, + 0,0,800,801,7,6,0,0,801,802,7,7,0,0,802,803,7,8,0,0,803,184,1,0,0,0,804, + 805,7,12,0,0,805,806,7,10,0,0,806,807,7,1,0,0,807,808,7,5,0,0,808,186, + 1,0,0,0,809,810,7,10,0,0,810,811,7,18,0,0,811,812,7,15,0,0,812,813,7, + 16,0,0,813,814,7,7,0,0,814,815,7,5,0,0,815,188,1,0,0,0,816,817,7,10,0, + 0,817,818,7,19,0,0,818,190,1,0,0,0,819,820,7,10,0,0,820,821,7,1,0,0,821, + 192,1,0,0,0,822,823,7,10,0,0,823,824,7,1,0,0,824,825,7,9,0,0,825,826, + 7,7,0,0,826,827,7,6,0,0,827,828,7,18,0,0,828,829,7,6,0,0,829,830,7,1, + 0,0,830,831,7,5,0,0,831,194,1,0,0,0,832,833,7,10,0,0,833,834,7,1,0,0, + 834,835,7,8,0,0,835,836,7,5,0,0,836,837,7,0,0,0,837,838,7,4,0,0,838,839, + 7,4,0,0,839,196,1,0,0,0,840,841,7,10,0,0,841,842,7,8,0,0,842,198,1,0, + 0,0,843,844,7,21,0,0,844,845,7,16,0,0,845,846,7,10,0,0,846,847,7,1,0, + 0,847,200,1,0,0,0,848,849,7,14,0,0,849,850,7,6,0,0,850,851,7,2,0,0,851, + 202,1,0,0,0,852,853,7,4,0,0,853,854,7,10,0,0,854,855,7,18,0,0,855,856, + 7,10,0,0,856,857,7,5,0,0,857,204,1,0,0,0,858,859,7,4,0,0,859,860,7,16, + 0,0,860,861,7,0,0,0,861,862,7,3,0,0,862,206,1,0,0,0,863,864,7,18,0,0, + 864,865,7,0,0,0,865,866,7,9,0,0,866,867,7,7,0,0,867,868,7,16,0,0,868, + 208,1,0,0,0,869,870,7,18,0,0,870,871,7,0,0,0,871,872,7,5,0,0,872,873, + 7,9,0,0,873,874,7,12,0,0,874,210,1,0,0,0,875,876,7,18,0,0,876,877,7,0, + 0,0,877,878,7,20,0,0,878,879,7,22,0,0,879,880,7,0,0,0,880,881,7,4,0,0, + 881,882,7,17,0,0,882,883,7,6,0,0,883,212,1,0,0,0,884,885,7,18,0,0,885, + 886,7,6,0,0,886,887,7,7,0,0,887,888,7,11,0,0,888,889,7,6,0,0,889,214, + 1,0,0,0,890,891,7,18,0,0,891,892,7,10,0,0,892,893,7,1,0,0,893,894,7,22, + 0,0,894,895,7,0,0,0,895,896,7,4,0,0,896,897,7,17,0,0,897,898,7,6,0,0, + 898,216,1,0,0,0,899,900,7,18,0,0,900,901,7,17,0,0,901,902,7,4,0,0,902, + 903,7,5,0,0,903,904,7,10,0,0,904,905,5,95,0,0,905,906,7,21,0,0,906,907, + 7,16,0,0,907,908,7,10,0,0,908,909,7,1,0,0,909,218,1,0,0,0,910,911,7,1, + 0,0,911,912,7,16,0,0,912,220,1,0,0,0,913,914,7,1,0,0,914,915,7,16,0,0, + 915,916,7,3,0,0,916,917,7,6,0,0,917,222,1,0,0,0,918,919,7,1,0,0,919,920, + 7,16,0,0,920,921,7,5,0,0,921,224,1,0,0,0,922,923,7,1,0,0,923,924,7,16, + 0,0,924,925,7,1,0,0,925,926,7,6,0,0,926,226,1,0,0,0,927,928,7,1,0,0,928, + 929,7,17,0,0,929,930,7,4,0,0,930,931,7,4,0,0,931,228,1,0,0,0,932,933, + 7,16,0,0,933,934,7,1,0,0,934,230,1,0,0,0,935,936,7,16,0,0,936,937,7,1, + 0,0,937,938,7,4,0,0,938,939,7,2,0,0,939,232,1,0,0,0,940,941,7,16,0,0, + 941,942,7,15,0,0,942,943,7,5,0,0,943,944,7,10,0,0,944,945,7,16,0,0,945, + 946,7,1,0,0,946,947,7,0,0,0,947,948,7,4,0,0,948,234,1,0,0,0,949,950,7, + 16,0,0,950,951,7,7,0,0,951,236,1,0,0,0,952,953,7,16,0,0,953,954,7,7,0, + 0,954,955,7,3,0,0,955,956,7,6,0,0,956,957,7,7,0,0,957,238,1,0,0,0,958, + 959,7,15,0,0,959,960,7,7,0,0,960,961,7,10,0,0,961,962,7,18,0,0,962,963, + 7,0,0,0,963,964,7,7,0,0,964,965,7,2,0,0,965,240,1,0,0,0,966,967,7,15, + 0,0,967,968,7,7,0,0,968,969,7,16,0,0,969,970,7,19,0,0,970,971,7,10,0, + 0,971,972,7,4,0,0,972,973,7,6,0,0,973,242,1,0,0,0,974,975,7,15,0,0,975, + 976,7,7,0,0,976,977,7,16,0,0,977,978,7,21,0,0,978,979,7,6,0,0,979,980, + 7,9,0,0,980,981,7,5,0,0,981,244,1,0,0,0,982,983,7,7,0,0,983,984,7,3,0, + 0,984,985,7,19,0,0,985,986,7,11,0,0,986,987,7,7,0,0,987,988,7,0,0,0,988, + 989,7,15,0,0,989,990,7,12,0,0,990,246,1,0,0,0,991,992,7,7,0,0,992,993, + 7,6,0,0,993,994,7,0,0,0,994,995,7,3,0,0,995,248,1,0,0,0,996,997,7,7,0, + 0,997,998,7,6,0,0,998,999,7,4,0,0,999,250,1,0,0,0,1000,1001,7,7,0,0,1001, + 1002,7,6,0,0,1002,1003,7,1,0,0,1003,1004,7,0,0,0,1004,1005,7,18,0,0,1005, + 1006,7,6,0,0,1006,252,1,0,0,0,1007,1008,7,7,0,0,1008,1009,7,6,0,0,1009, + 1010,7,5,0,0,1010,1011,7,17,0,0,1011,1012,7,7,0,0,1012,1013,7,1,0,0,1013, + 254,1,0,0,0,1014,1015,7,7,0,0,1015,1016,7,16,0,0,1016,1017,7,4,0,0,1017, + 1018,7,4,0,0,1018,1019,7,13,0,0,1019,1020,7,0,0,0,1020,1021,7,9,0,0,1021, + 1022,7,14,0,0,1022,256,1,0,0,0,1023,1024,7,7,0,0,1024,1025,7,16,0,0,1025, + 1026,7,4,0,0,1026,1027,7,4,0,0,1027,1028,7,13,0,0,1028,1029,7,0,0,0,1029, + 1030,7,9,0,0,1030,1031,7,14,0,0,1031,1032,5,95,0,0,1032,1033,7,8,0,0, + 1033,1034,7,14,0,0,1034,1035,7,10,0,0,1035,1036,7,15,0,0,1036,1037,5, + 95,0,0,1037,1038,7,9,0,0,1038,1039,7,12,0,0,1039,1040,7,6,0,0,1040,1041, + 7,9,0,0,1041,1042,7,14,0,0,1042,1043,7,15,0,0,1043,1044,7,16,0,0,1044, + 1045,7,10,0,0,1045,1046,7,1,0,0,1046,1047,7,5,0,0,1047,258,1,0,0,0,1048, + 1049,7,8,0,0,1049,1050,7,6,0,0,1050,1051,7,23,0,0,1051,1052,7,17,0,0, + 1052,1053,7,6,0,0,1053,1054,7,1,0,0,1054,1055,7,9,0,0,1055,1056,7,6,0, + 0,1056,260,1,0,0,0,1057,1058,7,8,0,0,1058,1059,7,6,0,0,1059,1060,7,5, + 0,0,1060,262,1,0,0,0,1061,1062,7,8,0,0,1062,1063,7,12,0,0,1063,1064,7, + 16,0,0,1064,1065,7,7,0,0,1065,1066,7,5,0,0,1066,1067,7,6,0,0,1067,1068, + 7,8,0,0,1068,1069,7,5,0,0,1069,264,1,0,0,0,1070,1071,7,8,0,0,1071,1072, + 7,5,0,0,1072,1073,7,0,0,0,1073,1074,7,7,0,0,1074,1075,7,5,0,0,1075,266, + 1,0,0,0,1076,1077,7,8,0,0,1077,1078,7,5,0,0,1078,1079,7,0,0,0,1079,1080, + 7,7,0,0,1080,1081,7,5,0,0,1081,1082,7,8,0,0,1082,268,1,0,0,0,1083,1084, + 7,5,0,0,1084,1085,7,0,0,0,1085,1086,7,13,0,0,1086,1087,7,4,0,0,1087,1088, + 7,6,0,0,1088,270,1,0,0,0,1089,1090,7,5,0,0,1090,1091,7,12,0,0,1091,1092, + 7,6,0,0,1092,1093,7,1,0,0,1093,272,1,0,0,0,1094,1095,7,5,0,0,1095,1096, + 7,16,0,0,1096,274,1,0,0,0,1097,1098,7,5,0,0,1098,1099,7,7,0,0,1099,1100, + 7,0,0,0,1100,1101,7,1,0,0,1101,1102,7,8,0,0,1102,1103,7,0,0,0,1103,1104, + 7,9,0,0,1104,1105,7,5,0,0,1105,1106,7,10,0,0,1106,1107,7,16,0,0,1107, + 1108,7,1,0,0,1108,276,1,0,0,0,1109,1110,7,5,0,0,1110,1111,7,7,0,0,1111, + 1112,7,17,0,0,1112,1113,7,6,0,0,1113,278,1,0,0,0,1114,1115,7,5,0,0,1115, + 1116,7,2,0,0,1116,1117,7,15,0,0,1117,1118,7,6,0,0,1118,280,1,0,0,0,1119, + 1120,7,17,0,0,1120,1121,7,1,0,0,1121,1122,7,10,0,0,1122,1123,7,16,0,0, + 1123,1124,7,1,0,0,1124,282,1,0,0,0,1125,1126,7,17,0,0,1126,1127,7,1,0, + 0,1127,1128,7,24,0,0,1128,1129,7,10,0,0,1129,1130,7,1,0,0,1130,1131,7, + 3,0,0,1131,284,1,0,0,0,1132,1133,7,17,0,0,1133,1134,7,8,0,0,1134,1135, + 7,6,0,0,1135,286,1,0,0,0,1136,1137,7,24,0,0,1137,1138,7,12,0,0,1138,1139, + 7,6,0,0,1139,1140,7,1,0,0,1140,288,1,0,0,0,1141,1142,7,24,0,0,1142,1143, + 7,12,0,0,1143,1144,7,6,0,0,1144,1145,7,7,0,0,1145,1146,7,6,0,0,1146,290, + 1,0,0,0,1147,1148,7,24,0,0,1148,1149,7,10,0,0,1149,1150,7,5,0,0,1150, + 1151,7,12,0,0,1151,292,1,0,0,0,1152,1153,7,24,0,0,1153,1154,7,7,0,0,1154, + 1155,7,10,0,0,1155,1156,7,5,0,0,1156,1157,7,6,0,0,1157,294,1,0,0,0,1158, + 1159,7,20,0,0,1159,1160,7,16,0,0,1160,1161,7,7,0,0,1161,296,1,0,0,0,1162, + 1163,7,8,0,0,1163,1164,7,10,0,0,1164,1165,7,1,0,0,1165,1166,7,11,0,0, + 1166,1167,7,4,0,0,1167,1168,7,6,0,0,1168,298,1,0,0,0,1169,1170,7,3,0, + 0,1170,1171,7,6,0,0,1171,1172,7,9,0,0,1172,1173,7,10,0,0,1173,1174,7, + 18,0,0,1174,1175,7,0,0,0,1175,1176,7,4,0,0,1176,300,1,0,0,0,1177,1178, + 5,42,0,0,1178,302,1,0,0,0,1179,1180,7,8,0,0,1180,1181,7,14,0,0,1181,1182, + 7,10,0,0,1182,1183,7,15,0,0,1183,304,1,0,0,0,1184,1185,5,33,0,0,1185, + 1186,5,61,0,0,1186,306,1,0,0,0,1187,1188,5,45,0,0,1188,308,1,0,0,0,1189, + 1190,5,33,0,0,1190,310,1,0,0,0,1191,1192,5,58,0,0,1192,312,1,0,0,0,1193, + 1198,5,34,0,0,1194,1197,3,377,188,0,1195,1197,3,315,157,0,1196,1194,1, + 0,0,0,1196,1195,1,0,0,0,1197,1200,1,0,0,0,1198,1196,1,0,0,0,1198,1199, + 1,0,0,0,1199,1201,1,0,0,0,1200,1198,1,0,0,0,1201,1212,5,34,0,0,1202,1207, + 5,39,0,0,1203,1206,3,357,178,0,1204,1206,3,315,157,0,1205,1203,1,0,0, + 0,1205,1204,1,0,0,0,1206,1209,1,0,0,0,1207,1205,1,0,0,0,1207,1208,1,0, + 0,0,1208,1210,1,0,0,0,1209,1207,1,0,0,0,1210,1212,5,39,0,0,1211,1193, + 1,0,0,0,1211,1202,1,0,0,0,1212,314,1,0,0,0,1213,1231,5,92,0,0,1214,1232, + 7,25,0,0,1215,1216,7,17,0,0,1216,1217,3,321,160,0,1217,1218,3,321,160, + 0,1218,1219,3,321,160,0,1219,1220,3,321,160,0,1220,1232,1,0,0,0,1221, + 1222,7,17,0,0,1222,1223,3,321,160,0,1223,1224,3,321,160,0,1224,1225,3, + 321,160,0,1225,1226,3,321,160,0,1226,1227,3,321,160,0,1227,1228,3,321, + 160,0,1228,1229,3,321,160,0,1229,1230,3,321,160,0,1230,1232,1,0,0,0,1231, + 1214,1,0,0,0,1231,1215,1,0,0,0,1231,1221,1,0,0,0,1232,316,1,0,0,0,1233, + 1242,3,329,164,0,1234,1238,3,325,162,0,1235,1237,3,323,161,0,1236,1235, + 1,0,0,0,1237,1240,1,0,0,0,1238,1236,1,0,0,0,1238,1239,1,0,0,0,1239,1242, + 1,0,0,0,1240,1238,1,0,0,0,1241,1233,1,0,0,0,1241,1234,1,0,0,0,1242,318, + 1,0,0,0,1243,1245,7,26,0,0,1244,1243,1,0,0,0,1245,320,1,0,0,0,1246,1249, + 3,323,161,0,1247,1249,3,319,159,0,1248,1246,1,0,0,0,1248,1247,1,0,0,0, + 1249,322,1,0,0,0,1250,1253,3,329,164,0,1251,1253,3,325,162,0,1252,1250, + 1,0,0,0,1252,1251,1,0,0,0,1253,324,1,0,0,0,1254,1257,3,327,163,0,1255, + 1257,2,56,57,0,1256,1254,1,0,0,0,1256,1255,1,0,0,0,1257,326,1,0,0,0,1258, + 1259,2,49,55,0,1259,328,1,0,0,0,1260,1261,5,48,0,0,1261,330,1,0,0,0,1262, + 1264,3,323,161,0,1263,1262,1,0,0,0,1264,1267,1,0,0,0,1265,1263,1,0,0, + 0,1265,1266,1,0,0,0,1266,1268,1,0,0,0,1267,1265,1,0,0,0,1268,1270,5,46, + 0,0,1269,1271,3,323,161,0,1270,1269,1,0,0,0,1271,1272,1,0,0,0,1272,1270, + 1,0,0,0,1272,1273,1,0,0,0,1273,332,1,0,0,0,1274,1278,3,335,167,0,1275, + 1277,3,337,168,0,1276,1275,1,0,0,0,1277,1280,1,0,0,0,1278,1276,1,0,0, + 0,1278,1279,1,0,0,0,1279,334,1,0,0,0,1280,1278,1,0,0,0,1281,1284,3,385, + 192,0,1282,1284,3,373,186,0,1283,1281,1,0,0,0,1283,1282,1,0,0,0,1284, + 336,1,0,0,0,1285,1288,3,353,176,0,1286,1288,3,369,184,0,1287,1285,1,0, + 0,0,1287,1286,1,0,0,0,1288,338,1,0,0,0,1289,1293,5,96,0,0,1290,1292,3, + 349,174,0,1291,1290,1,0,0,0,1292,1295,1,0,0,0,1293,1291,1,0,0,0,1293, + 1294,1,0,0,0,1294,1296,1,0,0,0,1295,1293,1,0,0,0,1296,1298,5,96,0,0,1297, + 1289,1,0,0,0,1298,1299,1,0,0,0,1299,1297,1,0,0,0,1299,1300,1,0,0,0,1300, + 340,1,0,0,0,1301,1303,3,343,171,0,1302,1301,1,0,0,0,1303,1304,1,0,0,0, + 1304,1302,1,0,0,0,1304,1305,1,0,0,0,1305,342,1,0,0,0,1306,1319,3,371, + 185,0,1307,1319,3,375,187,0,1308,1319,3,379,189,0,1309,1319,3,381,190, + 0,1310,1319,3,347,173,0,1311,1319,3,367,183,0,1312,1319,3,365,182,0,1313, + 1319,3,363,181,0,1314,1319,3,351,175,0,1315,1319,3,383,191,0,1316,1319, + 7,27,0,0,1317,1319,3,345,172,0,1318,1306,1,0,0,0,1318,1307,1,0,0,0,1318, + 1308,1,0,0,0,1318,1309,1,0,0,0,1318,1310,1,0,0,0,1318,1311,1,0,0,0,1318, + 1312,1,0,0,0,1318,1313,1,0,0,0,1318,1314,1,0,0,0,1318,1315,1,0,0,0,1318, + 1316,1,0,0,0,1318,1317,1,0,0,0,1319,344,1,0,0,0,1320,1321,5,47,0,0,1321, + 1322,5,42,0,0,1322,1328,1,0,0,0,1323,1327,3,355,177,0,1324,1325,5,42, + 0,0,1325,1327,3,361,180,0,1326,1323,1,0,0,0,1326,1324,1,0,0,0,1327,1330, + 1,0,0,0,1328,1326,1,0,0,0,1328,1329,1,0,0,0,1329,1331,1,0,0,0,1330,1328, + 1,0,0,0,1331,1332,5,42,0,0,1332,1350,5,47,0,0,1333,1334,5,47,0,0,1334, + 1335,5,47,0,0,1335,1339,1,0,0,0,1336,1338,3,359,179,0,1337,1336,1,0,0, + 0,1338,1341,1,0,0,0,1339,1337,1,0,0,0,1339,1340,1,0,0,0,1340,1343,1,0, + 0,0,1341,1339,1,0,0,0,1342,1344,3,367,183,0,1343,1342,1,0,0,0,1343,1344, + 1,0,0,0,1344,1347,1,0,0,0,1345,1348,3,379,189,0,1346,1348,5,0,0,1,1347, + 1345,1,0,0,0,1347,1346,1,0,0,0,1348,1350,1,0,0,0,1349,1320,1,0,0,0,1349, + 1333,1,0,0,0,1350,346,1,0,0,0,1351,1352,7,28,0,0,1352,348,1,0,0,0,1353, + 1354,8,29,0,0,1354,350,1,0,0,0,1355,1356,7,30,0,0,1356,352,1,0,0,0,1357, + 1358,7,31,0,0,1358,354,1,0,0,0,1359,1360,8,32,0,0,1360,356,1,0,0,0,1361, + 1362,8,33,0,0,1362,358,1,0,0,0,1363,1364,8,34,0,0,1364,360,1,0,0,0,1365, + 1366,8,35,0,0,1366,362,1,0,0,0,1367,1368,7,36,0,0,1368,364,1,0,0,0,1369, + 1370,7,37,0,0,1370,366,1,0,0,0,1371,1372,7,38,0,0,1372,368,1,0,0,0,1373, + 1374,7,39,0,0,1374,370,1,0,0,0,1375,1376,7,40,0,0,1376,372,1,0,0,0,1377, + 1378,7,41,0,0,1378,374,1,0,0,0,1379,1380,7,42,0,0,1380,376,1,0,0,0,1381, + 1382,8,43,0,0,1382,378,1,0,0,0,1383,1384,7,44,0,0,1384,380,1,0,0,0,1385, + 1386,7,45,0,0,1386,382,1,0,0,0,1387,1388,7,46,0,0,1388,384,1,0,0,0,1389, + 1390,7,47,0,0,1390,386,1,0,0,0,1391,1392,9,0,0,0,1392,388,1,0,0,0,28, + 0,1196,1198,1205,1207,1211,1231,1238,1241,1244,1248,1252,1256,1265,1272, + 1278,1283,1287,1293,1299,1304,1318,1326,1328,1339,1343,1347,1349,0 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); diff --git a/third_party/antlr4_cypher/cypher_parser.cpp b/third_party/antlr4_cypher/cypher_parser.cpp index a94f88792d4..0a000eee99e 100644 --- a/third_party/antlr4_cypher/cypher_parser.cpp +++ b/third_party/antlr4_cypher/cypher_parser.cpp @@ -56,17 +56,17 @@ void cypherParserInitialize() { "kU_ImportDatabase", "kU_AttachDatabase", "kU_Option", "kU_Options", "kU_DetachDatabase", "kU_UseDatabase", "kU_StandaloneCall", "kU_CommentOn", "kU_CreateMacro", "kU_PositionalArgs", "kU_DefaultArg", "kU_FilePaths", - "kU_ParsingOptions", "kU_IfNotExists", "kU_CreateNodeTable", "kU_CreateRelTable", - "kU_CreateRelTableGroup", "kU_RelTableConnection", "kU_CreateRdfGraph", - "kU_CreateSequence", "kU_CreateType", "kU_SequenceOptions", "kU_IncrementBy", - "kU_MinValue", "kU_MaxValue", "kU_StartWith", "kU_Cycle", "kU_IfExists", - "kU_Drop", "kU_AlterTable", "kU_AlterOptions", "kU_AddProperty", "kU_Default", - "kU_DropProperty", "kU_RenameTable", "kU_RenameProperty", "kU_ColumnDefinitions", - "kU_ColumnDefinition", "kU_PropertyDefinitions", "kU_PropertyDefinition", - "kU_CreateNodeConstraint", "kU_DataType", "kU_ListIdentifiers", "kU_ListIdentifier", - "oC_AnyCypherOption", "oC_Explain", "oC_Profile", "kU_Transaction", - "kU_Extension", "kU_LoadExtension", "kU_InstallExtension", "oC_Query", - "kU_ProjectGraph", "kU_GraphProjectionTableItems", "oC_RegularQuery", + "kU_ParsingOptions", "kU_IfNotExists", "kU_CreateNodeTable", "kU_CreateExternalNodeTable", + "kU_CreateRelTable", "kU_CreateRelTableGroup", "kU_RelTableConnection", + "kU_CreateRdfGraph", "kU_CreateSequence", "kU_CreateType", "kU_SequenceOptions", + "kU_IncrementBy", "kU_MinValue", "kU_MaxValue", "kU_StartWith", "kU_Cycle", + "kU_IfExists", "kU_Drop", "kU_AlterTable", "kU_AlterOptions", "kU_AddProperty", + "kU_Default", "kU_DropProperty", "kU_RenameTable", "kU_RenameProperty", + "kU_ColumnDefinitions", "kU_ColumnDefinition", "kU_PropertyDefinitions", + "kU_PropertyDefinition", "kU_PrimaryKey", "kU_DataType", "kU_ListIdentifiers", + "kU_ListIdentifier", "oC_AnyCypherOption", "oC_Explain", "oC_Profile", + "kU_Transaction", "kU_Extension", "kU_LoadExtension", "kU_InstallExtension", + "oC_Query", "kU_ProjectGraph", "kU_GraphProjectionTableItems", "oC_RegularQuery", "oC_Union", "oC_SingleQuery", "oC_SinglePartQuery", "oC_MultiPartQuery", "kU_QueryPart", "oC_UpdatingClause", "oC_ReadingClause", "kU_LoadFrom", "kU_InQueryCall", "kU_GraphProjectionTableItem", "kU_GraphProjectionColumnItems", @@ -93,11 +93,11 @@ void cypherParserInitialize() { "kU_ListEntry", "kU_StructLiteral", "kU_StructField", "oC_ParenthesizedExpression", "oC_FunctionInvocation", "oC_FunctionName", "kU_FunctionParameter", "kU_LambdaParameter", "kU_LambdaVars", "oC_PathPatterns", "oC_ExistSubquery", - "kU_CountSubquery", "oC_PropertyLookup", "oC_CaseExpression", "oC_CaseAlternative", - "oC_Variable", "oC_NumberLiteral", "oC_Parameter", "oC_PropertyExpression", - "oC_PropertyKeyName", "oC_IntegerLiteral", "oC_DoubleLiteral", "oC_SchemaName", - "oC_SymbolicName", "kU_NonReservedKeywords", "oC_LeftArrowHead", "oC_RightArrowHead", - "oC_Dash" + "kU_CountSubquery", "oC_PropertyLookup", "kU_TableLookup", "oC_CaseExpression", + "oC_CaseAlternative", "oC_Variable", "oC_NumberLiteral", "oC_Parameter", + "oC_PropertyExpression", "oC_PropertyKeyName", "oC_IntegerLiteral", + "oC_DoubleLiteral", "oC_SchemaName", "oC_SymbolicName", "kU_NonReservedKeywords", + "oC_LeftArrowHead", "oC_RightArrowHead", "oC_Dash" }, std::vector{ "", "';'", "'('", "','", "')'", "'.'", "'='", "'['", "']'", "'{'", @@ -112,8 +112,8 @@ void cypherParserInitialize() { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", - "", "", "'*'", "", "'!='", "'-'", "'!'", "':'", "", "", "", "", "", - "", "", "", "'0'" + "", "", "", "'*'", "", "'!='", "'-'", "'!'", "':'", "", "", "", "", + "", "", "", "", "'0'" }, std::vector{ "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", @@ -124,12 +124,12 @@ void cypherParserInitialize() { "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", "GLOB", "GRAPH", "GROUP", "HEADERS", - "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN", - "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", "MINVALUE", - "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", "ONLY", "OPTIONAL", - "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", "RDFGRAPH", "READ", - "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", + "EXTENSION", "EXTERNAL", "FALSE", "FROM", "GLOB", "GRAPH", "GROUP", + "HEADERS", "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", + "JOIN", "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", + "MINVALUE", "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", + "ONLY", "OPTIONAL", "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", + "RDFGRAPH", "READ", "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", "SEQUENCE", "SET", "SHORTEST", "START", "STARTS", "TABLE", "THEN", "TO", "TRANSACTION", "TRUE", "TYPE", "UNION", "UNWIND", "USE", "WHEN", "WHERE", "WITH", "WRITE", "XOR", "SINGLE", "DECIMAL", "STAR", "L_SKIP", @@ -141,7 +141,7 @@ void cypherParserInitialize() { } ); static const int32_t serializedATNSegment[] = { - 4,1,173,2830,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, + 4,1,174,2868,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, @@ -167,1111 +167,1125 @@ void cypherParserInitialize() { 7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158, 7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164, 7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170, - 7,170,2,171,7,171,2,172,7,172,2,173,7,173,1,0,1,0,3,0,351,8,0,1,0,1,0, - 3,0,355,8,0,1,0,5,0,358,8,0,10,0,12,0,361,9,0,1,0,3,0,364,8,0,1,0,1,0, - 1,1,3,1,369,8,1,1,1,3,1,372,8,1,1,1,1,1,3,1,376,8,1,1,1,3,1,379,8,1,1, - 2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2, - 1,2,1,2,1,2,1,2,3,2,403,8,2,1,3,1,3,1,3,1,3,3,3,409,8,3,1,3,1,3,3,3,413, - 8,3,1,3,3,3,416,8,3,1,3,1,3,1,3,1,3,3,3,422,8,3,1,3,3,3,425,8,3,1,4,1, - 4,3,4,429,8,4,1,4,1,4,3,4,433,8,4,1,4,1,4,3,4,437,8,4,1,4,5,4,440,8,4, - 10,4,12,4,443,9,4,1,4,3,4,446,8,4,1,4,1,4,1,5,1,5,1,5,3,5,453,8,5,1,5, - 1,5,3,5,457,8,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,465,8,5,1,5,1,5,3,5,469,8, - 5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,479,8,6,1,6,1,6,3,6,483,8,6,1,6, - 1,6,3,6,487,8,6,1,6,5,6,490,8,6,10,6,12,6,493,9,6,1,6,1,6,1,6,1,6,1,6, - 1,6,1,7,1,7,1,7,1,7,3,7,505,8,7,1,7,1,7,3,7,509,8,7,1,7,1,7,1,7,1,7,1, - 7,1,7,3,7,517,8,7,1,7,3,7,520,8,7,1,8,1,8,1,8,1,8,1,8,1,8,3,8,528,8,8, - 1,8,3,8,531,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,546,8,10,1,10,1,10,1,10,3,10,551,8,10,1,10,1,10,1,10,1,10,3, - 10,557,8,10,1,10,1,10,3,10,561,8,10,1,10,3,10,564,8,10,1,10,3,10,567, - 8,10,1,10,1,10,1,11,1,11,3,11,573,8,11,1,11,1,11,3,11,577,8,11,1,11,1, - 11,1,12,1,12,3,12,583,8,12,1,12,1,12,3,12,587,8,12,1,12,5,12,590,8,12, - 10,12,12,12,593,9,12,1,13,1,13,1,13,1,13,1,14,1,14,1,14,1,14,1,15,1,15, - 1,15,1,15,3,15,607,8,15,1,15,1,15,3,15,611,8,15,1,15,1,15,1,16,1,16,1, - 16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,17,1,17,1,17,1,17,1, - 17,1,17,3,17,633,8,17,1,17,1,17,3,17,637,8,17,1,17,3,17,640,8,17,1,17, - 3,17,643,8,17,1,17,3,17,646,8,17,1,17,3,17,649,8,17,1,17,1,17,3,17,653, - 8,17,1,17,5,17,656,8,17,10,17,12,17,659,9,17,1,17,3,17,662,8,17,1,17, - 1,17,1,17,1,17,1,17,1,17,1,18,1,18,3,18,672,8,18,1,18,1,18,3,18,676,8, - 18,1,18,5,18,679,8,18,10,18,12,18,682,9,18,1,19,1,19,3,19,686,8,19,1, - 19,1,19,1,19,3,19,691,8,19,1,19,1,19,1,20,1,20,3,20,697,8,20,1,20,1,20, - 3,20,701,8,20,1,20,1,20,3,20,705,8,20,1,20,5,20,708,8,20,10,20,12,20, - 711,9,20,1,20,1,20,1,20,1,20,3,20,717,8,20,1,20,1,20,3,20,721,8,20,1, - 20,1,20,3,20,725,8,20,1,20,3,20,728,8,20,1,21,1,21,3,21,732,8,21,1,21, - 1,21,3,21,736,8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22,1,22,1,23,1,23, - 1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,755,8,23,1,23,1,23,3,23,759,8, - 23,1,23,1,23,3,23,763,8,23,1,23,1,23,3,23,767,8,23,1,23,1,23,3,23,771, - 8,23,1,23,1,23,1,23,3,23,776,8,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,789,8,24,1,24,1,24,3,24,793,8,24,1,24,1,24,3, - 24,797,8,24,1,24,1,24,3,24,801,8,24,1,24,1,24,3,24,805,8,24,1,24,1,24, - 3,24,809,8,24,3,24,811,8,24,1,24,1,24,3,24,815,8,24,1,24,1,24,3,24,819, - 8,24,3,24,821,8,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25, - 1,25,1,25,1,25,3,25,836,8,25,1,25,1,25,3,25,840,8,25,1,25,1,25,3,25,844, - 8,25,1,25,1,25,3,25,848,8,25,1,25,1,25,3,25,852,8,25,1,25,4,25,855,8, - 25,11,25,12,25,856,1,25,3,25,860,8,25,1,25,1,25,3,25,864,8,25,1,25,1, - 25,3,25,868,8,25,3,25,870,8,25,1,25,1,25,3,25,874,8,25,1,25,1,25,3,25, - 878,8,25,3,25,880,8,25,1,25,1,25,1,26,1,26,1,26,1,26,1,26,1,26,1,26,1, - 26,1,27,1,27,1,27,1,27,1,27,1,27,1,27,3,27,899,8,27,1,27,1,27,1,28,1, - 28,1,28,1,28,1,28,1,28,1,28,3,28,910,8,28,1,28,1,28,1,28,5,28,915,8,28, - 10,28,12,28,918,9,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29,1,29, - 3,29,930,8,29,1,30,1,30,1,30,1,30,1,30,3,30,937,8,30,1,31,1,31,1,31,1, - 31,3,31,943,8,31,1,31,3,31,946,8,31,1,31,1,31,1,32,1,32,1,32,1,32,1,32, - 1,32,3,32,956,8,32,1,32,3,32,959,8,32,1,33,1,33,1,33,1,33,1,33,1,33,3, - 33,967,8,33,1,33,3,33,970,8,33,1,34,1,34,1,34,1,34,3,34,976,8,34,1,34, - 3,34,979,8,34,1,34,1,34,1,35,1,35,3,35,985,8,35,1,35,1,35,1,36,1,36,1, - 36,1,36,1,37,1,37,1,37,1,37,1,37,1,37,1,37,3,37,1000,8,37,1,37,1,37,1, - 38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,39,1,39,1,39,1,39,3,39,1016,8, - 39,1,40,1,40,1,40,1,40,1,40,1,40,1,40,3,40,1025,8,40,1,41,1,41,1,41,1, - 41,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1, - 44,1,44,1,44,1,44,1,44,1,45,1,45,3,45,1051,8,45,1,45,1,45,3,45,1055,8, - 45,1,45,5,45,1058,8,45,10,45,12,45,1061,9,45,1,46,1,46,1,46,1,46,1,47, - 1,47,3,47,1069,8,47,1,47,1,47,3,47,1073,8,47,1,47,5,47,1076,8,47,10,47, - 12,47,1079,9,47,1,48,1,48,1,48,3,48,1084,8,48,1,49,1,49,1,49,1,49,3,49, - 1090,8,49,1,49,1,49,3,49,1094,8,49,1,49,1,49,3,49,1098,8,49,1,49,1,49, - 1,50,1,50,1,50,1,50,3,50,1106,8,50,1,50,1,50,3,50,1110,8,50,1,50,1,50, - 3,50,1114,8,50,1,50,1,50,1,50,1,50,3,50,1120,8,50,1,50,1,50,3,50,1124, - 8,50,1,50,1,50,3,50,1128,8,50,1,50,1,50,1,50,1,50,3,50,1134,8,50,1,50, - 1,50,3,50,1138,8,50,1,50,1,50,3,50,1142,8,50,1,50,1,50,3,50,1146,8,50, - 1,50,1,50,3,50,1150,8,50,1,50,1,50,1,50,1,50,3,50,1156,8,50,1,50,1,50, - 3,50,1160,8,50,1,50,1,50,3,50,1164,8,50,1,50,1,50,3,50,1168,8,50,1,50, - 1,50,3,50,1172,8,50,1,50,1,50,3,50,1176,8,50,1,50,1,50,5,50,1180,8,50, - 10,50,12,50,1183,9,50,1,51,1,51,5,51,1187,8,51,10,51,12,51,1190,9,51, - 1,52,1,52,3,52,1194,8,52,1,52,1,52,1,53,1,53,3,53,1200,8,53,1,54,1,54, - 1,55,1,55,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56,1,56, - 1,56,3,56,1219,8,56,1,57,1,57,3,57,1223,8,57,1,58,1,58,1,58,1,58,1,58, - 1,58,3,58,1231,8,58,1,59,1,59,1,59,1,59,1,60,1,60,3,60,1239,8,60,3,60, - 1241,8,60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,61,3,61,1251,8,61,1,61, - 1,61,3,61,1255,8,61,1,61,1,61,3,61,1259,8,61,1,61,1,61,1,62,1,62,3,62, - 1265,8,62,1,62,1,62,3,62,1269,8,62,1,62,5,62,1272,8,62,10,62,12,62,1275, - 9,62,1,63,1,63,3,63,1279,8,63,1,63,5,63,1282,8,63,10,63,12,63,1285,9, - 63,1,63,1,63,3,63,1289,8,63,4,63,1291,8,63,11,63,12,63,1292,1,63,1,63, - 1,63,3,63,1298,8,63,1,64,1,64,1,64,1,64,3,64,1304,8,64,1,64,1,64,1,64, - 3,64,1309,8,64,1,64,3,64,1312,8,64,1,65,1,65,3,65,1316,8,65,1,66,1,66, - 3,66,1320,8,66,5,66,1322,8,66,10,66,12,66,1325,9,66,1,66,1,66,1,66,3, - 66,1330,8,66,5,66,1332,8,66,10,66,12,66,1335,9,66,1,66,1,66,3,66,1339, - 8,66,1,66,5,66,1342,8,66,10,66,12,66,1345,9,66,1,66,3,66,1348,8,66,1, - 66,3,66,1351,8,66,1,66,1,66,3,66,1355,8,66,4,66,1357,8,66,11,66,12,66, - 1358,1,66,1,66,3,66,1363,8,66,1,67,1,67,3,67,1367,8,67,4,67,1369,8,67, - 11,67,12,67,1370,1,67,1,67,1,68,1,68,3,68,1377,8,68,5,68,1379,8,68,10, - 68,12,68,1382,9,68,1,68,1,68,3,68,1386,8,68,5,68,1388,8,68,10,68,12,68, - 1391,9,68,1,68,1,68,1,69,1,69,1,69,1,69,3,69,1399,8,69,1,70,1,70,1,70, - 1,70,3,70,1405,8,70,1,71,1,71,1,71,1,71,1,71,1,71,3,71,1413,8,71,1,71, - 1,71,3,71,1417,8,71,1,71,1,71,3,71,1421,8,71,1,71,1,71,3,71,1425,8,71, - 1,71,1,71,1,71,1,71,1,71,3,71,1432,8,71,1,71,3,71,1435,8,71,1,71,3,71, - 1438,8,71,1,71,3,71,1441,8,71,1,72,1,72,3,72,1445,8,72,3,72,1447,8,72, - 1,72,1,72,1,72,1,72,3,72,1453,8,72,1,72,3,72,1456,8,72,1,73,1,73,3,73, - 1460,8,73,1,73,1,73,3,73,1464,8,73,1,73,1,73,3,73,1468,8,73,1,73,1,73, - 3,73,1472,8,73,1,74,1,74,3,74,1476,8,74,1,74,1,74,3,74,1480,8,74,1,74, - 5,74,1483,8,74,10,74,12,74,1486,9,74,1,75,1,75,1,75,3,75,1491,8,75,1, - 75,1,75,3,75,1495,8,75,1,76,1,76,3,76,1499,8,76,1,76,1,76,3,76,1503,8, - 76,1,76,1,76,1,76,3,76,1508,8,76,1,76,1,76,3,76,1512,8,76,1,77,1,77,1, - 77,1,77,1,78,1,78,1,78,3,78,1521,8,78,1,78,1,78,3,78,1525,8,78,1,78,1, - 78,1,78,3,78,1530,8,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1,78,1, - 78,4,78,1542,8,78,11,78,12,78,1543,5,78,1546,8,78,10,78,12,78,1549,9, - 78,1,79,1,79,3,79,1553,8,79,1,79,1,79,1,79,1,79,1,79,1,79,1,80,1,80,3, - 80,1563,8,80,1,80,1,80,1,81,1,81,3,81,1569,8,81,1,81,1,81,1,81,5,81,1574, - 8,81,10,81,12,81,1577,9,81,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1, - 82,1,82,3,82,1589,8,82,1,83,1,83,3,83,1593,8,83,1,83,1,83,3,83,1597,8, - 83,1,83,1,83,3,83,1601,8,83,1,83,5,83,1604,8,83,10,83,12,83,1607,9,83, - 1,84,1,84,3,84,1611,8,84,1,84,1,84,3,84,1615,8,84,1,84,1,84,1,85,1,85, - 3,85,1621,8,85,1,85,1,85,3,85,1625,8,85,1,85,1,85,3,85,1629,8,85,1,85, - 1,85,3,85,1633,8,85,1,85,5,85,1636,8,85,10,85,12,85,1639,9,85,1,86,1, - 86,1,86,3,86,1644,8,86,1,86,3,86,1647,8,86,1,87,1,87,1,87,1,88,3,88,1653, - 8,88,1,88,3,88,1656,8,88,1,88,1,88,1,88,1,88,3,88,1662,8,88,1,88,1,88, - 3,88,1666,8,88,1,88,1,88,3,88,1670,8,88,1,89,1,89,3,89,1674,8,89,1,89, - 1,89,3,89,1678,8,89,1,89,5,89,1681,8,89,10,89,12,89,1684,9,89,1,89,1, - 89,3,89,1688,8,89,1,89,1,89,3,89,1692,8,89,1,89,5,89,1695,8,89,10,89, - 12,89,1698,9,89,3,89,1700,8,89,1,90,1,90,1,90,1,90,1,90,1,90,1,90,3,90, - 1709,8,90,1,91,1,91,1,91,1,91,1,91,1,91,1,91,3,91,1718,8,91,1,91,5,91, - 1721,8,91,10,91,12,91,1724,9,91,1,92,1,92,1,92,1,92,1,93,1,93,1,93,1, - 93,1,94,1,94,3,94,1736,8,94,1,94,3,94,1739,8,94,1,95,1,95,1,95,1,95,1, - 96,1,96,3,96,1747,8,96,1,96,1,96,3,96,1751,8,96,1,96,5,96,1754,8,96,10, - 96,12,96,1757,9,96,1,97,1,97,3,97,1761,8,97,1,97,1,97,3,97,1765,8,97, - 1,97,1,97,1,97,3,97,1770,8,97,1,98,1,98,1,99,1,99,3,99,1776,8,99,1,99, - 5,99,1779,8,99,10,99,12,99,1782,9,99,1,99,1,99,1,99,1,99,3,99,1788,8, - 99,1,100,1,100,3,100,1792,8,100,1,100,1,100,3,100,1796,8,100,3,100,1798, - 8,100,1,100,1,100,3,100,1802,8,100,3,100,1804,8,100,1,100,1,100,3,100, - 1808,8,100,3,100,1810,8,100,1,100,1,100,1,101,1,101,3,101,1816,8,101, - 1,101,1,101,1,102,1,102,3,102,1822,8,102,1,102,1,102,3,102,1826,8,102, - 1,102,3,102,1829,8,102,1,102,3,102,1832,8,102,1,102,1,102,1,102,1,102, - 3,102,1838,8,102,1,102,3,102,1841,8,102,1,102,3,102,1844,8,102,1,102, - 1,102,3,102,1848,8,102,1,102,1,102,1,102,1,102,3,102,1854,8,102,1,102, - 3,102,1857,8,102,1,102,3,102,1860,8,102,1,102,1,102,3,102,1864,8,102, - 1,103,1,103,3,103,1868,8,103,1,103,1,103,3,103,1872,8,103,3,103,1874, - 8,103,1,103,1,103,3,103,1878,8,103,3,103,1880,8,103,1,103,1,103,3,103, - 1884,8,103,3,103,1886,8,103,1,103,1,103,3,103,1890,8,103,3,103,1892,8, - 103,1,103,1,103,1,104,1,104,3,104,1898,8,104,1,104,1,104,3,104,1902,8, - 104,1,104,1,104,3,104,1906,8,104,1,104,1,104,3,104,1910,8,104,1,104,1, - 104,3,104,1914,8,104,1,104,1,104,3,104,1918,8,104,1,104,1,104,3,104,1922, - 8,104,1,104,1,104,3,104,1926,8,104,5,104,1928,8,104,10,104,12,104,1931, - 9,104,3,104,1933,8,104,1,104,1,104,1,105,1,105,3,105,1939,8,105,1,105, - 1,105,3,105,1943,8,105,1,105,1,105,3,105,1947,8,105,1,105,3,105,1950, - 8,105,1,105,5,105,1953,8,105,10,105,12,105,1956,9,105,1,106,1,106,3,106, - 1960,8,106,1,106,5,106,1963,8,106,10,106,12,106,1966,9,106,1,107,1,107, - 3,107,1970,8,107,1,107,1,107,1,108,1,108,3,108,1976,8,108,1,108,1,108, - 1,108,1,108,3,108,1982,8,108,1,108,3,108,1985,8,108,1,108,3,108,1988, - 8,108,1,108,3,108,1991,8,108,1,108,1,108,3,108,1995,8,108,1,108,3,108, - 1998,8,108,1,108,3,108,2001,8,108,1,108,3,108,2004,8,108,1,108,3,108, - 2007,8,108,1,109,1,109,3,109,2011,8,109,1,109,1,109,3,109,2015,8,109, - 1,109,1,109,3,109,2019,8,109,1,109,1,109,3,109,2023,8,109,1,109,1,109, - 3,109,2027,8,109,1,109,1,109,3,109,2031,8,109,3,109,2033,8,109,1,109, - 3,109,2036,8,109,1,109,1,109,3,109,2040,8,109,1,109,1,109,3,109,2044, - 8,109,1,109,1,109,3,109,2048,8,109,1,109,1,109,3,109,2052,8,109,3,109, - 2054,8,109,1,109,1,109,1,110,1,110,3,110,2060,8,110,1,110,3,110,2063, - 8,110,1,110,3,110,2066,8,110,1,110,1,110,1,111,1,111,3,111,2072,8,111, - 1,111,3,111,2075,8,111,1,111,3,111,2078,8,111,1,111,1,111,1,112,1,112, - 1,113,1,113,1,114,1,114,1,115,1,115,1,116,1,116,1,117,1,117,1,117,1,117, - 1,117,5,117,2097,8,117,10,117,12,117,2100,9,117,1,118,1,118,1,118,1,118, - 1,118,5,118,2107,8,118,10,118,12,118,2110,9,118,1,119,1,119,1,119,1,119, - 1,119,5,119,2117,8,119,10,119,12,119,2120,9,119,1,120,1,120,3,120,2124, - 8,120,5,120,2126,8,120,10,120,12,120,2129,9,120,1,120,1,120,1,121,1,121, - 3,121,2135,8,121,1,121,1,121,3,121,2139,8,121,1,121,1,121,3,121,2143, - 8,121,1,121,1,121,3,121,2147,8,121,1,121,1,121,3,121,2151,8,121,1,121, - 1,121,1,121,1,121,1,121,1,121,3,121,2159,8,121,1,121,1,121,3,121,2163, - 8,121,1,121,1,121,3,121,2167,8,121,1,121,1,121,3,121,2171,8,121,1,121, - 1,121,4,121,2175,8,121,11,121,12,121,2176,1,121,1,121,3,121,2181,8,121, - 1,122,1,122,1,123,1,123,3,123,2187,8,123,1,123,1,123,3,123,2191,8,123, - 1,123,5,123,2194,8,123,10,123,12,123,2197,9,123,1,124,1,124,3,124,2201, - 8,124,1,124,1,124,3,124,2205,8,124,1,124,5,124,2208,8,124,10,124,12,124, - 2211,9,124,1,125,1,125,3,125,2215,8,125,1,125,1,125,3,125,2219,8,125, - 1,125,1,125,5,125,2223,8,125,10,125,12,125,2226,9,125,1,126,1,126,1,127, - 1,127,3,127,2232,8,127,1,127,1,127,3,127,2236,8,127,1,127,1,127,5,127, - 2240,8,127,10,127,12,127,2243,9,127,1,128,1,128,1,129,1,129,3,129,2249, - 8,129,1,129,1,129,3,129,2253,8,129,1,129,1,129,5,129,2257,8,129,10,129, - 12,129,2260,9,129,1,130,1,130,1,131,1,131,3,131,2266,8,131,1,131,1,131, - 3,131,2270,8,131,1,131,5,131,2273,8,131,10,131,12,131,2276,9,131,1,132, - 1,132,3,132,2280,8,132,5,132,2282,8,132,10,132,12,132,2285,9,132,1,132, - 1,132,3,132,2289,8,132,1,132,3,132,2292,8,132,1,133,1,133,1,133,4,133, - 2297,8,133,11,133,12,133,2298,1,133,3,133,2302,8,133,1,134,1,134,1,134, - 3,134,2307,8,134,1,134,1,134,1,134,1,134,1,134,1,134,1,134,3,134,2316, - 8,134,1,134,1,134,3,134,2320,8,134,1,134,3,134,2323,8,134,1,135,1,135, - 1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,1,135,3,135,2336,8,135, - 1,135,3,135,2339,8,135,1,135,1,135,1,136,3,136,2344,8,136,1,136,1,136, - 1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,1,137,3,137,2358, - 8,137,1,138,1,138,3,138,2362,8,138,1,138,5,138,2365,8,138,10,138,12,138, - 2368,9,138,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139,1,139, - 3,139,2380,8,139,1,140,1,140,3,140,2384,8,140,1,140,1,140,3,140,2388, - 8,140,1,140,1,140,3,140,2392,8,140,1,140,1,140,1,140,1,140,3,140,2398, - 8,140,1,140,1,140,3,140,2402,8,140,1,140,1,140,3,140,2406,8,140,1,140, - 1,140,1,140,1,140,3,140,2412,8,140,1,140,1,140,3,140,2416,8,140,1,140, - 1,140,3,140,2420,8,140,1,140,1,140,1,140,1,140,3,140,2426,8,140,1,140, - 1,140,3,140,2430,8,140,1,140,1,140,3,140,2434,8,140,1,140,1,140,3,140, - 2438,8,140,1,141,1,141,3,141,2442,8,141,1,141,3,141,2445,8,141,1,142, - 1,142,1,142,1,142,1,142,1,142,1,143,1,143,1,143,1,143,1,143,1,143,3,143, - 2459,8,143,1,144,1,144,1,145,1,145,3,145,2465,8,145,1,145,1,145,3,145, - 2469,8,145,1,145,1,145,3,145,2473,8,145,5,145,2475,8,145,10,145,12,145, - 2478,9,145,3,145,2480,8,145,1,145,1,145,1,146,1,146,3,146,2486,8,146, - 1,146,3,146,2489,8,146,1,147,1,147,3,147,2493,8,147,1,147,1,147,3,147, - 2497,8,147,1,147,1,147,3,147,2501,8,147,1,147,1,147,3,147,2505,8,147, - 5,147,2507,8,147,10,147,12,147,2510,9,147,1,147,1,147,1,148,1,148,3,148, - 2516,8,148,1,148,3,148,2519,8,148,1,148,1,148,3,148,2523,8,148,1,148, - 1,148,1,149,1,149,3,149,2529,8,149,1,149,1,149,3,149,2533,8,149,1,149, - 1,149,1,150,1,150,3,150,2539,8,150,1,150,1,150,3,150,2543,8,150,1,150, - 1,150,3,150,2547,8,150,1,150,1,150,1,150,3,150,2552,8,150,1,150,1,150, - 3,150,2556,8,150,1,150,1,150,3,150,2560,8,150,1,150,1,150,3,150,2564, - 8,150,1,150,1,150,1,150,3,150,2569,8,150,1,150,3,150,2572,8,150,1,150, - 3,150,2575,8,150,1,150,1,150,1,150,1,150,3,150,2581,8,150,1,150,1,150, - 3,150,2585,8,150,1,150,1,150,3,150,2589,8,150,3,150,2591,8,150,1,150, - 1,150,3,150,2595,8,150,1,150,1,150,3,150,2599,8,150,1,150,1,150,3,150, - 2603,8,150,5,150,2605,8,150,10,150,12,150,2608,9,150,3,150,2610,8,150, - 1,150,1,150,3,150,2614,8,150,1,151,1,151,1,152,1,152,3,152,2620,8,152, - 1,152,1,152,1,152,3,152,2625,8,152,3,152,2627,8,152,1,152,1,152,3,152, - 2631,8,152,1,153,1,153,3,153,2635,8,153,1,153,1,153,1,153,3,153,2640, - 8,153,1,153,1,153,3,153,2644,8,153,1,154,1,154,1,154,3,154,2649,8,154, - 1,154,1,154,3,154,2653,8,154,1,154,1,154,3,154,2657,8,154,1,154,1,154, - 3,154,2661,8,154,5,154,2663,8,154,10,154,12,154,2666,9,154,1,154,1,154, - 3,154,2670,8,154,1,155,1,155,3,155,2674,8,155,1,155,4,155,2677,8,155, - 11,155,12,155,2678,1,156,1,156,3,156,2683,8,156,1,156,1,156,3,156,2687, - 8,156,1,156,1,156,3,156,2691,8,156,1,156,1,156,3,156,2695,8,156,1,156, - 3,156,2698,8,156,1,156,3,156,2701,8,156,1,156,1,156,1,157,1,157,3,157, - 2707,8,157,1,157,1,157,3,157,2711,8,157,1,157,1,157,3,157,2715,8,157, - 1,157,1,157,3,157,2719,8,157,1,157,3,157,2722,8,157,1,157,3,157,2725, - 8,157,1,157,1,157,1,158,1,158,3,158,2731,8,158,1,158,1,158,3,158,2735, - 8,158,1,159,1,159,3,159,2739,8,159,1,159,4,159,2742,8,159,11,159,12,159, - 2743,1,159,1,159,3,159,2748,8,159,1,159,1,159,3,159,2752,8,159,1,159, - 4,159,2755,8,159,11,159,12,159,2756,3,159,2759,8,159,1,159,3,159,2762, - 8,159,1,159,1,159,3,159,2766,8,159,1,159,3,159,2769,8,159,1,159,3,159, - 2772,8,159,1,159,1,159,1,160,1,160,3,160,2778,8,160,1,160,1,160,3,160, - 2782,8,160,1,160,1,160,3,160,2786,8,160,1,160,1,160,1,161,1,161,1,162, - 1,162,3,162,2794,8,162,1,163,1,163,1,163,3,163,2799,8,163,1,164,1,164, - 3,164,2803,8,164,1,164,1,164,1,165,1,165,1,166,1,166,1,167,1,167,1,168, - 1,168,1,169,1,169,1,169,1,169,1,169,3,169,2820,8,169,1,170,1,170,1,171, - 1,171,1,172,1,172,1,173,1,173,1,173,0,2,100,156,174,0,2,4,6,8,10,12,14, - 16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60, - 62,64,66,68,70,72,74,76,78,80,82,84,86,88,90,92,94,96,98,100,102,104, - 106,108,110,112,114,116,118,120,122,124,126,128,130,132,134,136,138,140, - 142,144,146,148,150,152,154,156,158,160,162,164,166,168,170,172,174,176, - 178,180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,212, - 214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,244,246,248, - 250,252,254,256,258,260,262,264,266,268,270,272,274,276,278,280,282,284, - 286,288,290,292,294,296,298,300,302,304,306,308,310,312,314,316,318,320, - 322,324,326,328,330,332,334,336,338,340,342,344,346,0,11,3,0,122,122, - 129,129,134,134,2,0,52,53,74,75,2,0,6,6,13,17,1,0,19,20,2,0,21,21,153, - 153,2,0,22,23,150,150,2,0,86,86,138,138,29,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,89,89,93,94,96,96,98, - 98,100,102,104,107,109,110,121,121,123,127,129,130,132,132,137,137,139, - 139,142,142,146,146,149,149,151,151,2,0,14,14,27,30,2,0,16,16,31,34,2, - 0,35,45,153,153,3207,0,348,1,0,0,0,2,368,1,0,0,0,4,402,1,0,0,0,6,404, - 1,0,0,0,8,426,1,0,0,0,10,468,1,0,0,0,12,470,1,0,0,0,14,500,1,0,0,0,16, - 521,1,0,0,0,18,532,1,0,0,0,20,538,1,0,0,0,22,570,1,0,0,0,24,580,1,0,0, - 0,26,594,1,0,0,0,28,598,1,0,0,0,30,602,1,0,0,0,32,614,1,0,0,0,34,626, - 1,0,0,0,36,669,1,0,0,0,38,683,1,0,0,0,40,727,1,0,0,0,42,729,1,0,0,0,44, - 739,1,0,0,0,46,745,1,0,0,0,48,779,1,0,0,0,50,824,1,0,0,0,52,883,1,0,0, - 0,54,891,1,0,0,0,56,902,1,0,0,0,58,919,1,0,0,0,60,936,1,0,0,0,62,938, - 1,0,0,0,64,958,1,0,0,0,66,969,1,0,0,0,68,971,1,0,0,0,70,984,1,0,0,0,72, - 988,1,0,0,0,74,992,1,0,0,0,76,1003,1,0,0,0,78,1015,1,0,0,0,80,1017,1, - 0,0,0,82,1026,1,0,0,0,84,1030,1,0,0,0,86,1034,1,0,0,0,88,1040,1,0,0,0, - 90,1048,1,0,0,0,92,1062,1,0,0,0,94,1066,1,0,0,0,96,1080,1,0,0,0,98,1085, - 1,0,0,0,100,1175,1,0,0,0,102,1184,1,0,0,0,104,1191,1,0,0,0,106,1199,1, - 0,0,0,108,1201,1,0,0,0,110,1203,1,0,0,0,112,1218,1,0,0,0,114,1222,1,0, - 0,0,116,1224,1,0,0,0,118,1232,1,0,0,0,120,1240,1,0,0,0,122,1244,1,0,0, - 0,124,1262,1,0,0,0,126,1297,1,0,0,0,128,1311,1,0,0,0,130,1315,1,0,0,0, - 132,1362,1,0,0,0,134,1368,1,0,0,0,136,1380,1,0,0,0,138,1398,1,0,0,0,140, - 1404,1,0,0,0,142,1406,1,0,0,0,144,1446,1,0,0,0,146,1457,1,0,0,0,148,1473, - 1,0,0,0,150,1487,1,0,0,0,152,1498,1,0,0,0,154,1513,1,0,0,0,156,1529,1, - 0,0,0,158,1550,1,0,0,0,160,1560,1,0,0,0,162,1566,1,0,0,0,164,1588,1,0, - 0,0,166,1590,1,0,0,0,168,1608,1,0,0,0,170,1620,1,0,0,0,172,1640,1,0,0, - 0,174,1648,1,0,0,0,176,1655,1,0,0,0,178,1699,1,0,0,0,180,1708,1,0,0,0, - 182,1710,1,0,0,0,184,1725,1,0,0,0,186,1729,1,0,0,0,188,1733,1,0,0,0,190, - 1740,1,0,0,0,192,1744,1,0,0,0,194,1769,1,0,0,0,196,1771,1,0,0,0,198,1787, - 1,0,0,0,200,1789,1,0,0,0,202,1813,1,0,0,0,204,1863,1,0,0,0,206,1865,1, - 0,0,0,208,1895,1,0,0,0,210,1936,1,0,0,0,212,1957,1,0,0,0,214,1967,1,0, - 0,0,216,1973,1,0,0,0,218,2008,1,0,0,0,220,2057,1,0,0,0,222,2069,1,0,0, - 0,224,2081,1,0,0,0,226,2083,1,0,0,0,228,2085,1,0,0,0,230,2087,1,0,0,0, - 232,2089,1,0,0,0,234,2091,1,0,0,0,236,2101,1,0,0,0,238,2111,1,0,0,0,240, - 2127,1,0,0,0,242,2180,1,0,0,0,244,2182,1,0,0,0,246,2184,1,0,0,0,248,2198, - 1,0,0,0,250,2212,1,0,0,0,252,2227,1,0,0,0,254,2229,1,0,0,0,256,2244,1, - 0,0,0,258,2246,1,0,0,0,260,2261,1,0,0,0,262,2263,1,0,0,0,264,2283,1,0, - 0,0,266,2293,1,0,0,0,268,2322,1,0,0,0,270,2335,1,0,0,0,272,2343,1,0,0, - 0,274,2357,1,0,0,0,276,2359,1,0,0,0,278,2379,1,0,0,0,280,2437,1,0,0,0, - 282,2439,1,0,0,0,284,2446,1,0,0,0,286,2458,1,0,0,0,288,2460,1,0,0,0,290, - 2462,1,0,0,0,292,2483,1,0,0,0,294,2490,1,0,0,0,296,2515,1,0,0,0,298,2526, - 1,0,0,0,300,2613,1,0,0,0,302,2615,1,0,0,0,304,2630,1,0,0,0,306,2632,1, - 0,0,0,308,2669,1,0,0,0,310,2671,1,0,0,0,312,2680,1,0,0,0,314,2704,1,0, - 0,0,316,2728,1,0,0,0,318,2758,1,0,0,0,320,2775,1,0,0,0,322,2789,1,0,0, - 0,324,2793,1,0,0,0,326,2795,1,0,0,0,328,2800,1,0,0,0,330,2806,1,0,0,0, - 332,2808,1,0,0,0,334,2810,1,0,0,0,336,2812,1,0,0,0,338,2819,1,0,0,0,340, - 2821,1,0,0,0,342,2823,1,0,0,0,344,2825,1,0,0,0,346,2827,1,0,0,0,348,359, - 3,2,1,0,349,351,5,170,0,0,350,349,1,0,0,0,350,351,1,0,0,0,351,352,1,0, - 0,0,352,354,5,1,0,0,353,355,5,170,0,0,354,353,1,0,0,0,354,355,1,0,0,0, - 355,356,1,0,0,0,356,358,3,2,1,0,357,350,1,0,0,0,358,361,1,0,0,0,359,357, - 1,0,0,0,359,360,1,0,0,0,360,363,1,0,0,0,361,359,1,0,0,0,362,364,5,170, - 0,0,363,362,1,0,0,0,363,364,1,0,0,0,364,365,1,0,0,0,365,366,5,0,0,1,366, - 1,1,0,0,0,367,369,3,106,53,0,368,367,1,0,0,0,368,369,1,0,0,0,369,371, - 1,0,0,0,370,372,5,170,0,0,371,370,1,0,0,0,371,372,1,0,0,0,372,373,1,0, - 0,0,373,378,3,4,2,0,374,376,5,170,0,0,375,374,1,0,0,0,375,376,1,0,0,0, - 376,377,1,0,0,0,377,379,5,1,0,0,378,375,1,0,0,0,378,379,1,0,0,0,379,3, - 1,0,0,0,380,403,3,120,60,0,381,403,3,46,23,0,382,403,3,48,24,0,383,403, - 3,50,25,0,384,403,3,54,27,0,385,403,3,56,28,0,386,403,3,58,29,0,387,403, - 3,74,37,0,388,403,3,76,38,0,389,403,3,6,3,0,390,403,3,12,6,0,391,403, - 3,14,7,0,392,403,3,30,15,0,393,403,3,34,17,0,394,403,3,32,16,0,395,403, - 3,112,56,0,396,403,3,114,57,0,397,403,3,16,8,0,398,403,3,18,9,0,399,403, - 3,20,10,0,400,403,3,26,13,0,401,403,3,28,14,0,402,380,1,0,0,0,402,381, - 1,0,0,0,402,382,1,0,0,0,402,383,1,0,0,0,402,384,1,0,0,0,402,385,1,0,0, - 0,402,386,1,0,0,0,402,387,1,0,0,0,402,388,1,0,0,0,402,389,1,0,0,0,402, - 390,1,0,0,0,402,391,1,0,0,0,402,392,1,0,0,0,402,393,1,0,0,0,402,394,1, - 0,0,0,402,395,1,0,0,0,402,396,1,0,0,0,402,397,1,0,0,0,402,398,1,0,0,0, - 402,399,1,0,0,0,402,400,1,0,0,0,402,401,1,0,0,0,403,5,1,0,0,0,404,405, - 5,66,0,0,405,406,5,170,0,0,406,415,3,336,168,0,407,409,5,170,0,0,408, - 407,1,0,0,0,408,409,1,0,0,0,409,410,1,0,0,0,410,412,3,8,4,0,411,413,5, - 170,0,0,412,411,1,0,0,0,412,413,1,0,0,0,413,416,1,0,0,0,414,416,5,170, - 0,0,415,408,1,0,0,0,415,414,1,0,0,0,416,417,1,0,0,0,417,418,5,87,0,0, - 418,419,5,170,0,0,419,424,3,10,5,0,420,422,5,170,0,0,421,420,1,0,0,0, - 421,422,1,0,0,0,422,423,1,0,0,0,423,425,3,42,21,0,424,421,1,0,0,0,424, - 425,1,0,0,0,425,7,1,0,0,0,426,428,5,2,0,0,427,429,5,170,0,0,428,427,1, - 0,0,0,428,429,1,0,0,0,429,430,1,0,0,0,430,441,3,336,168,0,431,433,5,170, - 0,0,432,431,1,0,0,0,432,433,1,0,0,0,433,434,1,0,0,0,434,436,5,3,0,0,435, - 437,5,170,0,0,436,435,1,0,0,0,436,437,1,0,0,0,437,438,1,0,0,0,438,440, - 3,336,168,0,439,432,1,0,0,0,440,443,1,0,0,0,441,439,1,0,0,0,441,442,1, - 0,0,0,442,445,1,0,0,0,443,441,1,0,0,0,444,446,5,170,0,0,445,444,1,0,0, - 0,445,446,1,0,0,0,446,447,1,0,0,0,447,448,5,4,0,0,448,9,1,0,0,0,449,469, - 3,40,20,0,450,452,5,2,0,0,451,453,5,170,0,0,452,451,1,0,0,0,452,453,1, - 0,0,0,453,454,1,0,0,0,454,456,3,120,60,0,455,457,5,170,0,0,456,455,1, - 0,0,0,456,457,1,0,0,0,457,458,1,0,0,0,458,459,5,4,0,0,459,469,1,0,0,0, - 460,469,3,322,161,0,461,462,3,322,161,0,462,464,5,5,0,0,463,465,5,170, - 0,0,464,463,1,0,0,0,464,465,1,0,0,0,465,466,1,0,0,0,466,467,3,336,168, - 0,467,469,1,0,0,0,468,449,1,0,0,0,468,450,1,0,0,0,468,460,1,0,0,0,468, - 461,1,0,0,0,469,11,1,0,0,0,470,471,5,66,0,0,471,472,5,170,0,0,472,473, - 3,336,168,0,473,474,5,170,0,0,474,475,5,87,0,0,475,476,5,170,0,0,476, - 478,5,2,0,0,477,479,5,170,0,0,478,477,1,0,0,0,478,479,1,0,0,0,479,480, - 1,0,0,0,480,491,5,156,0,0,481,483,5,170,0,0,482,481,1,0,0,0,482,483,1, - 0,0,0,483,484,1,0,0,0,484,486,5,3,0,0,485,487,5,170,0,0,486,485,1,0,0, - 0,486,487,1,0,0,0,487,488,1,0,0,0,488,490,5,156,0,0,489,482,1,0,0,0,490, - 493,1,0,0,0,491,489,1,0,0,0,491,492,1,0,0,0,492,494,1,0,0,0,493,491,1, - 0,0,0,494,495,5,4,0,0,495,496,5,170,0,0,496,497,5,56,0,0,497,498,5,170, - 0,0,498,499,5,61,0,0,499,13,1,0,0,0,500,501,5,66,0,0,501,502,5,170,0, - 0,502,504,5,2,0,0,503,505,5,170,0,0,504,503,1,0,0,0,504,505,1,0,0,0,505, - 506,1,0,0,0,506,508,3,120,60,0,507,509,5,170,0,0,508,507,1,0,0,0,508, - 509,1,0,0,0,509,510,1,0,0,0,510,511,5,4,0,0,511,512,5,170,0,0,512,513, - 5,136,0,0,513,514,5,170,0,0,514,519,5,156,0,0,515,517,5,170,0,0,516,515, - 1,0,0,0,516,517,1,0,0,0,517,518,1,0,0,0,518,520,3,42,21,0,519,516,1,0, - 0,0,519,520,1,0,0,0,520,15,1,0,0,0,521,522,5,84,0,0,522,523,5,170,0,0, - 523,524,5,70,0,0,524,525,5,170,0,0,525,530,5,156,0,0,526,528,5,170,0, - 0,527,526,1,0,0,0,527,528,1,0,0,0,528,529,1,0,0,0,529,531,3,42,21,0,530, - 527,1,0,0,0,530,531,1,0,0,0,531,17,1,0,0,0,532,533,5,93,0,0,533,534,5, - 170,0,0,534,535,5,70,0,0,535,536,5,170,0,0,536,537,5,156,0,0,537,19,1, - 0,0,0,538,539,5,54,0,0,539,540,5,170,0,0,540,545,5,156,0,0,541,542,5, - 170,0,0,542,543,5,51,0,0,543,544,5,170,0,0,544,546,3,336,168,0,545,541, - 1,0,0,0,545,546,1,0,0,0,546,547,1,0,0,0,547,548,5,170,0,0,548,550,5,2, - 0,0,549,551,5,170,0,0,550,549,1,0,0,0,550,551,1,0,0,0,551,552,1,0,0,0, - 552,553,5,71,0,0,553,554,5,170,0,0,554,563,3,338,169,0,555,557,5,170, - 0,0,556,555,1,0,0,0,556,557,1,0,0,0,557,558,1,0,0,0,558,560,5,3,0,0,559, - 561,5,170,0,0,560,559,1,0,0,0,560,561,1,0,0,0,561,562,1,0,0,0,562,564, - 3,24,12,0,563,556,1,0,0,0,563,564,1,0,0,0,564,566,1,0,0,0,565,567,5,170, - 0,0,566,565,1,0,0,0,566,567,1,0,0,0,567,568,1,0,0,0,568,569,5,4,0,0,569, - 21,1,0,0,0,570,572,3,338,169,0,571,573,5,170,0,0,572,571,1,0,0,0,572, - 573,1,0,0,0,573,574,1,0,0,0,574,576,5,6,0,0,575,577,5,170,0,0,576,575, - 1,0,0,0,576,577,1,0,0,0,577,578,1,0,0,0,578,579,3,286,143,0,579,23,1, - 0,0,0,580,591,3,22,11,0,581,583,5,170,0,0,582,581,1,0,0,0,582,583,1,0, - 0,0,583,584,1,0,0,0,584,586,5,3,0,0,585,587,5,170,0,0,586,585,1,0,0,0, - 586,587,1,0,0,0,587,588,1,0,0,0,588,590,3,22,11,0,589,582,1,0,0,0,590, - 593,1,0,0,0,591,589,1,0,0,0,591,592,1,0,0,0,592,25,1,0,0,0,593,591,1, - 0,0,0,594,595,5,76,0,0,595,596,5,170,0,0,596,597,3,336,168,0,597,27,1, - 0,0,0,598,599,5,142,0,0,599,600,5,170,0,0,600,601,3,336,168,0,601,29, - 1,0,0,0,602,603,5,57,0,0,603,604,5,170,0,0,604,606,3,338,169,0,605,607, - 5,170,0,0,606,605,1,0,0,0,606,607,1,0,0,0,607,608,1,0,0,0,608,610,5,6, - 0,0,609,611,5,170,0,0,610,609,1,0,0,0,610,611,1,0,0,0,611,612,1,0,0,0, - 612,613,3,232,116,0,613,31,1,0,0,0,614,615,5,62,0,0,615,616,5,170,0,0, - 616,617,5,114,0,0,617,618,5,170,0,0,618,619,5,134,0,0,619,620,5,170,0, - 0,620,621,3,336,168,0,621,622,5,170,0,0,622,623,5,98,0,0,623,624,5,170, - 0,0,624,625,5,156,0,0,625,33,1,0,0,0,626,627,5,68,0,0,627,628,5,170,0, - 0,628,629,5,103,0,0,629,630,5,170,0,0,630,632,3,302,151,0,631,633,5,170, - 0,0,632,631,1,0,0,0,632,633,1,0,0,0,633,634,1,0,0,0,634,636,5,2,0,0,635, - 637,5,170,0,0,636,635,1,0,0,0,636,637,1,0,0,0,637,639,1,0,0,0,638,640, - 3,36,18,0,639,638,1,0,0,0,639,640,1,0,0,0,640,642,1,0,0,0,641,643,5,170, - 0,0,642,641,1,0,0,0,642,643,1,0,0,0,643,645,1,0,0,0,644,646,3,38,19,0, - 645,644,1,0,0,0,645,646,1,0,0,0,646,657,1,0,0,0,647,649,5,170,0,0,648, - 647,1,0,0,0,648,649,1,0,0,0,649,650,1,0,0,0,650,652,5,3,0,0,651,653,5, - 170,0,0,652,651,1,0,0,0,652,653,1,0,0,0,653,654,1,0,0,0,654,656,3,38, - 19,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,661,1,0,0,0,659,657,1,0,0,0,660,662,5,170,0,0,661,660,1,0,0,0,661, - 662,1,0,0,0,662,663,1,0,0,0,663,664,5,4,0,0,664,665,5,170,0,0,665,666, - 5,51,0,0,666,667,5,170,0,0,667,668,3,232,116,0,668,35,1,0,0,0,669,680, - 3,338,169,0,670,672,5,170,0,0,671,670,1,0,0,0,671,672,1,0,0,0,672,673, - 1,0,0,0,673,675,5,3,0,0,674,676,5,170,0,0,675,674,1,0,0,0,675,676,1,0, - 0,0,676,677,1,0,0,0,677,679,3,338,169,0,678,671,1,0,0,0,679,682,1,0,0, - 0,680,678,1,0,0,0,680,681,1,0,0,0,681,37,1,0,0,0,682,680,1,0,0,0,683, - 685,3,338,169,0,684,686,5,170,0,0,685,684,1,0,0,0,685,686,1,0,0,0,686, - 687,1,0,0,0,687,688,5,155,0,0,688,690,5,6,0,0,689,691,5,170,0,0,690,689, - 1,0,0,0,690,691,1,0,0,0,691,692,1,0,0,0,692,693,3,286,143,0,693,39,1, - 0,0,0,694,696,5,7,0,0,695,697,5,170,0,0,696,695,1,0,0,0,696,697,1,0,0, - 0,697,698,1,0,0,0,698,709,5,156,0,0,699,701,5,170,0,0,700,699,1,0,0,0, - 700,701,1,0,0,0,701,702,1,0,0,0,702,704,5,3,0,0,703,705,5,170,0,0,704, - 703,1,0,0,0,704,705,1,0,0,0,705,706,1,0,0,0,706,708,5,156,0,0,707,700, - 1,0,0,0,708,711,1,0,0,0,709,707,1,0,0,0,709,710,1,0,0,0,710,712,1,0,0, - 0,711,709,1,0,0,0,712,728,5,8,0,0,713,728,5,156,0,0,714,716,5,88,0,0, - 715,717,5,170,0,0,716,715,1,0,0,0,716,717,1,0,0,0,717,718,1,0,0,0,718, - 720,5,2,0,0,719,721,5,170,0,0,720,719,1,0,0,0,720,721,1,0,0,0,721,722, - 1,0,0,0,722,724,5,156,0,0,723,725,5,170,0,0,724,723,1,0,0,0,724,725,1, - 0,0,0,725,726,1,0,0,0,726,728,5,4,0,0,727,694,1,0,0,0,727,713,1,0,0,0, - 727,714,1,0,0,0,728,41,1,0,0,0,729,731,5,2,0,0,730,732,5,170,0,0,731, - 730,1,0,0,0,731,732,1,0,0,0,732,733,1,0,0,0,733,735,3,24,12,0,734,736, - 5,170,0,0,735,734,1,0,0,0,735,736,1,0,0,0,736,737,1,0,0,0,737,738,5,4, - 0,0,738,43,1,0,0,0,739,740,5,94,0,0,740,741,5,170,0,0,741,742,5,111,0, - 0,742,743,5,170,0,0,743,744,5,82,0,0,744,45,1,0,0,0,745,746,5,68,0,0, - 746,747,5,170,0,0,747,748,5,110,0,0,748,749,5,170,0,0,749,750,5,134,0, - 0,750,754,5,170,0,0,751,752,3,44,22,0,752,753,5,170,0,0,753,755,1,0,0, - 0,754,751,1,0,0,0,754,755,1,0,0,0,755,756,1,0,0,0,756,758,3,336,168,0, - 757,759,5,170,0,0,758,757,1,0,0,0,758,759,1,0,0,0,759,760,1,0,0,0,760, - 762,5,2,0,0,761,763,5,170,0,0,762,761,1,0,0,0,762,763,1,0,0,0,763,764, - 1,0,0,0,764,766,3,94,47,0,765,767,5,170,0,0,766,765,1,0,0,0,766,767,1, - 0,0,0,767,768,1,0,0,0,768,770,5,3,0,0,769,771,5,170,0,0,770,769,1,0,0, - 0,770,771,1,0,0,0,771,772,1,0,0,0,772,773,3,98,49,0,773,775,1,0,0,0,774, - 776,5,170,0,0,775,774,1,0,0,0,775,776,1,0,0,0,776,777,1,0,0,0,777,778, - 5,4,0,0,778,47,1,0,0,0,779,780,5,68,0,0,780,781,5,170,0,0,781,782,5,124, - 0,0,782,783,5,170,0,0,783,784,5,134,0,0,784,788,5,170,0,0,785,786,3,44, - 22,0,786,787,5,170,0,0,787,789,1,0,0,0,788,785,1,0,0,0,788,789,1,0,0, - 0,789,790,1,0,0,0,790,792,3,336,168,0,791,793,5,170,0,0,792,791,1,0,0, - 0,792,793,1,0,0,0,793,794,1,0,0,0,794,796,5,2,0,0,795,797,5,170,0,0,796, - 795,1,0,0,0,796,797,1,0,0,0,797,798,1,0,0,0,798,800,3,52,26,0,799,801, - 5,170,0,0,800,799,1,0,0,0,800,801,1,0,0,0,801,810,1,0,0,0,802,804,5,3, - 0,0,803,805,5,170,0,0,804,803,1,0,0,0,804,805,1,0,0,0,805,806,1,0,0,0, - 806,808,3,94,47,0,807,809,5,170,0,0,808,807,1,0,0,0,808,809,1,0,0,0,809, - 811,1,0,0,0,810,802,1,0,0,0,810,811,1,0,0,0,811,820,1,0,0,0,812,814,5, - 3,0,0,813,815,5,170,0,0,814,813,1,0,0,0,814,815,1,0,0,0,815,816,1,0,0, - 0,816,818,3,338,169,0,817,819,5,170,0,0,818,817,1,0,0,0,818,819,1,0,0, - 0,819,821,1,0,0,0,820,812,1,0,0,0,820,821,1,0,0,0,821,822,1,0,0,0,822, - 823,5,4,0,0,823,49,1,0,0,0,824,825,5,68,0,0,825,826,5,170,0,0,826,827, - 5,124,0,0,827,828,5,170,0,0,828,829,5,134,0,0,829,830,5,170,0,0,830,831, - 5,90,0,0,831,835,5,170,0,0,832,833,3,44,22,0,833,834,5,170,0,0,834,836, - 1,0,0,0,835,832,1,0,0,0,835,836,1,0,0,0,836,837,1,0,0,0,837,839,3,336, - 168,0,838,840,5,170,0,0,839,838,1,0,0,0,839,840,1,0,0,0,840,841,1,0,0, - 0,841,843,5,2,0,0,842,844,5,170,0,0,843,842,1,0,0,0,843,844,1,0,0,0,844, - 845,1,0,0,0,845,854,3,52,26,0,846,848,5,170,0,0,847,846,1,0,0,0,847,848, - 1,0,0,0,848,849,1,0,0,0,849,851,5,3,0,0,850,852,5,170,0,0,851,850,1,0, - 0,0,851,852,1,0,0,0,852,853,1,0,0,0,853,855,3,52,26,0,854,847,1,0,0,0, - 855,856,1,0,0,0,856,854,1,0,0,0,856,857,1,0,0,0,857,859,1,0,0,0,858,860, - 5,170,0,0,859,858,1,0,0,0,859,860,1,0,0,0,860,869,1,0,0,0,861,863,5,3, - 0,0,862,864,5,170,0,0,863,862,1,0,0,0,863,864,1,0,0,0,864,865,1,0,0,0, - 865,867,3,94,47,0,866,868,5,170,0,0,867,866,1,0,0,0,867,868,1,0,0,0,868, - 870,1,0,0,0,869,861,1,0,0,0,869,870,1,0,0,0,870,879,1,0,0,0,871,873,5, - 3,0,0,872,874,5,170,0,0,873,872,1,0,0,0,873,874,1,0,0,0,874,875,1,0,0, - 0,875,877,3,338,169,0,876,878,5,170,0,0,877,876,1,0,0,0,877,878,1,0,0, - 0,878,880,1,0,0,0,879,871,1,0,0,0,879,880,1,0,0,0,880,881,1,0,0,0,881, - 882,5,4,0,0,882,51,1,0,0,0,883,884,5,87,0,0,884,885,5,170,0,0,885,886, - 3,336,168,0,886,887,5,170,0,0,887,888,5,136,0,0,888,889,5,170,0,0,889, - 890,3,336,168,0,890,53,1,0,0,0,891,892,5,68,0,0,892,893,5,170,0,0,893, - 894,5,122,0,0,894,898,5,170,0,0,895,896,3,44,22,0,896,897,5,170,0,0,897, - 899,1,0,0,0,898,895,1,0,0,0,898,899,1,0,0,0,899,900,1,0,0,0,900,901,3, - 336,168,0,901,55,1,0,0,0,902,903,5,68,0,0,903,904,5,170,0,0,904,905,5, - 129,0,0,905,909,5,170,0,0,906,907,3,44,22,0,907,908,5,170,0,0,908,910, - 1,0,0,0,909,906,1,0,0,0,909,910,1,0,0,0,910,911,1,0,0,0,911,916,3,336, - 168,0,912,913,5,170,0,0,913,915,3,60,30,0,914,912,1,0,0,0,915,918,1,0, - 0,0,916,914,1,0,0,0,916,917,1,0,0,0,917,57,1,0,0,0,918,916,1,0,0,0,919, - 920,5,68,0,0,920,921,5,170,0,0,921,922,5,139,0,0,922,923,5,170,0,0,923, - 924,3,336,168,0,924,925,5,170,0,0,925,926,5,51,0,0,926,927,5,170,0,0, - 927,929,3,100,50,0,928,930,5,170,0,0,929,928,1,0,0,0,929,930,1,0,0,0, - 930,59,1,0,0,0,931,937,3,62,31,0,932,937,3,64,32,0,933,937,3,66,33,0, - 934,937,3,68,34,0,935,937,3,70,35,0,936,931,1,0,0,0,936,932,1,0,0,0,936, - 933,1,0,0,0,936,934,1,0,0,0,936,935,1,0,0,0,937,61,1,0,0,0,938,939,5, - 96,0,0,939,942,5,170,0,0,940,941,5,56,0,0,941,943,5,170,0,0,942,940,1, - 0,0,0,942,943,1,0,0,0,943,945,1,0,0,0,944,946,5,153,0,0,945,944,1,0,0, - 0,945,946,1,0,0,0,946,947,1,0,0,0,947,948,3,332,166,0,948,63,1,0,0,0, - 949,950,5,109,0,0,950,951,5,170,0,0,951,959,5,107,0,0,952,953,5,107,0, - 0,953,955,5,170,0,0,954,956,5,153,0,0,955,954,1,0,0,0,955,956,1,0,0,0, - 956,957,1,0,0,0,957,959,3,332,166,0,958,949,1,0,0,0,958,952,1,0,0,0,959, - 65,1,0,0,0,960,961,5,109,0,0,961,962,5,170,0,0,962,970,5,105,0,0,963, - 964,5,105,0,0,964,966,5,170,0,0,965,967,5,153,0,0,966,965,1,0,0,0,966, - 967,1,0,0,0,967,968,1,0,0,0,968,970,3,332,166,0,969,960,1,0,0,0,969,963, - 1,0,0,0,970,67,1,0,0,0,971,972,5,132,0,0,972,975,5,170,0,0,973,974,5, - 145,0,0,974,976,5,170,0,0,975,973,1,0,0,0,975,976,1,0,0,0,976,978,1,0, - 0,0,977,979,5,153,0,0,978,977,1,0,0,0,978,979,1,0,0,0,979,980,1,0,0,0, - 980,981,3,332,166,0,981,69,1,0,0,0,982,983,5,109,0,0,983,985,5,170,0, - 0,984,982,1,0,0,0,984,985,1,0,0,0,985,986,1,0,0,0,986,987,5,69,0,0,987, - 71,1,0,0,0,988,989,5,94,0,0,989,990,5,170,0,0,990,991,5,82,0,0,991,73, - 1,0,0,0,992,993,5,78,0,0,993,994,5,170,0,0,994,995,7,0,0,0,995,999,5, - 170,0,0,996,997,3,72,36,0,997,998,5,170,0,0,998,1000,1,0,0,0,999,996, - 1,0,0,0,999,1000,1,0,0,0,1000,1001,1,0,0,0,1001,1002,3,336,168,0,1002, - 75,1,0,0,0,1003,1004,5,49,0,0,1004,1005,5,170,0,0,1005,1006,5,134,0,0, - 1006,1007,5,170,0,0,1007,1008,3,336,168,0,1008,1009,5,170,0,0,1009,1010, - 3,78,39,0,1010,77,1,0,0,0,1011,1016,3,80,40,0,1012,1016,3,84,42,0,1013, - 1016,3,86,43,0,1014,1016,3,88,44,0,1015,1011,1,0,0,0,1015,1012,1,0,0, - 0,1015,1013,1,0,0,0,1015,1014,1,0,0,0,1016,79,1,0,0,0,1017,1018,5,47, - 0,0,1018,1019,5,170,0,0,1019,1020,3,330,165,0,1020,1021,5,170,0,0,1021, - 1024,3,100,50,0,1022,1023,5,170,0,0,1023,1025,3,82,41,0,1024,1022,1,0, - 0,0,1024,1025,1,0,0,0,1025,81,1,0,0,0,1026,1027,5,72,0,0,1027,1028,5, - 170,0,0,1028,1029,3,232,116,0,1029,83,1,0,0,0,1030,1031,5,78,0,0,1031, - 1032,5,170,0,0,1032,1033,3,330,165,0,1033,85,1,0,0,0,1034,1035,5,125, - 0,0,1035,1036,5,170,0,0,1036,1037,5,136,0,0,1037,1038,5,170,0,0,1038, - 1039,3,336,168,0,1039,87,1,0,0,0,1040,1041,5,125,0,0,1041,1042,5,170, - 0,0,1042,1043,3,330,165,0,1043,1044,5,170,0,0,1044,1045,5,136,0,0,1045, - 1046,5,170,0,0,1046,1047,3,330,165,0,1047,89,1,0,0,0,1048,1059,3,92,46, - 0,1049,1051,5,170,0,0,1050,1049,1,0,0,0,1050,1051,1,0,0,0,1051,1052,1, - 0,0,0,1052,1054,5,3,0,0,1053,1055,5,170,0,0,1054,1053,1,0,0,0,1054,1055, - 1,0,0,0,1055,1056,1,0,0,0,1056,1058,3,92,46,0,1057,1050,1,0,0,0,1058, - 1061,1,0,0,0,1059,1057,1,0,0,0,1059,1060,1,0,0,0,1060,91,1,0,0,0,1061, - 1059,1,0,0,0,1062,1063,3,330,165,0,1063,1064,5,170,0,0,1064,1065,3,100, - 50,0,1065,93,1,0,0,0,1066,1077,3,96,48,0,1067,1069,5,170,0,0,1068,1067, - 1,0,0,0,1068,1069,1,0,0,0,1069,1070,1,0,0,0,1070,1072,5,3,0,0,1071,1073, - 5,170,0,0,1072,1071,1,0,0,0,1072,1073,1,0,0,0,1073,1074,1,0,0,0,1074, - 1076,3,96,48,0,1075,1068,1,0,0,0,1076,1079,1,0,0,0,1077,1075,1,0,0,0, - 1077,1078,1,0,0,0,1078,95,1,0,0,0,1079,1077,1,0,0,0,1080,1083,3,92,46, - 0,1081,1082,5,170,0,0,1082,1084,3,82,41,0,1083,1081,1,0,0,0,1083,1084, - 1,0,0,0,1084,97,1,0,0,0,1085,1086,5,119,0,0,1086,1087,5,170,0,0,1087, - 1089,5,100,0,0,1088,1090,5,170,0,0,1089,1088,1,0,0,0,1089,1090,1,0,0, - 0,1090,1091,1,0,0,0,1091,1093,5,2,0,0,1092,1094,5,170,0,0,1093,1092,1, - 0,0,0,1093,1094,1,0,0,0,1094,1095,1,0,0,0,1095,1097,3,330,165,0,1096, - 1098,5,170,0,0,1097,1096,1,0,0,0,1097,1098,1,0,0,0,1098,1099,1,0,0,0, - 1099,1100,5,4,0,0,1100,99,1,0,0,0,1101,1102,6,50,-1,0,1102,1176,3,338, - 169,0,1103,1105,5,140,0,0,1104,1106,5,170,0,0,1105,1104,1,0,0,0,1105, - 1106,1,0,0,0,1106,1107,1,0,0,0,1107,1109,5,2,0,0,1108,1110,5,170,0,0, - 1109,1108,1,0,0,0,1109,1110,1,0,0,0,1110,1111,1,0,0,0,1111,1113,3,90, - 45,0,1112,1114,5,170,0,0,1113,1112,1,0,0,0,1113,1114,1,0,0,0,1114,1115, - 1,0,0,0,1115,1116,5,4,0,0,1116,1176,1,0,0,0,1117,1119,3,338,169,0,1118, - 1120,5,170,0,0,1119,1118,1,0,0,0,1119,1120,1,0,0,0,1120,1121,1,0,0,0, - 1121,1123,5,2,0,0,1122,1124,5,170,0,0,1123,1122,1,0,0,0,1123,1124,1,0, - 0,0,1124,1125,1,0,0,0,1125,1127,3,90,45,0,1126,1128,5,170,0,0,1127,1126, - 1,0,0,0,1127,1128,1,0,0,0,1128,1129,1,0,0,0,1129,1130,5,4,0,0,1130,1176, - 1,0,0,0,1131,1133,3,338,169,0,1132,1134,5,170,0,0,1133,1132,1,0,0,0,1133, - 1134,1,0,0,0,1134,1135,1,0,0,0,1135,1137,5,2,0,0,1136,1138,5,170,0,0, - 1137,1136,1,0,0,0,1137,1138,1,0,0,0,1138,1139,1,0,0,0,1139,1141,3,100, - 50,0,1140,1142,5,170,0,0,1141,1140,1,0,0,0,1141,1142,1,0,0,0,1142,1143, - 1,0,0,0,1143,1145,5,3,0,0,1144,1146,5,170,0,0,1145,1144,1,0,0,0,1145, - 1146,1,0,0,0,1146,1147,1,0,0,0,1147,1149,3,100,50,0,1148,1150,5,170,0, - 0,1149,1148,1,0,0,0,1149,1150,1,0,0,0,1150,1151,1,0,0,0,1151,1152,5,4, - 0,0,1152,1176,1,0,0,0,1153,1155,5,149,0,0,1154,1156,5,170,0,0,1155,1154, - 1,0,0,0,1155,1156,1,0,0,0,1156,1157,1,0,0,0,1157,1159,5,2,0,0,1158,1160, - 5,170,0,0,1159,1158,1,0,0,0,1159,1160,1,0,0,0,1160,1161,1,0,0,0,1161, - 1163,3,332,166,0,1162,1164,5,170,0,0,1163,1162,1,0,0,0,1163,1164,1,0, - 0,0,1164,1165,1,0,0,0,1165,1167,5,3,0,0,1166,1168,5,170,0,0,1167,1166, - 1,0,0,0,1167,1168,1,0,0,0,1168,1169,1,0,0,0,1169,1171,3,332,166,0,1170, - 1172,5,170,0,0,1171,1170,1,0,0,0,1171,1172,1,0,0,0,1172,1173,1,0,0,0, - 1173,1174,5,4,0,0,1174,1176,1,0,0,0,1175,1101,1,0,0,0,1175,1103,1,0,0, - 0,1175,1117,1,0,0,0,1175,1131,1,0,0,0,1175,1153,1,0,0,0,1176,1181,1,0, - 0,0,1177,1178,10,5,0,0,1178,1180,3,102,51,0,1179,1177,1,0,0,0,1180,1183, - 1,0,0,0,1181,1179,1,0,0,0,1181,1182,1,0,0,0,1182,101,1,0,0,0,1183,1181, - 1,0,0,0,1184,1188,3,104,52,0,1185,1187,3,104,52,0,1186,1185,1,0,0,0,1187, - 1190,1,0,0,0,1188,1186,1,0,0,0,1188,1189,1,0,0,0,1189,103,1,0,0,0,1190, - 1188,1,0,0,0,1191,1193,5,7,0,0,1192,1194,3,332,166,0,1193,1192,1,0,0, - 0,1193,1194,1,0,0,0,1194,1195,1,0,0,0,1195,1196,5,8,0,0,1196,105,1,0, - 0,0,1197,1200,3,108,54,0,1198,1200,3,110,55,0,1199,1197,1,0,0,0,1199, - 1198,1,0,0,0,1200,107,1,0,0,0,1201,1202,5,83,0,0,1202,109,1,0,0,0,1203, - 1204,5,120,0,0,1204,111,1,0,0,0,1205,1206,5,55,0,0,1206,1207,5,170,0, - 0,1207,1219,5,137,0,0,1208,1209,5,55,0,0,1209,1210,5,170,0,0,1210,1211, - 5,137,0,0,1211,1212,5,170,0,0,1212,1213,5,123,0,0,1213,1214,5,170,0,0, - 1214,1219,5,115,0,0,1215,1219,5,63,0,0,1216,1219,5,127,0,0,1217,1219, - 5,60,0,0,1218,1205,1,0,0,0,1218,1208,1,0,0,0,1218,1215,1,0,0,0,1218,1216, - 1,0,0,0,1218,1217,1,0,0,0,1219,113,1,0,0,0,1220,1223,3,116,58,0,1221, - 1223,3,118,59,0,1222,1220,1,0,0,0,1222,1221,1,0,0,0,1223,115,1,0,0,0, - 1224,1225,5,102,0,0,1225,1226,5,170,0,0,1226,1227,5,85,0,0,1227,1230, - 5,170,0,0,1228,1231,5,156,0,0,1229,1231,3,322,161,0,1230,1228,1,0,0,0, - 1230,1229,1,0,0,0,1231,117,1,0,0,0,1232,1233,5,97,0,0,1233,1234,5,170, - 0,0,1234,1235,3,322,161,0,1235,119,1,0,0,0,1236,1238,3,122,61,0,1237, - 1239,5,170,0,0,1238,1237,1,0,0,0,1238,1239,1,0,0,0,1239,1241,1,0,0,0, - 1240,1236,1,0,0,0,1240,1241,1,0,0,0,1241,1242,1,0,0,0,1242,1243,3,126, - 63,0,1243,121,1,0,0,0,1244,1245,5,121,0,0,1245,1246,5,170,0,0,1246,1247, - 5,89,0,0,1247,1248,5,170,0,0,1248,1250,3,336,168,0,1249,1251,5,170,0, - 0,1250,1249,1,0,0,0,1250,1251,1,0,0,0,1251,1252,1,0,0,0,1252,1254,5,2, - 0,0,1253,1255,5,170,0,0,1254,1253,1,0,0,0,1254,1255,1,0,0,0,1255,1256, - 1,0,0,0,1256,1258,3,124,62,0,1257,1259,5,170,0,0,1258,1257,1,0,0,0,1258, - 1259,1,0,0,0,1259,1260,1,0,0,0,1260,1261,5,4,0,0,1261,123,1,0,0,0,1262, - 1273,3,146,73,0,1263,1265,5,170,0,0,1264,1263,1,0,0,0,1264,1265,1,0,0, - 0,1265,1266,1,0,0,0,1266,1268,5,3,0,0,1267,1269,5,170,0,0,1268,1267,1, - 0,0,0,1268,1269,1,0,0,0,1269,1270,1,0,0,0,1270,1272,3,146,73,0,1271,1264, - 1,0,0,0,1272,1275,1,0,0,0,1273,1271,1,0,0,0,1273,1274,1,0,0,0,1274,125, - 1,0,0,0,1275,1273,1,0,0,0,1276,1283,3,130,65,0,1277,1279,5,170,0,0,1278, - 1277,1,0,0,0,1278,1279,1,0,0,0,1279,1280,1,0,0,0,1280,1282,3,128,64,0, - 1281,1278,1,0,0,0,1282,1285,1,0,0,0,1283,1281,1,0,0,0,1283,1284,1,0,0, - 0,1284,1298,1,0,0,0,1285,1283,1,0,0,0,1286,1288,3,174,87,0,1287,1289, - 5,170,0,0,1288,1287,1,0,0,0,1288,1289,1,0,0,0,1289,1291,1,0,0,0,1290, - 1286,1,0,0,0,1291,1292,1,0,0,0,1292,1290,1,0,0,0,1292,1293,1,0,0,0,1293, - 1294,1,0,0,0,1294,1295,3,130,65,0,1295,1296,6,63,-1,0,1296,1298,1,0,0, - 0,1297,1276,1,0,0,0,1297,1290,1,0,0,0,1298,127,1,0,0,0,1299,1300,5,140, - 0,0,1300,1301,5,170,0,0,1301,1303,5,48,0,0,1302,1304,5,170,0,0,1303,1302, - 1,0,0,0,1303,1304,1,0,0,0,1304,1305,1,0,0,0,1305,1312,3,130,65,0,1306, - 1308,5,140,0,0,1307,1309,5,170,0,0,1308,1307,1,0,0,0,1308,1309,1,0,0, - 0,1309,1310,1,0,0,0,1310,1312,3,130,65,0,1311,1299,1,0,0,0,1311,1306, - 1,0,0,0,1312,129,1,0,0,0,1313,1316,3,132,66,0,1314,1316,3,134,67,0,1315, - 1313,1,0,0,0,1315,1314,1,0,0,0,1316,131,1,0,0,0,1317,1319,3,140,70,0, - 1318,1320,5,170,0,0,1319,1318,1,0,0,0,1319,1320,1,0,0,0,1320,1322,1,0, - 0,0,1321,1317,1,0,0,0,1322,1325,1,0,0,0,1323,1321,1,0,0,0,1323,1324,1, - 0,0,0,1324,1326,1,0,0,0,1325,1323,1,0,0,0,1326,1363,3,174,87,0,1327,1329, - 3,140,70,0,1328,1330,5,170,0,0,1329,1328,1,0,0,0,1329,1330,1,0,0,0,1330, - 1332,1,0,0,0,1331,1327,1,0,0,0,1332,1335,1,0,0,0,1333,1331,1,0,0,0,1333, - 1334,1,0,0,0,1334,1336,1,0,0,0,1335,1333,1,0,0,0,1336,1343,3,138,69,0, - 1337,1339,5,170,0,0,1338,1337,1,0,0,0,1338,1339,1,0,0,0,1339,1340,1,0, - 0,0,1340,1342,3,138,69,0,1341,1338,1,0,0,0,1342,1345,1,0,0,0,1343,1341, - 1,0,0,0,1343,1344,1,0,0,0,1344,1350,1,0,0,0,1345,1343,1,0,0,0,1346,1348, - 5,170,0,0,1347,1346,1,0,0,0,1347,1348,1,0,0,0,1348,1349,1,0,0,0,1349, - 1351,3,174,87,0,1350,1347,1,0,0,0,1350,1351,1,0,0,0,1351,1363,1,0,0,0, - 1352,1354,3,140,70,0,1353,1355,5,170,0,0,1354,1353,1,0,0,0,1354,1355, - 1,0,0,0,1355,1357,1,0,0,0,1356,1352,1,0,0,0,1357,1358,1,0,0,0,1358,1356, - 1,0,0,0,1358,1359,1,0,0,0,1359,1360,1,0,0,0,1360,1361,6,66,-1,0,1361, - 1363,1,0,0,0,1362,1323,1,0,0,0,1362,1333,1,0,0,0,1362,1356,1,0,0,0,1363, - 133,1,0,0,0,1364,1366,3,136,68,0,1365,1367,5,170,0,0,1366,1365,1,0,0, - 0,1366,1367,1,0,0,0,1367,1369,1,0,0,0,1368,1364,1,0,0,0,1369,1370,1,0, - 0,0,1370,1368,1,0,0,0,1370,1371,1,0,0,0,1371,1372,1,0,0,0,1372,1373,3, - 132,66,0,1373,135,1,0,0,0,1374,1376,3,140,70,0,1375,1377,5,170,0,0,1376, - 1375,1,0,0,0,1376,1377,1,0,0,0,1377,1379,1,0,0,0,1378,1374,1,0,0,0,1379, - 1382,1,0,0,0,1380,1378,1,0,0,0,1380,1381,1,0,0,0,1381,1389,1,0,0,0,1382, - 1380,1,0,0,0,1383,1385,3,138,69,0,1384,1386,5,170,0,0,1385,1384,1,0,0, - 0,1385,1386,1,0,0,0,1386,1388,1,0,0,0,1387,1383,1,0,0,0,1388,1391,1,0, - 0,0,1389,1387,1,0,0,0,1389,1390,1,0,0,0,1390,1392,1,0,0,0,1391,1389,1, - 0,0,0,1392,1393,3,172,86,0,1393,137,1,0,0,0,1394,1399,3,160,80,0,1395, - 1399,3,162,81,0,1396,1399,3,166,83,0,1397,1399,3,170,85,0,1398,1394,1, - 0,0,0,1398,1395,1,0,0,0,1398,1396,1,0,0,0,1398,1397,1,0,0,0,1399,139, - 1,0,0,0,1400,1405,3,152,76,0,1401,1405,3,158,79,0,1402,1405,3,144,72, - 0,1403,1405,3,142,71,0,1404,1400,1,0,0,0,1404,1401,1,0,0,0,1404,1402, - 1,0,0,0,1404,1403,1,0,0,0,1405,141,1,0,0,0,1406,1424,5,102,0,0,1407,1408, - 5,170,0,0,1408,1409,5,145,0,0,1409,1410,5,170,0,0,1410,1412,5,91,0,0, - 1411,1413,5,170,0,0,1412,1411,1,0,0,0,1412,1413,1,0,0,0,1413,1414,1,0, - 0,0,1414,1416,5,2,0,0,1415,1417,5,170,0,0,1416,1415,1,0,0,0,1416,1417, - 1,0,0,0,1417,1418,1,0,0,0,1418,1420,3,90,45,0,1419,1421,5,170,0,0,1420, - 1419,1,0,0,0,1420,1421,1,0,0,0,1421,1422,1,0,0,0,1422,1423,5,4,0,0,1423, - 1425,1,0,0,0,1424,1407,1,0,0,0,1424,1425,1,0,0,0,1425,1426,1,0,0,0,1426, - 1427,5,170,0,0,1427,1428,5,87,0,0,1428,1429,5,170,0,0,1429,1434,3,10, - 5,0,1430,1432,5,170,0,0,1431,1430,1,0,0,0,1431,1432,1,0,0,0,1432,1433, - 1,0,0,0,1433,1435,3,42,21,0,1434,1431,1,0,0,0,1434,1435,1,0,0,0,1435, - 1440,1,0,0,0,1436,1438,5,170,0,0,1437,1436,1,0,0,0,1437,1438,1,0,0,0, - 1438,1439,1,0,0,0,1439,1441,3,190,95,0,1440,1437,1,0,0,0,1440,1441,1, - 0,0,0,1441,143,1,0,0,0,1442,1444,3,122,61,0,1443,1445,5,170,0,0,1444, - 1443,1,0,0,0,1444,1445,1,0,0,0,1445,1447,1,0,0,0,1446,1442,1,0,0,0,1446, - 1447,1,0,0,0,1447,1448,1,0,0,0,1448,1449,5,57,0,0,1449,1450,5,170,0,0, - 1450,1455,3,300,150,0,1451,1453,5,170,0,0,1452,1451,1,0,0,0,1452,1453, - 1,0,0,0,1453,1454,1,0,0,0,1454,1456,3,190,95,0,1455,1452,1,0,0,0,1455, - 1456,1,0,0,0,1456,145,1,0,0,0,1457,1471,3,336,168,0,1458,1460,5,170,0, - 0,1459,1458,1,0,0,0,1459,1460,1,0,0,0,1460,1461,1,0,0,0,1461,1463,5,9, - 0,0,1462,1464,5,170,0,0,1463,1462,1,0,0,0,1463,1464,1,0,0,0,1464,1465, - 1,0,0,0,1465,1467,3,148,74,0,1466,1468,5,170,0,0,1467,1466,1,0,0,0,1467, - 1468,1,0,0,0,1468,1469,1,0,0,0,1469,1470,5,10,0,0,1470,1472,1,0,0,0,1471, - 1459,1,0,0,0,1471,1472,1,0,0,0,1472,147,1,0,0,0,1473,1484,3,150,75,0, - 1474,1476,5,170,0,0,1475,1474,1,0,0,0,1475,1476,1,0,0,0,1476,1477,1,0, - 0,0,1477,1479,5,3,0,0,1478,1480,5,170,0,0,1479,1478,1,0,0,0,1479,1480, - 1,0,0,0,1480,1481,1,0,0,0,1481,1483,3,150,75,0,1482,1475,1,0,0,0,1483, - 1486,1,0,0,0,1484,1482,1,0,0,0,1484,1485,1,0,0,0,1485,149,1,0,0,0,1486, - 1484,1,0,0,0,1487,1490,3,330,165,0,1488,1489,5,170,0,0,1489,1491,3,82, - 41,0,1490,1488,1,0,0,0,1490,1491,1,0,0,0,1491,1494,1,0,0,0,1492,1493, - 5,170,0,0,1493,1495,3,190,95,0,1494,1492,1,0,0,0,1494,1495,1,0,0,0,1495, - 151,1,0,0,0,1496,1497,5,116,0,0,1497,1499,5,170,0,0,1498,1496,1,0,0,0, - 1498,1499,1,0,0,0,1499,1500,1,0,0,0,1500,1502,5,104,0,0,1501,1503,5,170, - 0,0,1502,1501,1,0,0,0,1502,1503,1,0,0,0,1503,1504,1,0,0,0,1504,1507,3, - 192,96,0,1505,1506,5,170,0,0,1506,1508,3,190,95,0,1507,1505,1,0,0,0,1507, - 1508,1,0,0,0,1508,1511,1,0,0,0,1509,1510,5,170,0,0,1510,1512,3,154,77, - 0,1511,1509,1,0,0,0,1511,1512,1,0,0,0,1512,153,1,0,0,0,1513,1514,5,92, - 0,0,1514,1515,5,170,0,0,1515,1516,3,156,78,0,1516,155,1,0,0,0,1517,1518, - 6,78,-1,0,1518,1520,5,2,0,0,1519,1521,5,170,0,0,1520,1519,1,0,0,0,1520, - 1521,1,0,0,0,1521,1522,1,0,0,0,1522,1524,3,156,78,0,1523,1525,5,170,0, - 0,1524,1523,1,0,0,0,1524,1525,1,0,0,0,1525,1526,1,0,0,0,1526,1527,5,4, - 0,0,1527,1530,1,0,0,0,1528,1530,3,336,168,0,1529,1517,1,0,0,0,1529,1528, - 1,0,0,0,1530,1547,1,0,0,0,1531,1532,10,4,0,0,1532,1533,5,170,0,0,1533, - 1534,5,99,0,0,1534,1535,5,170,0,0,1535,1546,3,156,78,5,1536,1541,10,3, - 0,0,1537,1538,5,170,0,0,1538,1539,5,108,0,0,1539,1540,5,170,0,0,1540, - 1542,3,336,168,0,1541,1537,1,0,0,0,1542,1543,1,0,0,0,1543,1541,1,0,0, - 0,1543,1544,1,0,0,0,1544,1546,1,0,0,0,1545,1531,1,0,0,0,1545,1536,1,0, - 0,0,1546,1549,1,0,0,0,1547,1545,1,0,0,0,1547,1548,1,0,0,0,1548,157,1, - 0,0,0,1549,1547,1,0,0,0,1550,1552,5,141,0,0,1551,1553,5,170,0,0,1552, - 1551,1,0,0,0,1552,1553,1,0,0,0,1553,1554,1,0,0,0,1554,1555,3,232,116, - 0,1555,1556,5,170,0,0,1556,1557,5,51,0,0,1557,1558,5,170,0,0,1558,1559, - 3,322,161,0,1559,159,1,0,0,0,1560,1562,5,68,0,0,1561,1563,5,170,0,0,1562, - 1561,1,0,0,0,1562,1563,1,0,0,0,1563,1564,1,0,0,0,1564,1565,3,192,96,0, - 1565,161,1,0,0,0,1566,1568,5,106,0,0,1567,1569,5,170,0,0,1568,1567,1, - 0,0,0,1568,1569,1,0,0,0,1569,1570,1,0,0,0,1570,1575,3,192,96,0,1571,1572, - 5,170,0,0,1572,1574,3,164,82,0,1573,1571,1,0,0,0,1574,1577,1,0,0,0,1575, - 1573,1,0,0,0,1575,1576,1,0,0,0,1576,163,1,0,0,0,1577,1575,1,0,0,0,1578, - 1579,5,114,0,0,1579,1580,5,170,0,0,1580,1581,5,104,0,0,1581,1582,5,170, - 0,0,1582,1589,3,166,83,0,1583,1584,5,114,0,0,1584,1585,5,170,0,0,1585, - 1586,5,68,0,0,1586,1587,5,170,0,0,1587,1589,3,166,83,0,1588,1578,1,0, - 0,0,1588,1583,1,0,0,0,1589,165,1,0,0,0,1590,1592,5,130,0,0,1591,1593, - 5,170,0,0,1592,1591,1,0,0,0,1592,1593,1,0,0,0,1593,1594,1,0,0,0,1594, - 1605,3,168,84,0,1595,1597,5,170,0,0,1596,1595,1,0,0,0,1596,1597,1,0,0, - 0,1597,1598,1,0,0,0,1598,1600,5,3,0,0,1599,1601,5,170,0,0,1600,1599,1, - 0,0,0,1600,1601,1,0,0,0,1601,1602,1,0,0,0,1602,1604,3,168,84,0,1603,1596, - 1,0,0,0,1604,1607,1,0,0,0,1605,1603,1,0,0,0,1605,1606,1,0,0,0,1606,167, - 1,0,0,0,1607,1605,1,0,0,0,1608,1610,3,328,164,0,1609,1611,5,170,0,0,1610, - 1609,1,0,0,0,1610,1611,1,0,0,0,1611,1612,1,0,0,0,1612,1614,5,6,0,0,1613, - 1615,5,170,0,0,1614,1613,1,0,0,0,1614,1615,1,0,0,0,1615,1616,1,0,0,0, - 1616,1617,3,232,116,0,1617,169,1,0,0,0,1618,1619,5,76,0,0,1619,1621,5, - 170,0,0,1620,1618,1,0,0,0,1620,1621,1,0,0,0,1621,1622,1,0,0,0,1622,1624, - 5,73,0,0,1623,1625,5,170,0,0,1624,1623,1,0,0,0,1624,1625,1,0,0,0,1625, - 1626,1,0,0,0,1626,1637,3,232,116,0,1627,1629,5,170,0,0,1628,1627,1,0, - 0,0,1628,1629,1,0,0,0,1629,1630,1,0,0,0,1630,1632,5,3,0,0,1631,1633,5, - 170,0,0,1632,1631,1,0,0,0,1632,1633,1,0,0,0,1633,1634,1,0,0,0,1634,1636, - 3,232,116,0,1635,1628,1,0,0,0,1636,1639,1,0,0,0,1637,1635,1,0,0,0,1637, - 1638,1,0,0,0,1638,171,1,0,0,0,1639,1637,1,0,0,0,1640,1641,5,145,0,0,1641, - 1646,3,176,88,0,1642,1644,5,170,0,0,1643,1642,1,0,0,0,1643,1644,1,0,0, - 0,1644,1645,1,0,0,0,1645,1647,3,190,95,0,1646,1643,1,0,0,0,1646,1647, - 1,0,0,0,1647,173,1,0,0,0,1648,1649,5,126,0,0,1649,1650,3,176,88,0,1650, - 175,1,0,0,0,1651,1653,5,170,0,0,1652,1651,1,0,0,0,1652,1653,1,0,0,0,1653, - 1654,1,0,0,0,1654,1656,5,77,0,0,1655,1652,1,0,0,0,1655,1656,1,0,0,0,1656, - 1657,1,0,0,0,1657,1658,5,170,0,0,1658,1661,3,178,89,0,1659,1660,5,170, - 0,0,1660,1662,3,182,91,0,1661,1659,1,0,0,0,1661,1662,1,0,0,0,1662,1665, - 1,0,0,0,1663,1664,5,170,0,0,1664,1666,3,184,92,0,1665,1663,1,0,0,0,1665, - 1666,1,0,0,0,1666,1669,1,0,0,0,1667,1668,5,170,0,0,1668,1670,3,186,93, - 0,1669,1667,1,0,0,0,1669,1670,1,0,0,0,1670,177,1,0,0,0,1671,1682,5,150, - 0,0,1672,1674,5,170,0,0,1673,1672,1,0,0,0,1673,1674,1,0,0,0,1674,1675, - 1,0,0,0,1675,1677,5,3,0,0,1676,1678,5,170,0,0,1677,1676,1,0,0,0,1677, - 1678,1,0,0,0,1678,1679,1,0,0,0,1679,1681,3,180,90,0,1680,1673,1,0,0,0, - 1681,1684,1,0,0,0,1682,1680,1,0,0,0,1682,1683,1,0,0,0,1683,1700,1,0,0, - 0,1684,1682,1,0,0,0,1685,1696,3,180,90,0,1686,1688,5,170,0,0,1687,1686, - 1,0,0,0,1687,1688,1,0,0,0,1688,1689,1,0,0,0,1689,1691,5,3,0,0,1690,1692, - 5,170,0,0,1691,1690,1,0,0,0,1691,1692,1,0,0,0,1692,1693,1,0,0,0,1693, - 1695,3,180,90,0,1694,1687,1,0,0,0,1695,1698,1,0,0,0,1696,1694,1,0,0,0, - 1696,1697,1,0,0,0,1697,1700,1,0,0,0,1698,1696,1,0,0,0,1699,1671,1,0,0, - 0,1699,1685,1,0,0,0,1700,179,1,0,0,0,1701,1702,3,232,116,0,1702,1703, - 5,170,0,0,1703,1704,5,51,0,0,1704,1705,5,170,0,0,1705,1706,3,322,161, - 0,1706,1709,1,0,0,0,1707,1709,3,232,116,0,1708,1701,1,0,0,0,1708,1707, - 1,0,0,0,1709,181,1,0,0,0,1710,1711,5,118,0,0,1711,1712,5,170,0,0,1712, - 1713,5,56,0,0,1713,1714,5,170,0,0,1714,1722,3,188,94,0,1715,1717,5,3, - 0,0,1716,1718,5,170,0,0,1717,1716,1,0,0,0,1717,1718,1,0,0,0,1718,1719, - 1,0,0,0,1719,1721,3,188,94,0,1720,1715,1,0,0,0,1721,1724,1,0,0,0,1722, - 1720,1,0,0,0,1722,1723,1,0,0,0,1723,183,1,0,0,0,1724,1722,1,0,0,0,1725, - 1726,5,151,0,0,1726,1727,5,170,0,0,1727,1728,3,232,116,0,1728,185,1,0, - 0,0,1729,1730,5,101,0,0,1730,1731,5,170,0,0,1731,1732,3,232,116,0,1732, - 187,1,0,0,0,1733,1738,3,232,116,0,1734,1736,5,170,0,0,1735,1734,1,0,0, - 0,1735,1736,1,0,0,0,1736,1737,1,0,0,0,1737,1739,7,1,0,0,1738,1735,1,0, - 0,0,1738,1739,1,0,0,0,1739,189,1,0,0,0,1740,1741,5,144,0,0,1741,1742, - 5,170,0,0,1742,1743,3,232,116,0,1743,191,1,0,0,0,1744,1755,3,194,97,0, - 1745,1747,5,170,0,0,1746,1745,1,0,0,0,1746,1747,1,0,0,0,1747,1748,1,0, - 0,0,1748,1750,5,3,0,0,1749,1751,5,170,0,0,1750,1749,1,0,0,0,1750,1751, - 1,0,0,0,1751,1752,1,0,0,0,1752,1754,3,194,97,0,1753,1746,1,0,0,0,1754, - 1757,1,0,0,0,1755,1753,1,0,0,0,1755,1756,1,0,0,0,1756,193,1,0,0,0,1757, - 1755,1,0,0,0,1758,1760,3,322,161,0,1759,1761,5,170,0,0,1760,1759,1,0, - 0,0,1760,1761,1,0,0,0,1761,1762,1,0,0,0,1762,1764,5,6,0,0,1763,1765,5, - 170,0,0,1764,1763,1,0,0,0,1764,1765,1,0,0,0,1765,1766,1,0,0,0,1766,1767, - 3,196,98,0,1767,1770,1,0,0,0,1768,1770,3,196,98,0,1769,1758,1,0,0,0,1769, - 1768,1,0,0,0,1770,195,1,0,0,0,1771,1772,3,198,99,0,1772,197,1,0,0,0,1773, - 1780,3,200,100,0,1774,1776,5,170,0,0,1775,1774,1,0,0,0,1775,1776,1,0, - 0,0,1776,1777,1,0,0,0,1777,1779,3,202,101,0,1778,1775,1,0,0,0,1779,1782, - 1,0,0,0,1780,1778,1,0,0,0,1780,1781,1,0,0,0,1781,1788,1,0,0,0,1782,1780, - 1,0,0,0,1783,1784,5,2,0,0,1784,1785,3,198,99,0,1785,1786,5,4,0,0,1786, - 1788,1,0,0,0,1787,1773,1,0,0,0,1787,1783,1,0,0,0,1788,199,1,0,0,0,1789, - 1791,5,2,0,0,1790,1792,5,170,0,0,1791,1790,1,0,0,0,1791,1792,1,0,0,0, - 1792,1797,1,0,0,0,1793,1795,3,322,161,0,1794,1796,5,170,0,0,1795,1794, - 1,0,0,0,1795,1796,1,0,0,0,1796,1798,1,0,0,0,1797,1793,1,0,0,0,1797,1798, - 1,0,0,0,1798,1803,1,0,0,0,1799,1801,3,212,106,0,1800,1802,5,170,0,0,1801, - 1800,1,0,0,0,1801,1802,1,0,0,0,1802,1804,1,0,0,0,1803,1799,1,0,0,0,1803, - 1804,1,0,0,0,1804,1809,1,0,0,0,1805,1807,3,208,104,0,1806,1808,5,170, - 0,0,1807,1806,1,0,0,0,1807,1808,1,0,0,0,1808,1810,1,0,0,0,1809,1805,1, - 0,0,0,1809,1810,1,0,0,0,1810,1811,1,0,0,0,1811,1812,5,4,0,0,1812,201, - 1,0,0,0,1813,1815,3,204,102,0,1814,1816,5,170,0,0,1815,1814,1,0,0,0,1815, - 1816,1,0,0,0,1816,1817,1,0,0,0,1817,1818,3,200,100,0,1818,203,1,0,0,0, - 1819,1821,3,342,171,0,1820,1822,5,170,0,0,1821,1820,1,0,0,0,1821,1822, - 1,0,0,0,1822,1823,1,0,0,0,1823,1825,3,346,173,0,1824,1826,5,170,0,0,1825, - 1824,1,0,0,0,1825,1826,1,0,0,0,1826,1828,1,0,0,0,1827,1829,3,206,103, - 0,1828,1827,1,0,0,0,1828,1829,1,0,0,0,1829,1831,1,0,0,0,1830,1832,5,170, - 0,0,1831,1830,1,0,0,0,1831,1832,1,0,0,0,1832,1833,1,0,0,0,1833,1834,3, - 346,173,0,1834,1864,1,0,0,0,1835,1837,3,346,173,0,1836,1838,5,170,0,0, - 1837,1836,1,0,0,0,1837,1838,1,0,0,0,1838,1840,1,0,0,0,1839,1841,3,206, - 103,0,1840,1839,1,0,0,0,1840,1841,1,0,0,0,1841,1843,1,0,0,0,1842,1844, - 5,170,0,0,1843,1842,1,0,0,0,1843,1844,1,0,0,0,1844,1845,1,0,0,0,1845, - 1847,3,346,173,0,1846,1848,5,170,0,0,1847,1846,1,0,0,0,1847,1848,1,0, - 0,0,1848,1849,1,0,0,0,1849,1850,3,344,172,0,1850,1864,1,0,0,0,1851,1853, - 3,346,173,0,1852,1854,5,170,0,0,1853,1852,1,0,0,0,1853,1854,1,0,0,0,1854, - 1856,1,0,0,0,1855,1857,3,206,103,0,1856,1855,1,0,0,0,1856,1857,1,0,0, - 0,1857,1859,1,0,0,0,1858,1860,5,170,0,0,1859,1858,1,0,0,0,1859,1860,1, - 0,0,0,1860,1861,1,0,0,0,1861,1862,3,346,173,0,1862,1864,1,0,0,0,1863, - 1819,1,0,0,0,1863,1835,1,0,0,0,1863,1851,1,0,0,0,1864,205,1,0,0,0,1865, - 1867,5,7,0,0,1866,1868,5,170,0,0,1867,1866,1,0,0,0,1867,1868,1,0,0,0, - 1868,1873,1,0,0,0,1869,1871,3,322,161,0,1870,1872,5,170,0,0,1871,1870, - 1,0,0,0,1871,1872,1,0,0,0,1872,1874,1,0,0,0,1873,1869,1,0,0,0,1873,1874, - 1,0,0,0,1874,1879,1,0,0,0,1875,1877,3,210,105,0,1876,1878,5,170,0,0,1877, - 1876,1,0,0,0,1877,1878,1,0,0,0,1878,1880,1,0,0,0,1879,1875,1,0,0,0,1879, - 1880,1,0,0,0,1880,1885,1,0,0,0,1881,1883,3,216,108,0,1882,1884,5,170, - 0,0,1883,1882,1,0,0,0,1883,1884,1,0,0,0,1884,1886,1,0,0,0,1885,1881,1, - 0,0,0,1885,1886,1,0,0,0,1886,1891,1,0,0,0,1887,1889,3,208,104,0,1888, - 1890,5,170,0,0,1889,1888,1,0,0,0,1889,1890,1,0,0,0,1890,1892,1,0,0,0, - 1891,1887,1,0,0,0,1891,1892,1,0,0,0,1892,1893,1,0,0,0,1893,1894,5,8,0, - 0,1894,207,1,0,0,0,1895,1897,5,9,0,0,1896,1898,5,170,0,0,1897,1896,1, - 0,0,0,1897,1898,1,0,0,0,1898,1932,1,0,0,0,1899,1901,3,330,165,0,1900, - 1902,5,170,0,0,1901,1900,1,0,0,0,1901,1902,1,0,0,0,1902,1903,1,0,0,0, - 1903,1905,5,155,0,0,1904,1906,5,170,0,0,1905,1904,1,0,0,0,1905,1906,1, - 0,0,0,1906,1907,1,0,0,0,1907,1909,3,232,116,0,1908,1910,5,170,0,0,1909, - 1908,1,0,0,0,1909,1910,1,0,0,0,1910,1929,1,0,0,0,1911,1913,5,3,0,0,1912, - 1914,5,170,0,0,1913,1912,1,0,0,0,1913,1914,1,0,0,0,1914,1915,1,0,0,0, - 1915,1917,3,330,165,0,1916,1918,5,170,0,0,1917,1916,1,0,0,0,1917,1918, - 1,0,0,0,1918,1919,1,0,0,0,1919,1921,5,155,0,0,1920,1922,5,170,0,0,1921, - 1920,1,0,0,0,1921,1922,1,0,0,0,1922,1923,1,0,0,0,1923,1925,3,232,116, - 0,1924,1926,5,170,0,0,1925,1924,1,0,0,0,1925,1926,1,0,0,0,1926,1928,1, - 0,0,0,1927,1911,1,0,0,0,1928,1931,1,0,0,0,1929,1927,1,0,0,0,1929,1930, - 1,0,0,0,1930,1933,1,0,0,0,1931,1929,1,0,0,0,1932,1899,1,0,0,0,1932,1933, - 1,0,0,0,1933,1934,1,0,0,0,1934,1935,5,10,0,0,1935,209,1,0,0,0,1936,1938, - 5,155,0,0,1937,1939,5,170,0,0,1938,1937,1,0,0,0,1938,1939,1,0,0,0,1939, - 1940,1,0,0,0,1940,1954,3,230,115,0,1941,1943,5,170,0,0,1942,1941,1,0, - 0,0,1942,1943,1,0,0,0,1943,1944,1,0,0,0,1944,1946,5,11,0,0,1945,1947, - 5,155,0,0,1946,1945,1,0,0,0,1946,1947,1,0,0,0,1947,1949,1,0,0,0,1948, - 1950,5,170,0,0,1949,1948,1,0,0,0,1949,1950,1,0,0,0,1950,1951,1,0,0,0, - 1951,1953,3,230,115,0,1952,1942,1,0,0,0,1953,1956,1,0,0,0,1954,1952,1, - 0,0,0,1954,1955,1,0,0,0,1955,211,1,0,0,0,1956,1954,1,0,0,0,1957,1964, - 3,214,107,0,1958,1960,5,170,0,0,1959,1958,1,0,0,0,1959,1960,1,0,0,0,1960, - 1961,1,0,0,0,1961,1963,3,214,107,0,1962,1959,1,0,0,0,1963,1966,1,0,0, - 0,1964,1962,1,0,0,0,1964,1965,1,0,0,0,1965,213,1,0,0,0,1966,1964,1,0, - 0,0,1967,1969,5,155,0,0,1968,1970,5,170,0,0,1969,1968,1,0,0,0,1969,1970, - 1,0,0,0,1970,1971,1,0,0,0,1971,1972,3,228,114,0,1972,215,1,0,0,0,1973, - 1975,5,150,0,0,1974,1976,5,170,0,0,1975,1974,1,0,0,0,1975,1976,1,0,0, - 0,1976,1981,1,0,0,0,1977,1982,5,131,0,0,1978,1979,5,48,0,0,1979,1980, - 5,170,0,0,1980,1982,5,131,0,0,1981,1977,1,0,0,0,1981,1978,1,0,0,0,1981, - 1982,1,0,0,0,1982,1984,1,0,0,0,1983,1985,5,170,0,0,1984,1983,1,0,0,0, - 1984,1985,1,0,0,0,1985,2000,1,0,0,0,1986,1988,3,224,112,0,1987,1986,1, - 0,0,0,1987,1988,1,0,0,0,1988,1990,1,0,0,0,1989,1991,5,170,0,0,1990,1989, - 1,0,0,0,1990,1991,1,0,0,0,1991,1992,1,0,0,0,1992,1994,5,12,0,0,1993,1995, - 5,170,0,0,1994,1993,1,0,0,0,1994,1995,1,0,0,0,1995,1997,1,0,0,0,1996, - 1998,3,226,113,0,1997,1996,1,0,0,0,1997,1998,1,0,0,0,1998,2001,1,0,0, - 0,1999,2001,3,332,166,0,2000,1987,1,0,0,0,2000,1999,1,0,0,0,2000,2001, - 1,0,0,0,2001,2006,1,0,0,0,2002,2004,5,170,0,0,2003,2002,1,0,0,0,2003, - 2004,1,0,0,0,2004,2005,1,0,0,0,2005,2007,3,218,109,0,2006,2003,1,0,0, - 0,2006,2007,1,0,0,0,2007,217,1,0,0,0,2008,2010,5,2,0,0,2009,2011,5,170, - 0,0,2010,2009,1,0,0,0,2010,2011,1,0,0,0,2011,2012,1,0,0,0,2012,2014,3, - 322,161,0,2013,2015,5,170,0,0,2014,2013,1,0,0,0,2014,2015,1,0,0,0,2015, - 2016,1,0,0,0,2016,2018,5,3,0,0,2017,2019,5,170,0,0,2018,2017,1,0,0,0, - 2018,2019,1,0,0,0,2019,2020,1,0,0,0,2020,2032,3,322,161,0,2021,2023,5, - 170,0,0,2022,2021,1,0,0,0,2022,2023,1,0,0,0,2023,2024,1,0,0,0,2024,2026, - 5,11,0,0,2025,2027,5,170,0,0,2026,2025,1,0,0,0,2026,2027,1,0,0,0,2027, - 2028,1,0,0,0,2028,2030,3,190,95,0,2029,2031,5,170,0,0,2030,2029,1,0,0, - 0,2030,2031,1,0,0,0,2031,2033,1,0,0,0,2032,2022,1,0,0,0,2032,2033,1,0, - 0,0,2033,2053,1,0,0,0,2034,2036,5,170,0,0,2035,2034,1,0,0,0,2035,2036, - 1,0,0,0,2036,2037,1,0,0,0,2037,2039,5,11,0,0,2038,2040,5,170,0,0,2039, - 2038,1,0,0,0,2039,2040,1,0,0,0,2040,2041,1,0,0,0,2041,2043,3,222,111, - 0,2042,2044,5,170,0,0,2043,2042,1,0,0,0,2043,2044,1,0,0,0,2044,2045,1, - 0,0,0,2045,2047,5,3,0,0,2046,2048,5,170,0,0,2047,2046,1,0,0,0,2047,2048, - 1,0,0,0,2048,2049,1,0,0,0,2049,2051,3,220,110,0,2050,2052,5,170,0,0,2051, - 2050,1,0,0,0,2051,2052,1,0,0,0,2052,2054,1,0,0,0,2053,2035,1,0,0,0,2053, - 2054,1,0,0,0,2054,2055,1,0,0,0,2055,2056,5,4,0,0,2056,219,1,0,0,0,2057, - 2059,5,9,0,0,2058,2060,5,170,0,0,2059,2058,1,0,0,0,2059,2060,1,0,0,0, - 2060,2062,1,0,0,0,2061,2063,3,178,89,0,2062,2061,1,0,0,0,2062,2063,1, - 0,0,0,2063,2065,1,0,0,0,2064,2066,5,170,0,0,2065,2064,1,0,0,0,2065,2066, - 1,0,0,0,2066,2067,1,0,0,0,2067,2068,5,10,0,0,2068,221,1,0,0,0,2069,2071, - 5,9,0,0,2070,2072,5,170,0,0,2071,2070,1,0,0,0,2071,2072,1,0,0,0,2072, - 2074,1,0,0,0,2073,2075,3,178,89,0,2074,2073,1,0,0,0,2074,2075,1,0,0,0, - 2075,2077,1,0,0,0,2076,2078,5,170,0,0,2077,2076,1,0,0,0,2077,2078,1,0, - 0,0,2078,2079,1,0,0,0,2079,2080,5,10,0,0,2080,223,1,0,0,0,2081,2082,5, - 158,0,0,2082,225,1,0,0,0,2083,2084,5,158,0,0,2084,227,1,0,0,0,2085,2086, - 3,336,168,0,2086,229,1,0,0,0,2087,2088,3,336,168,0,2088,231,1,0,0,0,2089, - 2090,3,234,117,0,2090,233,1,0,0,0,2091,2098,3,236,118,0,2092,2093,5,170, - 0,0,2093,2094,5,117,0,0,2094,2095,5,170,0,0,2095,2097,3,236,118,0,2096, - 2092,1,0,0,0,2097,2100,1,0,0,0,2098,2096,1,0,0,0,2098,2099,1,0,0,0,2099, - 235,1,0,0,0,2100,2098,1,0,0,0,2101,2108,3,238,119,0,2102,2103,5,170,0, - 0,2103,2104,5,147,0,0,2104,2105,5,170,0,0,2105,2107,3,238,119,0,2106, - 2102,1,0,0,0,2107,2110,1,0,0,0,2108,2106,1,0,0,0,2108,2109,1,0,0,0,2109, - 237,1,0,0,0,2110,2108,1,0,0,0,2111,2118,3,240,120,0,2112,2113,5,170,0, - 0,2113,2114,5,50,0,0,2114,2115,5,170,0,0,2115,2117,3,240,120,0,2116,2112, - 1,0,0,0,2117,2120,1,0,0,0,2118,2116,1,0,0,0,2118,2119,1,0,0,0,2119,239, - 1,0,0,0,2120,2118,1,0,0,0,2121,2123,5,111,0,0,2122,2124,5,170,0,0,2123, - 2122,1,0,0,0,2123,2124,1,0,0,0,2124,2126,1,0,0,0,2125,2121,1,0,0,0,2126, - 2129,1,0,0,0,2127,2125,1,0,0,0,2127,2128,1,0,0,0,2128,2130,1,0,0,0,2129, - 2127,1,0,0,0,2130,2131,3,242,121,0,2131,241,1,0,0,0,2132,2142,3,246,123, - 0,2133,2135,5,170,0,0,2134,2133,1,0,0,0,2134,2135,1,0,0,0,2135,2136,1, - 0,0,0,2136,2138,3,244,122,0,2137,2139,5,170,0,0,2138,2137,1,0,0,0,2138, - 2139,1,0,0,0,2139,2140,1,0,0,0,2140,2141,3,246,123,0,2141,2143,1,0,0, - 0,2142,2134,1,0,0,0,2142,2143,1,0,0,0,2143,2181,1,0,0,0,2144,2146,3,246, - 123,0,2145,2147,5,170,0,0,2146,2145,1,0,0,0,2146,2147,1,0,0,0,2147,2148, - 1,0,0,0,2148,2150,5,152,0,0,2149,2151,5,170,0,0,2150,2149,1,0,0,0,2150, - 2151,1,0,0,0,2151,2152,1,0,0,0,2152,2153,3,246,123,0,2153,2154,1,0,0, - 0,2154,2155,6,121,-1,0,2155,2181,1,0,0,0,2156,2158,3,246,123,0,2157,2159, - 5,170,0,0,2158,2157,1,0,0,0,2158,2159,1,0,0,0,2159,2160,1,0,0,0,2160, - 2162,3,244,122,0,2161,2163,5,170,0,0,2162,2161,1,0,0,0,2162,2163,1,0, - 0,0,2163,2164,1,0,0,0,2164,2174,3,246,123,0,2165,2167,5,170,0,0,2166, - 2165,1,0,0,0,2166,2167,1,0,0,0,2167,2168,1,0,0,0,2168,2170,3,244,122, - 0,2169,2171,5,170,0,0,2170,2169,1,0,0,0,2170,2171,1,0,0,0,2171,2172,1, - 0,0,0,2172,2173,3,246,123,0,2173,2175,1,0,0,0,2174,2166,1,0,0,0,2175, - 2176,1,0,0,0,2176,2174,1,0,0,0,2176,2177,1,0,0,0,2177,2178,1,0,0,0,2178, - 2179,6,121,-1,0,2179,2181,1,0,0,0,2180,2132,1,0,0,0,2180,2144,1,0,0,0, - 2180,2156,1,0,0,0,2181,243,1,0,0,0,2182,2183,7,2,0,0,2183,245,1,0,0,0, - 2184,2195,3,248,124,0,2185,2187,5,170,0,0,2186,2185,1,0,0,0,2186,2187, - 1,0,0,0,2187,2188,1,0,0,0,2188,2190,5,11,0,0,2189,2191,5,170,0,0,2190, - 2189,1,0,0,0,2190,2191,1,0,0,0,2191,2192,1,0,0,0,2192,2194,3,248,124, - 0,2193,2186,1,0,0,0,2194,2197,1,0,0,0,2195,2193,1,0,0,0,2195,2196,1,0, - 0,0,2196,247,1,0,0,0,2197,2195,1,0,0,0,2198,2209,3,250,125,0,2199,2201, - 5,170,0,0,2200,2199,1,0,0,0,2200,2201,1,0,0,0,2201,2202,1,0,0,0,2202, - 2204,5,18,0,0,2203,2205,5,170,0,0,2204,2203,1,0,0,0,2204,2205,1,0,0,0, - 2205,2206,1,0,0,0,2206,2208,3,250,125,0,2207,2200,1,0,0,0,2208,2211,1, - 0,0,0,2209,2207,1,0,0,0,2209,2210,1,0,0,0,2210,249,1,0,0,0,2211,2209, - 1,0,0,0,2212,2224,3,254,127,0,2213,2215,5,170,0,0,2214,2213,1,0,0,0,2214, - 2215,1,0,0,0,2215,2216,1,0,0,0,2216,2218,3,252,126,0,2217,2219,5,170, - 0,0,2218,2217,1,0,0,0,2218,2219,1,0,0,0,2219,2220,1,0,0,0,2220,2221,3, - 254,127,0,2221,2223,1,0,0,0,2222,2214,1,0,0,0,2223,2226,1,0,0,0,2224, - 2222,1,0,0,0,2224,2225,1,0,0,0,2225,251,1,0,0,0,2226,2224,1,0,0,0,2227, - 2228,7,3,0,0,2228,253,1,0,0,0,2229,2241,3,258,129,0,2230,2232,5,170,0, - 0,2231,2230,1,0,0,0,2231,2232,1,0,0,0,2232,2233,1,0,0,0,2233,2235,3,256, - 128,0,2234,2236,5,170,0,0,2235,2234,1,0,0,0,2235,2236,1,0,0,0,2236,2237, - 1,0,0,0,2237,2238,3,258,129,0,2238,2240,1,0,0,0,2239,2231,1,0,0,0,2240, - 2243,1,0,0,0,2241,2239,1,0,0,0,2241,2242,1,0,0,0,2242,255,1,0,0,0,2243, - 2241,1,0,0,0,2244,2245,7,4,0,0,2245,257,1,0,0,0,2246,2258,3,262,131,0, - 2247,2249,5,170,0,0,2248,2247,1,0,0,0,2248,2249,1,0,0,0,2249,2250,1,0, - 0,0,2250,2252,3,260,130,0,2251,2253,5,170,0,0,2252,2251,1,0,0,0,2252, - 2253,1,0,0,0,2253,2254,1,0,0,0,2254,2255,3,262,131,0,2255,2257,1,0,0, - 0,2256,2248,1,0,0,0,2257,2260,1,0,0,0,2258,2256,1,0,0,0,2258,2259,1,0, - 0,0,2259,259,1,0,0,0,2260,2258,1,0,0,0,2261,2262,7,5,0,0,2262,261,1,0, - 0,0,2263,2274,3,264,132,0,2264,2266,5,170,0,0,2265,2264,1,0,0,0,2265, - 2266,1,0,0,0,2266,2267,1,0,0,0,2267,2269,5,24,0,0,2268,2270,5,170,0,0, - 2269,2268,1,0,0,0,2269,2270,1,0,0,0,2270,2271,1,0,0,0,2271,2273,3,264, - 132,0,2272,2265,1,0,0,0,2273,2276,1,0,0,0,2274,2272,1,0,0,0,2274,2275, - 1,0,0,0,2275,263,1,0,0,0,2276,2274,1,0,0,0,2277,2279,5,153,0,0,2278,2280, - 5,170,0,0,2279,2278,1,0,0,0,2279,2280,1,0,0,0,2280,2282,1,0,0,0,2281, - 2277,1,0,0,0,2282,2285,1,0,0,0,2283,2281,1,0,0,0,2283,2284,1,0,0,0,2284, - 2286,1,0,0,0,2285,2283,1,0,0,0,2286,2291,3,266,133,0,2287,2289,5,170, - 0,0,2288,2287,1,0,0,0,2288,2289,1,0,0,0,2289,2290,1,0,0,0,2290,2292,5, - 154,0,0,2291,2288,1,0,0,0,2291,2292,1,0,0,0,2292,265,1,0,0,0,2293,2301, - 3,276,138,0,2294,2302,3,270,135,0,2295,2297,3,268,134,0,2296,2295,1,0, - 0,0,2297,2298,1,0,0,0,2298,2296,1,0,0,0,2298,2299,1,0,0,0,2299,2302,1, - 0,0,0,2300,2302,3,274,137,0,2301,2294,1,0,0,0,2301,2296,1,0,0,0,2301, - 2300,1,0,0,0,2301,2302,1,0,0,0,2302,267,1,0,0,0,2303,2304,5,170,0,0,2304, - 2306,5,95,0,0,2305,2307,5,170,0,0,2306,2305,1,0,0,0,2306,2307,1,0,0,0, - 2307,2308,1,0,0,0,2308,2323,3,276,138,0,2309,2310,5,7,0,0,2310,2311,3, - 232,116,0,2311,2312,5,8,0,0,2312,2323,1,0,0,0,2313,2315,5,7,0,0,2314, - 2316,3,232,116,0,2315,2314,1,0,0,0,2315,2316,1,0,0,0,2316,2317,1,0,0, - 0,2317,2319,5,155,0,0,2318,2320,3,232,116,0,2319,2318,1,0,0,0,2319,2320, - 1,0,0,0,2320,2321,1,0,0,0,2321,2323,5,8,0,0,2322,2303,1,0,0,0,2322,2309, - 1,0,0,0,2322,2313,1,0,0,0,2323,269,1,0,0,0,2324,2336,3,272,136,0,2325, - 2326,5,170,0,0,2326,2327,5,133,0,0,2327,2328,5,170,0,0,2328,2336,5,145, - 0,0,2329,2330,5,170,0,0,2330,2331,5,81,0,0,2331,2332,5,170,0,0,2332,2336, - 5,145,0,0,2333,2334,5,170,0,0,2334,2336,5,65,0,0,2335,2324,1,0,0,0,2335, - 2325,1,0,0,0,2335,2329,1,0,0,0,2335,2333,1,0,0,0,2336,2338,1,0,0,0,2337, - 2339,5,170,0,0,2338,2337,1,0,0,0,2338,2339,1,0,0,0,2339,2340,1,0,0,0, - 2340,2341,3,276,138,0,2341,271,1,0,0,0,2342,2344,5,170,0,0,2343,2342, - 1,0,0,0,2343,2344,1,0,0,0,2344,2345,1,0,0,0,2345,2346,5,25,0,0,2346,273, - 1,0,0,0,2347,2348,5,170,0,0,2348,2349,5,98,0,0,2349,2350,5,170,0,0,2350, - 2358,5,113,0,0,2351,2352,5,170,0,0,2352,2353,5,98,0,0,2353,2354,5,170, - 0,0,2354,2355,5,111,0,0,2355,2356,5,170,0,0,2356,2358,5,113,0,0,2357, - 2347,1,0,0,0,2357,2351,1,0,0,0,2358,275,1,0,0,0,2359,2366,3,278,139,0, - 2360,2362,5,170,0,0,2361,2360,1,0,0,0,2361,2362,1,0,0,0,2362,2363,1,0, - 0,0,2363,2365,3,316,158,0,2364,2361,1,0,0,0,2365,2368,1,0,0,0,2366,2364, - 1,0,0,0,2366,2367,1,0,0,0,2367,277,1,0,0,0,2368,2366,1,0,0,0,2369,2380, - 3,286,143,0,2370,2380,3,326,163,0,2371,2380,3,318,159,0,2372,2380,3,298, - 149,0,2373,2380,3,300,150,0,2374,2380,3,310,155,0,2375,2380,3,312,156, - 0,2376,2380,3,314,157,0,2377,2380,3,322,161,0,2378,2380,3,280,140,0,2379, - 2369,1,0,0,0,2379,2370,1,0,0,0,2379,2371,1,0,0,0,2379,2372,1,0,0,0,2379, - 2373,1,0,0,0,2379,2374,1,0,0,0,2379,2375,1,0,0,0,2379,2376,1,0,0,0,2379, - 2377,1,0,0,0,2379,2378,1,0,0,0,2380,279,1,0,0,0,2381,2383,5,48,0,0,2382, - 2384,5,170,0,0,2383,2382,1,0,0,0,2383,2384,1,0,0,0,2384,2385,1,0,0,0, - 2385,2387,5,2,0,0,2386,2388,5,170,0,0,2387,2386,1,0,0,0,2387,2388,1,0, - 0,0,2388,2389,1,0,0,0,2389,2391,3,282,141,0,2390,2392,5,170,0,0,2391, - 2390,1,0,0,0,2391,2392,1,0,0,0,2392,2393,1,0,0,0,2393,2394,5,4,0,0,2394, - 2438,1,0,0,0,2395,2397,5,46,0,0,2396,2398,5,170,0,0,2397,2396,1,0,0,0, - 2397,2398,1,0,0,0,2398,2399,1,0,0,0,2399,2401,5,2,0,0,2400,2402,5,170, - 0,0,2401,2400,1,0,0,0,2401,2402,1,0,0,0,2402,2403,1,0,0,0,2403,2405,3, - 282,141,0,2404,2406,5,170,0,0,2405,2404,1,0,0,0,2405,2406,1,0,0,0,2406, - 2407,1,0,0,0,2407,2408,5,4,0,0,2408,2438,1,0,0,0,2409,2411,5,112,0,0, - 2410,2412,5,170,0,0,2411,2410,1,0,0,0,2411,2412,1,0,0,0,2412,2413,1,0, - 0,0,2413,2415,5,2,0,0,2414,2416,5,170,0,0,2415,2414,1,0,0,0,2415,2416, - 1,0,0,0,2416,2417,1,0,0,0,2417,2419,3,282,141,0,2418,2420,5,170,0,0,2419, - 2418,1,0,0,0,2419,2420,1,0,0,0,2420,2421,1,0,0,0,2421,2422,5,4,0,0,2422, - 2438,1,0,0,0,2423,2425,5,148,0,0,2424,2426,5,170,0,0,2425,2424,1,0,0, - 0,2425,2426,1,0,0,0,2426,2427,1,0,0,0,2427,2429,5,2,0,0,2428,2430,5,170, - 0,0,2429,2428,1,0,0,0,2429,2430,1,0,0,0,2430,2431,1,0,0,0,2431,2433,3, - 282,141,0,2432,2434,5,170,0,0,2433,2432,1,0,0,0,2433,2434,1,0,0,0,2434, - 2435,1,0,0,0,2435,2436,5,4,0,0,2436,2438,1,0,0,0,2437,2381,1,0,0,0,2437, - 2395,1,0,0,0,2437,2409,1,0,0,0,2437,2423,1,0,0,0,2438,281,1,0,0,0,2439, - 2444,3,284,142,0,2440,2442,5,170,0,0,2441,2440,1,0,0,0,2441,2442,1,0, - 0,0,2442,2443,1,0,0,0,2443,2445,3,190,95,0,2444,2441,1,0,0,0,2444,2445, - 1,0,0,0,2445,283,1,0,0,0,2446,2447,3,322,161,0,2447,2448,5,170,0,0,2448, - 2449,5,95,0,0,2449,2450,5,170,0,0,2450,2451,3,232,116,0,2451,285,1,0, - 0,0,2452,2459,3,324,162,0,2453,2459,5,156,0,0,2454,2459,3,288,144,0,2455, - 2459,5,113,0,0,2456,2459,3,290,145,0,2457,2459,3,294,147,0,2458,2452, - 1,0,0,0,2458,2453,1,0,0,0,2458,2454,1,0,0,0,2458,2455,1,0,0,0,2458,2456, - 1,0,0,0,2458,2457,1,0,0,0,2459,287,1,0,0,0,2460,2461,7,6,0,0,2461,289, - 1,0,0,0,2462,2464,5,7,0,0,2463,2465,5,170,0,0,2464,2463,1,0,0,0,2464, - 2465,1,0,0,0,2465,2479,1,0,0,0,2466,2468,3,232,116,0,2467,2469,5,170, - 0,0,2468,2467,1,0,0,0,2468,2469,1,0,0,0,2469,2476,1,0,0,0,2470,2472,3, - 292,146,0,2471,2473,5,170,0,0,2472,2471,1,0,0,0,2472,2473,1,0,0,0,2473, - 2475,1,0,0,0,2474,2470,1,0,0,0,2475,2478,1,0,0,0,2476,2474,1,0,0,0,2476, - 2477,1,0,0,0,2477,2480,1,0,0,0,2478,2476,1,0,0,0,2479,2466,1,0,0,0,2479, - 2480,1,0,0,0,2480,2481,1,0,0,0,2481,2482,5,8,0,0,2482,291,1,0,0,0,2483, - 2485,5,3,0,0,2484,2486,5,170,0,0,2485,2484,1,0,0,0,2485,2486,1,0,0,0, - 2486,2488,1,0,0,0,2487,2489,3,232,116,0,2488,2487,1,0,0,0,2488,2489,1, - 0,0,0,2489,293,1,0,0,0,2490,2492,5,9,0,0,2491,2493,5,170,0,0,2492,2491, - 1,0,0,0,2492,2493,1,0,0,0,2493,2494,1,0,0,0,2494,2496,3,296,148,0,2495, - 2497,5,170,0,0,2496,2495,1,0,0,0,2496,2497,1,0,0,0,2497,2508,1,0,0,0, - 2498,2500,5,3,0,0,2499,2501,5,170,0,0,2500,2499,1,0,0,0,2500,2501,1,0, - 0,0,2501,2502,1,0,0,0,2502,2504,3,296,148,0,2503,2505,5,170,0,0,2504, - 2503,1,0,0,0,2504,2505,1,0,0,0,2505,2507,1,0,0,0,2506,2498,1,0,0,0,2507, - 2510,1,0,0,0,2508,2506,1,0,0,0,2508,2509,1,0,0,0,2509,2511,1,0,0,0,2510, - 2508,1,0,0,0,2511,2512,5,10,0,0,2512,295,1,0,0,0,2513,2516,3,338,169, - 0,2514,2516,5,156,0,0,2515,2513,1,0,0,0,2515,2514,1,0,0,0,2516,2518,1, - 0,0,0,2517,2519,5,170,0,0,2518,2517,1,0,0,0,2518,2519,1,0,0,0,2519,2520, - 1,0,0,0,2520,2522,5,155,0,0,2521,2523,5,170,0,0,2522,2521,1,0,0,0,2522, - 2523,1,0,0,0,2523,2524,1,0,0,0,2524,2525,3,232,116,0,2525,297,1,0,0,0, - 2526,2528,5,2,0,0,2527,2529,5,170,0,0,2528,2527,1,0,0,0,2528,2529,1,0, - 0,0,2529,2530,1,0,0,0,2530,2532,3,232,116,0,2531,2533,5,170,0,0,2532, - 2531,1,0,0,0,2532,2533,1,0,0,0,2533,2534,1,0,0,0,2534,2535,5,4,0,0,2535, - 299,1,0,0,0,2536,2538,5,67,0,0,2537,2539,5,170,0,0,2538,2537,1,0,0,0, - 2538,2539,1,0,0,0,2539,2540,1,0,0,0,2540,2542,5,2,0,0,2541,2543,5,170, - 0,0,2542,2541,1,0,0,0,2542,2543,1,0,0,0,2543,2544,1,0,0,0,2544,2546,5, - 150,0,0,2545,2547,5,170,0,0,2546,2545,1,0,0,0,2546,2547,1,0,0,0,2547, - 2548,1,0,0,0,2548,2614,5,4,0,0,2549,2551,5,59,0,0,2550,2552,5,170,0,0, - 2551,2550,1,0,0,0,2551,2552,1,0,0,0,2552,2553,1,0,0,0,2553,2555,5,2,0, - 0,2554,2556,5,170,0,0,2555,2554,1,0,0,0,2555,2556,1,0,0,0,2556,2557,1, - 0,0,0,2557,2559,3,304,152,0,2558,2560,5,170,0,0,2559,2558,1,0,0,0,2559, - 2560,1,0,0,0,2560,2571,1,0,0,0,2561,2563,5,51,0,0,2562,2564,5,170,0,0, - 2563,2562,1,0,0,0,2563,2564,1,0,0,0,2564,2565,1,0,0,0,2565,2572,3,100, - 50,0,2566,2568,5,3,0,0,2567,2569,5,170,0,0,2568,2567,1,0,0,0,2568,2569, - 1,0,0,0,2569,2570,1,0,0,0,2570,2572,3,304,152,0,2571,2561,1,0,0,0,2571, - 2566,1,0,0,0,2572,2574,1,0,0,0,2573,2575,5,170,0,0,2574,2573,1,0,0,0, - 2574,2575,1,0,0,0,2575,2576,1,0,0,0,2576,2577,5,4,0,0,2577,2614,1,0,0, - 0,2578,2580,3,302,151,0,2579,2581,5,170,0,0,2580,2579,1,0,0,0,2580,2581, - 1,0,0,0,2581,2582,1,0,0,0,2582,2584,5,2,0,0,2583,2585,5,170,0,0,2584, - 2583,1,0,0,0,2584,2585,1,0,0,0,2585,2590,1,0,0,0,2586,2588,5,77,0,0,2587, - 2589,5,170,0,0,2588,2587,1,0,0,0,2588,2589,1,0,0,0,2589,2591,1,0,0,0, - 2590,2586,1,0,0,0,2590,2591,1,0,0,0,2591,2609,1,0,0,0,2592,2594,3,304, - 152,0,2593,2595,5,170,0,0,2594,2593,1,0,0,0,2594,2595,1,0,0,0,2595,2606, - 1,0,0,0,2596,2598,5,3,0,0,2597,2599,5,170,0,0,2598,2597,1,0,0,0,2598, - 2599,1,0,0,0,2599,2600,1,0,0,0,2600,2602,3,304,152,0,2601,2603,5,170, - 0,0,2602,2601,1,0,0,0,2602,2603,1,0,0,0,2603,2605,1,0,0,0,2604,2596,1, - 0,0,0,2605,2608,1,0,0,0,2606,2604,1,0,0,0,2606,2607,1,0,0,0,2607,2610, - 1,0,0,0,2608,2606,1,0,0,0,2609,2592,1,0,0,0,2609,2610,1,0,0,0,2610,2611, - 1,0,0,0,2611,2612,5,4,0,0,2612,2614,1,0,0,0,2613,2536,1,0,0,0,2613,2549, - 1,0,0,0,2613,2578,1,0,0,0,2614,301,1,0,0,0,2615,2616,3,338,169,0,2616, - 303,1,0,0,0,2617,2619,3,338,169,0,2618,2620,5,170,0,0,2619,2618,1,0,0, - 0,2619,2620,1,0,0,0,2620,2621,1,0,0,0,2621,2622,5,155,0,0,2622,2624,5, - 6,0,0,2623,2625,5,170,0,0,2624,2623,1,0,0,0,2624,2625,1,0,0,0,2625,2627, - 1,0,0,0,2626,2617,1,0,0,0,2626,2627,1,0,0,0,2627,2628,1,0,0,0,2628,2631, - 3,232,116,0,2629,2631,3,306,153,0,2630,2626,1,0,0,0,2630,2629,1,0,0,0, - 2631,305,1,0,0,0,2632,2634,3,308,154,0,2633,2635,5,170,0,0,2634,2633, - 1,0,0,0,2634,2635,1,0,0,0,2635,2636,1,0,0,0,2636,2637,5,153,0,0,2637, - 2639,5,16,0,0,2638,2640,5,170,0,0,2639,2638,1,0,0,0,2639,2640,1,0,0,0, - 2640,2641,1,0,0,0,2641,2643,3,232,116,0,2642,2644,5,170,0,0,2643,2642, - 1,0,0,0,2643,2644,1,0,0,0,2644,307,1,0,0,0,2645,2670,3,338,169,0,2646, - 2648,5,2,0,0,2647,2649,5,170,0,0,2648,2647,1,0,0,0,2648,2649,1,0,0,0, - 2649,2650,1,0,0,0,2650,2652,3,338,169,0,2651,2653,5,170,0,0,2652,2651, - 1,0,0,0,2652,2653,1,0,0,0,2653,2664,1,0,0,0,2654,2656,5,3,0,0,2655,2657, - 5,170,0,0,2656,2655,1,0,0,0,2656,2657,1,0,0,0,2657,2658,1,0,0,0,2658, - 2660,3,338,169,0,2659,2661,5,170,0,0,2660,2659,1,0,0,0,2660,2661,1,0, - 0,0,2661,2663,1,0,0,0,2662,2654,1,0,0,0,2663,2666,1,0,0,0,2664,2662,1, - 0,0,0,2664,2665,1,0,0,0,2665,2667,1,0,0,0,2666,2664,1,0,0,0,2667,2668, - 5,4,0,0,2668,2670,1,0,0,0,2669,2645,1,0,0,0,2669,2646,1,0,0,0,2670,309, - 1,0,0,0,2671,2676,3,200,100,0,2672,2674,5,170,0,0,2673,2672,1,0,0,0,2673, - 2674,1,0,0,0,2674,2675,1,0,0,0,2675,2677,3,202,101,0,2676,2673,1,0,0, - 0,2677,2678,1,0,0,0,2678,2676,1,0,0,0,2678,2679,1,0,0,0,2679,311,1,0, - 0,0,2680,2682,5,82,0,0,2681,2683,5,170,0,0,2682,2681,1,0,0,0,2682,2683, - 1,0,0,0,2683,2684,1,0,0,0,2684,2686,5,9,0,0,2685,2687,5,170,0,0,2686, - 2685,1,0,0,0,2686,2687,1,0,0,0,2687,2688,1,0,0,0,2688,2690,5,104,0,0, - 2689,2691,5,170,0,0,2690,2689,1,0,0,0,2690,2691,1,0,0,0,2691,2692,1,0, - 0,0,2692,2697,3,192,96,0,2693,2695,5,170,0,0,2694,2693,1,0,0,0,2694,2695, - 1,0,0,0,2695,2696,1,0,0,0,2696,2698,3,190,95,0,2697,2694,1,0,0,0,2697, - 2698,1,0,0,0,2698,2700,1,0,0,0,2699,2701,5,170,0,0,2700,2699,1,0,0,0, - 2700,2701,1,0,0,0,2701,2702,1,0,0,0,2702,2703,5,10,0,0,2703,313,1,0,0, - 0,2704,2706,5,67,0,0,2705,2707,5,170,0,0,2706,2705,1,0,0,0,2706,2707, - 1,0,0,0,2707,2708,1,0,0,0,2708,2710,5,9,0,0,2709,2711,5,170,0,0,2710, - 2709,1,0,0,0,2710,2711,1,0,0,0,2711,2712,1,0,0,0,2712,2714,5,104,0,0, - 2713,2715,5,170,0,0,2714,2713,1,0,0,0,2714,2715,1,0,0,0,2715,2716,1,0, - 0,0,2716,2721,3,192,96,0,2717,2719,5,170,0,0,2718,2717,1,0,0,0,2718,2719, - 1,0,0,0,2719,2720,1,0,0,0,2720,2722,3,190,95,0,2721,2718,1,0,0,0,2721, - 2722,1,0,0,0,2722,2724,1,0,0,0,2723,2725,5,170,0,0,2724,2723,1,0,0,0, - 2724,2725,1,0,0,0,2725,2726,1,0,0,0,2726,2727,5,10,0,0,2727,315,1,0,0, - 0,2728,2730,5,5,0,0,2729,2731,5,170,0,0,2730,2729,1,0,0,0,2730,2731,1, - 0,0,0,2731,2734,1,0,0,0,2732,2735,3,330,165,0,2733,2735,5,150,0,0,2734, - 2732,1,0,0,0,2734,2733,1,0,0,0,2735,317,1,0,0,0,2736,2741,5,58,0,0,2737, - 2739,5,170,0,0,2738,2737,1,0,0,0,2738,2739,1,0,0,0,2739,2740,1,0,0,0, - 2740,2742,3,320,160,0,2741,2738,1,0,0,0,2742,2743,1,0,0,0,2743,2741,1, - 0,0,0,2743,2744,1,0,0,0,2744,2759,1,0,0,0,2745,2747,5,58,0,0,2746,2748, - 5,170,0,0,2747,2746,1,0,0,0,2747,2748,1,0,0,0,2748,2749,1,0,0,0,2749, - 2754,3,232,116,0,2750,2752,5,170,0,0,2751,2750,1,0,0,0,2751,2752,1,0, - 0,0,2752,2753,1,0,0,0,2753,2755,3,320,160,0,2754,2751,1,0,0,0,2755,2756, - 1,0,0,0,2756,2754,1,0,0,0,2756,2757,1,0,0,0,2757,2759,1,0,0,0,2758,2736, - 1,0,0,0,2758,2745,1,0,0,0,2759,2768,1,0,0,0,2760,2762,5,170,0,0,2761, - 2760,1,0,0,0,2761,2762,1,0,0,0,2762,2763,1,0,0,0,2763,2765,5,79,0,0,2764, - 2766,5,170,0,0,2765,2764,1,0,0,0,2765,2766,1,0,0,0,2766,2767,1,0,0,0, - 2767,2769,3,232,116,0,2768,2761,1,0,0,0,2768,2769,1,0,0,0,2769,2771,1, - 0,0,0,2770,2772,5,170,0,0,2771,2770,1,0,0,0,2771,2772,1,0,0,0,2772,2773, - 1,0,0,0,2773,2774,5,80,0,0,2774,319,1,0,0,0,2775,2777,5,143,0,0,2776, - 2778,5,170,0,0,2777,2776,1,0,0,0,2777,2778,1,0,0,0,2778,2779,1,0,0,0, - 2779,2781,3,232,116,0,2780,2782,5,170,0,0,2781,2780,1,0,0,0,2781,2782, - 1,0,0,0,2782,2783,1,0,0,0,2783,2785,5,135,0,0,2784,2786,5,170,0,0,2785, - 2784,1,0,0,0,2785,2786,1,0,0,0,2786,2787,1,0,0,0,2787,2788,3,232,116, - 0,2788,321,1,0,0,0,2789,2790,3,338,169,0,2790,323,1,0,0,0,2791,2794,3, - 334,167,0,2792,2794,3,332,166,0,2793,2791,1,0,0,0,2793,2792,1,0,0,0,2794, - 325,1,0,0,0,2795,2798,5,26,0,0,2796,2799,3,338,169,0,2797,2799,5,158, - 0,0,2798,2796,1,0,0,0,2798,2797,1,0,0,0,2799,327,1,0,0,0,2800,2802,3, - 278,139,0,2801,2803,5,170,0,0,2802,2801,1,0,0,0,2802,2803,1,0,0,0,2803, - 2804,1,0,0,0,2804,2805,3,316,158,0,2805,329,1,0,0,0,2806,2807,3,336,168, - 0,2807,331,1,0,0,0,2808,2809,5,158,0,0,2809,333,1,0,0,0,2810,2811,5,165, - 0,0,2811,335,1,0,0,0,2812,2813,3,338,169,0,2813,337,1,0,0,0,2814,2820, - 5,166,0,0,2815,2816,5,169,0,0,2816,2820,6,169,-1,0,2817,2820,5,159,0, - 0,2818,2820,3,340,170,0,2819,2814,1,0,0,0,2819,2815,1,0,0,0,2819,2817, - 1,0,0,0,2819,2818,1,0,0,0,2820,339,1,0,0,0,2821,2822,7,7,0,0,2822,341, - 1,0,0,0,2823,2824,7,8,0,0,2824,343,1,0,0,0,2825,2826,7,9,0,0,2826,345, - 1,0,0,0,2827,2828,7,10,0,0,2828,347,1,0,0,0,487,350,354,359,363,368,371, - 375,378,402,408,412,415,421,424,428,432,436,441,445,452,456,464,468,478, - 482,486,491,504,508,516,519,527,530,545,550,556,560,563,566,572,576,582, - 586,591,606,610,632,636,639,642,645,648,652,657,661,671,675,680,685,690, - 696,700,704,709,716,720,724,727,731,735,754,758,762,766,770,775,788,792, - 796,800,804,808,810,814,818,820,835,839,843,847,851,856,859,863,867,869, - 873,877,879,898,909,916,929,936,942,945,955,958,966,969,975,978,984,999, - 1015,1024,1050,1054,1059,1068,1072,1077,1083,1089,1093,1097,1105,1109, - 1113,1119,1123,1127,1133,1137,1141,1145,1149,1155,1159,1163,1167,1171, - 1175,1181,1188,1193,1199,1218,1222,1230,1238,1240,1250,1254,1258,1264, - 1268,1273,1278,1283,1288,1292,1297,1303,1308,1311,1315,1319,1323,1329, - 1333,1338,1343,1347,1350,1354,1358,1362,1366,1370,1376,1380,1385,1389, - 1398,1404,1412,1416,1420,1424,1431,1434,1437,1440,1444,1446,1452,1455, - 1459,1463,1467,1471,1475,1479,1484,1490,1494,1498,1502,1507,1511,1520, - 1524,1529,1543,1545,1547,1552,1562,1568,1575,1588,1592,1596,1600,1605, - 1610,1614,1620,1624,1628,1632,1637,1643,1646,1652,1655,1661,1665,1669, - 1673,1677,1682,1687,1691,1696,1699,1708,1717,1722,1735,1738,1746,1750, - 1755,1760,1764,1769,1775,1780,1787,1791,1795,1797,1801,1803,1807,1809, - 1815,1821,1825,1828,1831,1837,1840,1843,1847,1853,1856,1859,1863,1867, - 1871,1873,1877,1879,1883,1885,1889,1891,1897,1901,1905,1909,1913,1917, - 1921,1925,1929,1932,1938,1942,1946,1949,1954,1959,1964,1969,1975,1981, - 1984,1987,1990,1994,1997,2000,2003,2006,2010,2014,2018,2022,2026,2030, - 2032,2035,2039,2043,2047,2051,2053,2059,2062,2065,2071,2074,2077,2098, - 2108,2118,2123,2127,2134,2138,2142,2146,2150,2158,2162,2166,2170,2176, - 2180,2186,2190,2195,2200,2204,2209,2214,2218,2224,2231,2235,2241,2248, - 2252,2258,2265,2269,2274,2279,2283,2288,2291,2298,2301,2306,2315,2319, - 2322,2335,2338,2343,2357,2361,2366,2379,2383,2387,2391,2397,2401,2405, - 2411,2415,2419,2425,2429,2433,2437,2441,2444,2458,2464,2468,2472,2476, - 2479,2485,2488,2492,2496,2500,2504,2508,2515,2518,2522,2528,2532,2538, - 2542,2546,2551,2555,2559,2563,2568,2571,2574,2580,2584,2588,2590,2594, - 2598,2602,2606,2609,2613,2619,2624,2626,2630,2634,2639,2643,2648,2652, - 2656,2660,2664,2669,2673,2678,2682,2686,2690,2694,2697,2700,2706,2710, - 2714,2718,2721,2724,2730,2734,2738,2743,2747,2751,2756,2758,2761,2765, - 2768,2771,2777,2781,2785,2793,2798,2802,2819 + 7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,1,0, + 1,0,3,0,355,8,0,1,0,1,0,3,0,359,8,0,1,0,5,0,362,8,0,10,0,12,0,365,9,0, + 1,0,3,0,368,8,0,1,0,1,0,1,1,3,1,373,8,1,1,1,3,1,376,8,1,1,1,1,1,3,1,380, + 8,1,1,1,3,1,383,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,3,2,408,8,2,1,3,1,3,1,3,1,3, + 3,3,414,8,3,1,3,1,3,3,3,418,8,3,1,3,3,3,421,8,3,1,3,1,3,1,3,1,3,3,3,427, + 8,3,1,3,3,3,430,8,3,1,4,1,4,3,4,434,8,4,1,4,1,4,3,4,438,8,4,1,4,1,4,3, + 4,442,8,4,1,4,5,4,445,8,4,10,4,12,4,448,9,4,1,4,3,4,451,8,4,1,4,1,4,1, + 5,1,5,1,5,3,5,458,8,5,1,5,1,5,3,5,462,8,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5, + 470,8,5,1,5,1,5,3,5,474,8,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,3,6,484,8, + 6,1,6,1,6,3,6,488,8,6,1,6,1,6,3,6,492,8,6,1,6,5,6,495,8,6,10,6,12,6,498, + 9,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1,7,1,7,3,7,510,8,7,1,7,1,7,3,7,514, + 8,7,1,7,1,7,1,7,1,7,1,7,1,7,3,7,522,8,7,1,7,3,7,525,8,7,1,8,1,8,1,8,1, + 8,1,8,1,8,3,8,533,8,8,1,8,3,8,536,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,551,8,10,1,10,1,10,1,10,3,10,556,8,10, + 1,10,1,10,1,10,1,10,3,10,562,8,10,1,10,1,10,3,10,566,8,10,1,10,3,10,569, + 8,10,1,10,3,10,572,8,10,1,10,1,10,1,11,1,11,3,11,578,8,11,1,11,1,11,3, + 11,582,8,11,1,11,1,11,1,12,1,12,3,12,588,8,12,1,12,1,12,3,12,592,8,12, + 1,12,5,12,595,8,12,10,12,12,12,598,9,12,1,13,1,13,1,13,1,13,1,14,1,14, + 1,14,1,14,1,15,1,15,1,15,1,15,3,15,612,8,15,1,15,1,15,3,15,616,8,15,1, + 15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1, + 17,1,17,1,17,1,17,1,17,1,17,3,17,638,8,17,1,17,1,17,3,17,642,8,17,1,17, + 3,17,645,8,17,1,17,3,17,648,8,17,1,17,3,17,651,8,17,1,17,3,17,654,8,17, + 1,17,1,17,3,17,658,8,17,1,17,5,17,661,8,17,10,17,12,17,664,9,17,1,17, + 3,17,667,8,17,1,17,1,17,1,17,1,17,1,17,1,17,1,18,1,18,3,18,677,8,18,1, + 18,1,18,3,18,681,8,18,1,18,5,18,684,8,18,10,18,12,18,687,9,18,1,19,1, + 19,3,19,691,8,19,1,19,1,19,1,19,3,19,696,8,19,1,19,1,19,1,20,1,20,3,20, + 702,8,20,1,20,1,20,3,20,706,8,20,1,20,1,20,3,20,710,8,20,1,20,5,20,713, + 8,20,10,20,12,20,716,9,20,1,20,1,20,1,20,1,20,3,20,722,8,20,1,20,1,20, + 3,20,726,8,20,1,20,1,20,3,20,730,8,20,1,20,3,20,733,8,20,1,21,1,21,3, + 21,737,8,21,1,21,1,21,3,21,741,8,21,1,21,1,21,1,22,1,22,1,22,1,22,1,22, + 1,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,760,8,23,1,23, + 1,23,3,23,764,8,23,1,23,1,23,3,23,768,8,23,1,23,1,23,3,23,772,8,23,1, + 23,1,23,3,23,776,8,23,1,23,1,23,1,23,3,23,781,8,23,1,23,1,23,1,24,1,24, + 1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,1,24,3,24, + 800,8,24,1,24,1,24,3,24,804,8,24,1,24,1,24,3,24,808,8,24,1,24,1,24,1, + 25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,3,25,821,8,25,1,25,1,25,3, + 25,825,8,25,1,25,1,25,3,25,829,8,25,1,25,1,25,3,25,833,8,25,1,25,1,25, + 3,25,837,8,25,1,25,1,25,3,25,841,8,25,3,25,843,8,25,1,25,1,25,3,25,847, + 8,25,1,25,1,25,3,25,851,8,25,3,25,853,8,25,1,25,1,25,1,26,1,26,1,26,1, + 26,1,26,1,26,1,26,1,26,1,26,1,26,1,26,3,26,868,8,26,1,26,1,26,3,26,872, + 8,26,1,26,1,26,3,26,876,8,26,1,26,1,26,3,26,880,8,26,1,26,1,26,3,26,884, + 8,26,1,26,4,26,887,8,26,11,26,12,26,888,1,26,3,26,892,8,26,1,26,1,26, + 3,26,896,8,26,1,26,1,26,3,26,900,8,26,3,26,902,8,26,1,26,1,26,3,26,906, + 8,26,1,26,1,26,3,26,910,8,26,3,26,912,8,26,1,26,1,26,1,27,1,27,1,27,1, + 27,1,27,1,27,1,27,1,27,1,28,1,28,1,28,1,28,1,28,1,28,1,28,3,28,931,8, + 28,1,28,1,28,1,29,1,29,1,29,1,29,1,29,1,29,1,29,3,29,942,8,29,1,29,1, + 29,1,29,5,29,947,8,29,10,29,12,29,950,9,29,1,30,1,30,1,30,1,30,1,30,1, + 30,1,30,1,30,1,30,1,30,3,30,962,8,30,1,31,1,31,1,31,1,31,1,31,3,31,969, + 8,31,1,32,1,32,1,32,1,32,3,32,975,8,32,1,32,3,32,978,8,32,1,32,1,32,1, + 33,1,33,1,33,1,33,1,33,1,33,3,33,988,8,33,1,33,3,33,991,8,33,1,34,1,34, + 1,34,1,34,1,34,1,34,3,34,999,8,34,1,34,3,34,1002,8,34,1,35,1,35,1,35, + 1,35,3,35,1008,8,35,1,35,3,35,1011,8,35,1,35,1,35,1,36,1,36,3,36,1017, + 8,36,1,36,1,36,1,37,1,37,1,37,1,37,1,38,1,38,1,38,1,38,1,38,1,38,1,38, + 3,38,1032,8,38,1,38,1,38,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,40, + 1,40,1,40,1,40,3,40,1048,8,40,1,41,1,41,1,41,1,41,1,41,1,41,1,41,3,41, + 1057,8,41,1,42,1,42,1,42,1,42,1,43,1,43,1,43,1,43,1,44,1,44,1,44,1,44, + 1,44,1,44,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,45,1,46,1,46,3,46,1083, + 8,46,1,46,1,46,3,46,1087,8,46,1,46,5,46,1090,8,46,10,46,12,46,1093,9, + 46,1,47,1,47,1,47,1,47,1,48,1,48,3,48,1101,8,48,1,48,1,48,3,48,1105,8, + 48,1,48,5,48,1108,8,48,10,48,12,48,1111,9,48,1,49,1,49,1,49,3,49,1116, + 8,49,1,50,1,50,1,50,1,50,3,50,1122,8,50,1,50,1,50,3,50,1126,8,50,1,50, + 1,50,3,50,1130,8,50,1,50,1,50,1,51,1,51,1,51,1,51,3,51,1138,8,51,1,51, + 1,51,3,51,1142,8,51,1,51,1,51,3,51,1146,8,51,1,51,1,51,1,51,1,51,3,51, + 1152,8,51,1,51,1,51,3,51,1156,8,51,1,51,1,51,3,51,1160,8,51,1,51,1,51, + 1,51,1,51,3,51,1166,8,51,1,51,1,51,3,51,1170,8,51,1,51,1,51,3,51,1174, + 8,51,1,51,1,51,3,51,1178,8,51,1,51,1,51,3,51,1182,8,51,1,51,1,51,1,51, + 1,51,3,51,1188,8,51,1,51,1,51,3,51,1192,8,51,1,51,1,51,3,51,1196,8,51, + 1,51,1,51,3,51,1200,8,51,1,51,1,51,3,51,1204,8,51,1,51,1,51,3,51,1208, + 8,51,1,51,1,51,5,51,1212,8,51,10,51,12,51,1215,9,51,1,52,1,52,5,52,1219, + 8,52,10,52,12,52,1222,9,52,1,53,1,53,3,53,1226,8,53,1,53,1,53,1,54,1, + 54,3,54,1232,8,54,1,55,1,55,1,56,1,56,1,57,1,57,1,57,1,57,1,57,1,57,1, + 57,1,57,1,57,1,57,1,57,1,57,1,57,3,57,1251,8,57,1,58,1,58,3,58,1255,8, + 58,1,59,1,59,1,59,1,59,1,59,1,59,3,59,1263,8,59,1,60,1,60,1,60,1,60,1, + 61,1,61,3,61,1271,8,61,3,61,1273,8,61,1,61,1,61,1,62,1,62,1,62,1,62,1, + 62,1,62,3,62,1283,8,62,1,62,1,62,3,62,1287,8,62,1,62,1,62,3,62,1291,8, + 62,1,62,1,62,1,63,1,63,3,63,1297,8,63,1,63,1,63,3,63,1301,8,63,1,63,5, + 63,1304,8,63,10,63,12,63,1307,9,63,1,64,1,64,3,64,1311,8,64,1,64,5,64, + 1314,8,64,10,64,12,64,1317,9,64,1,64,1,64,3,64,1321,8,64,4,64,1323,8, + 64,11,64,12,64,1324,1,64,1,64,1,64,3,64,1330,8,64,1,65,1,65,1,65,1,65, + 3,65,1336,8,65,1,65,1,65,1,65,3,65,1341,8,65,1,65,3,65,1344,8,65,1,66, + 1,66,3,66,1348,8,66,1,67,1,67,3,67,1352,8,67,5,67,1354,8,67,10,67,12, + 67,1357,9,67,1,67,1,67,1,67,3,67,1362,8,67,5,67,1364,8,67,10,67,12,67, + 1367,9,67,1,67,1,67,3,67,1371,8,67,1,67,5,67,1374,8,67,10,67,12,67,1377, + 9,67,1,67,3,67,1380,8,67,1,67,3,67,1383,8,67,1,67,1,67,3,67,1387,8,67, + 4,67,1389,8,67,11,67,12,67,1390,1,67,1,67,3,67,1395,8,67,1,68,1,68,3, + 68,1399,8,68,4,68,1401,8,68,11,68,12,68,1402,1,68,1,68,1,69,1,69,3,69, + 1409,8,69,5,69,1411,8,69,10,69,12,69,1414,9,69,1,69,1,69,3,69,1418,8, + 69,5,69,1420,8,69,10,69,12,69,1423,9,69,1,69,1,69,1,70,1,70,1,70,1,70, + 3,70,1431,8,70,1,71,1,71,1,71,1,71,3,71,1437,8,71,1,72,1,72,1,72,1,72, + 1,72,1,72,3,72,1445,8,72,1,72,1,72,3,72,1449,8,72,1,72,1,72,3,72,1453, + 8,72,1,72,1,72,3,72,1457,8,72,1,72,1,72,1,72,1,72,1,72,3,72,1464,8,72, + 1,72,3,72,1467,8,72,1,72,3,72,1470,8,72,1,72,3,72,1473,8,72,1,73,1,73, + 3,73,1477,8,73,3,73,1479,8,73,1,73,1,73,1,73,1,73,3,73,1485,8,73,1,73, + 3,73,1488,8,73,1,74,1,74,3,74,1492,8,74,1,74,1,74,3,74,1496,8,74,1,74, + 1,74,3,74,1500,8,74,1,74,1,74,3,74,1504,8,74,1,75,1,75,3,75,1508,8,75, + 1,75,1,75,3,75,1512,8,75,1,75,5,75,1515,8,75,10,75,12,75,1518,9,75,1, + 76,1,76,1,76,3,76,1523,8,76,1,76,1,76,3,76,1527,8,76,1,77,1,77,3,77,1531, + 8,77,1,77,1,77,3,77,1535,8,77,1,77,1,77,1,77,3,77,1540,8,77,1,77,1,77, + 3,77,1544,8,77,1,78,1,78,1,78,1,78,1,79,1,79,1,79,3,79,1553,8,79,1,79, + 1,79,3,79,1557,8,79,1,79,1,79,1,79,3,79,1562,8,79,1,79,1,79,1,79,1,79, + 1,79,1,79,1,79,1,79,1,79,1,79,4,79,1574,8,79,11,79,12,79,1575,5,79,1578, + 8,79,10,79,12,79,1581,9,79,1,80,1,80,3,80,1585,8,80,1,80,1,80,1,80,1, + 80,1,80,1,80,1,81,1,81,3,81,1595,8,81,1,81,1,81,1,82,1,82,3,82,1601,8, + 82,1,82,1,82,1,82,5,82,1606,8,82,10,82,12,82,1609,9,82,1,83,1,83,1,83, + 1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1621,8,83,1,84,1,84,3,84,1625, + 8,84,1,84,1,84,3,84,1629,8,84,1,84,1,84,3,84,1633,8,84,1,84,5,84,1636, + 8,84,10,84,12,84,1639,9,84,1,85,1,85,3,85,1643,8,85,1,85,1,85,3,85,1647, + 8,85,1,85,1,85,1,86,1,86,3,86,1653,8,86,1,86,1,86,3,86,1657,8,86,1,86, + 1,86,3,86,1661,8,86,1,86,1,86,3,86,1665,8,86,1,86,5,86,1668,8,86,10,86, + 12,86,1671,9,86,1,87,1,87,1,87,3,87,1676,8,87,1,87,3,87,1679,8,87,1,88, + 1,88,1,88,1,89,3,89,1685,8,89,1,89,3,89,1688,8,89,1,89,1,89,1,89,1,89, + 3,89,1694,8,89,1,89,1,89,3,89,1698,8,89,1,89,1,89,3,89,1702,8,89,1,90, + 1,90,3,90,1706,8,90,1,90,1,90,3,90,1710,8,90,1,90,5,90,1713,8,90,10,90, + 12,90,1716,9,90,1,90,1,90,3,90,1720,8,90,1,90,1,90,3,90,1724,8,90,1,90, + 5,90,1727,8,90,10,90,12,90,1730,9,90,3,90,1732,8,90,1,91,1,91,1,91,1, + 91,1,91,1,91,1,91,3,91,1741,8,91,1,92,1,92,1,92,1,92,1,92,1,92,1,92,3, + 92,1750,8,92,1,92,5,92,1753,8,92,10,92,12,92,1756,9,92,1,93,1,93,1,93, + 1,93,1,94,1,94,1,94,1,94,1,95,1,95,3,95,1768,8,95,1,95,3,95,1771,8,95, + 1,96,1,96,1,96,1,96,1,97,1,97,3,97,1779,8,97,1,97,1,97,3,97,1783,8,97, + 1,97,5,97,1786,8,97,10,97,12,97,1789,9,97,1,98,1,98,3,98,1793,8,98,1, + 98,1,98,3,98,1797,8,98,1,98,1,98,1,98,3,98,1802,8,98,1,99,1,99,1,100, + 1,100,3,100,1808,8,100,1,100,5,100,1811,8,100,10,100,12,100,1814,9,100, + 1,100,1,100,1,100,1,100,3,100,1820,8,100,1,101,1,101,3,101,1824,8,101, + 1,101,1,101,3,101,1828,8,101,3,101,1830,8,101,1,101,1,101,3,101,1834, + 8,101,3,101,1836,8,101,1,101,1,101,3,101,1840,8,101,3,101,1842,8,101, + 1,101,1,101,1,102,1,102,3,102,1848,8,102,1,102,1,102,1,103,1,103,3,103, + 1854,8,103,1,103,1,103,3,103,1858,8,103,1,103,3,103,1861,8,103,1,103, + 3,103,1864,8,103,1,103,1,103,1,103,1,103,3,103,1870,8,103,1,103,3,103, + 1873,8,103,1,103,3,103,1876,8,103,1,103,1,103,3,103,1880,8,103,1,103, + 1,103,1,103,1,103,3,103,1886,8,103,1,103,3,103,1889,8,103,1,103,3,103, + 1892,8,103,1,103,1,103,3,103,1896,8,103,1,104,1,104,3,104,1900,8,104, + 1,104,1,104,3,104,1904,8,104,3,104,1906,8,104,1,104,1,104,3,104,1910, + 8,104,3,104,1912,8,104,1,104,1,104,3,104,1916,8,104,3,104,1918,8,104, + 1,104,1,104,3,104,1922,8,104,3,104,1924,8,104,1,104,1,104,1,105,1,105, + 3,105,1930,8,105,1,105,1,105,3,105,1934,8,105,1,105,1,105,3,105,1938, + 8,105,1,105,1,105,3,105,1942,8,105,1,105,1,105,3,105,1946,8,105,1,105, + 1,105,3,105,1950,8,105,1,105,1,105,3,105,1954,8,105,1,105,1,105,3,105, + 1958,8,105,5,105,1960,8,105,10,105,12,105,1963,9,105,3,105,1965,8,105, + 1,105,1,105,1,106,1,106,3,106,1971,8,106,1,106,1,106,3,106,1975,8,106, + 1,106,1,106,3,106,1979,8,106,1,106,3,106,1982,8,106,1,106,5,106,1985, + 8,106,10,106,12,106,1988,9,106,1,107,1,107,3,107,1992,8,107,1,107,5,107, + 1995,8,107,10,107,12,107,1998,9,107,1,108,1,108,3,108,2002,8,108,1,108, + 1,108,1,109,1,109,3,109,2008,8,109,1,109,1,109,1,109,1,109,3,109,2014, + 8,109,1,109,3,109,2017,8,109,1,109,3,109,2020,8,109,1,109,3,109,2023, + 8,109,1,109,1,109,3,109,2027,8,109,1,109,3,109,2030,8,109,1,109,3,109, + 2033,8,109,1,109,3,109,2036,8,109,1,109,3,109,2039,8,109,1,110,1,110, + 3,110,2043,8,110,1,110,1,110,3,110,2047,8,110,1,110,1,110,3,110,2051, + 8,110,1,110,1,110,3,110,2055,8,110,1,110,1,110,3,110,2059,8,110,1,110, + 1,110,3,110,2063,8,110,3,110,2065,8,110,1,110,3,110,2068,8,110,1,110, + 1,110,3,110,2072,8,110,1,110,1,110,3,110,2076,8,110,1,110,1,110,3,110, + 2080,8,110,1,110,1,110,3,110,2084,8,110,3,110,2086,8,110,1,110,1,110, + 1,111,1,111,3,111,2092,8,111,1,111,3,111,2095,8,111,1,111,3,111,2098, + 8,111,1,111,1,111,1,112,1,112,3,112,2104,8,112,1,112,3,112,2107,8,112, + 1,112,3,112,2110,8,112,1,112,1,112,1,113,1,113,1,114,1,114,1,115,1,115, + 1,116,1,116,1,117,1,117,1,118,1,118,1,118,1,118,1,118,5,118,2129,8,118, + 10,118,12,118,2132,9,118,1,119,1,119,1,119,1,119,1,119,5,119,2139,8,119, + 10,119,12,119,2142,9,119,1,120,1,120,1,120,1,120,1,120,5,120,2149,8,120, + 10,120,12,120,2152,9,120,1,121,1,121,3,121,2156,8,121,5,121,2158,8,121, + 10,121,12,121,2161,9,121,1,121,1,121,1,122,1,122,3,122,2167,8,122,1,122, + 1,122,3,122,2171,8,122,1,122,1,122,3,122,2175,8,122,1,122,1,122,3,122, + 2179,8,122,1,122,1,122,3,122,2183,8,122,1,122,1,122,1,122,1,122,1,122, + 1,122,3,122,2191,8,122,1,122,1,122,3,122,2195,8,122,1,122,1,122,3,122, + 2199,8,122,1,122,1,122,3,122,2203,8,122,1,122,1,122,4,122,2207,8,122, + 11,122,12,122,2208,1,122,1,122,3,122,2213,8,122,1,123,1,123,1,124,1,124, + 3,124,2219,8,124,1,124,1,124,3,124,2223,8,124,1,124,5,124,2226,8,124, + 10,124,12,124,2229,9,124,1,125,1,125,3,125,2233,8,125,1,125,1,125,3,125, + 2237,8,125,1,125,5,125,2240,8,125,10,125,12,125,2243,9,125,1,126,1,126, + 3,126,2247,8,126,1,126,1,126,3,126,2251,8,126,1,126,1,126,5,126,2255, + 8,126,10,126,12,126,2258,9,126,1,127,1,127,1,128,1,128,3,128,2264,8,128, + 1,128,1,128,3,128,2268,8,128,1,128,1,128,5,128,2272,8,128,10,128,12,128, + 2275,9,128,1,129,1,129,1,130,1,130,3,130,2281,8,130,1,130,1,130,3,130, + 2285,8,130,1,130,1,130,5,130,2289,8,130,10,130,12,130,2292,9,130,1,131, + 1,131,1,132,1,132,3,132,2298,8,132,1,132,1,132,3,132,2302,8,132,1,132, + 5,132,2305,8,132,10,132,12,132,2308,9,132,1,133,1,133,3,133,2312,8,133, + 5,133,2314,8,133,10,133,12,133,2317,9,133,1,133,1,133,3,133,2321,8,133, + 1,133,3,133,2324,8,133,1,134,1,134,1,134,4,134,2329,8,134,11,134,12,134, + 2330,1,134,3,134,2334,8,134,1,135,1,135,1,135,3,135,2339,8,135,1,135, + 1,135,1,135,1,135,1,135,1,135,1,135,3,135,2348,8,135,1,135,1,135,3,135, + 2352,8,135,1,135,3,135,2355,8,135,1,136,1,136,1,136,1,136,1,136,1,136, + 1,136,1,136,1,136,1,136,1,136,3,136,2368,8,136,1,136,3,136,2371,8,136, + 1,136,1,136,1,137,3,137,2376,8,137,1,137,1,137,1,138,1,138,1,138,1,138, + 1,138,1,138,1,138,1,138,1,138,1,138,3,138,2390,8,138,1,139,1,139,3,139, + 2394,8,139,1,139,5,139,2397,8,139,10,139,12,139,2400,9,139,1,140,1,140, + 1,140,1,140,1,140,1,140,1,140,1,140,1,140,1,140,3,140,2412,8,140,1,141, + 1,141,3,141,2416,8,141,1,141,1,141,3,141,2420,8,141,1,141,1,141,3,141, + 2424,8,141,1,141,1,141,1,141,1,141,3,141,2430,8,141,1,141,1,141,3,141, + 2434,8,141,1,141,1,141,3,141,2438,8,141,1,141,1,141,1,141,1,141,3,141, + 2444,8,141,1,141,1,141,3,141,2448,8,141,1,141,1,141,3,141,2452,8,141, + 1,141,1,141,1,141,1,141,3,141,2458,8,141,1,141,1,141,3,141,2462,8,141, + 1,141,1,141,3,141,2466,8,141,1,141,1,141,3,141,2470,8,141,1,142,1,142, + 3,142,2474,8,142,1,142,3,142,2477,8,142,1,143,1,143,1,143,1,143,1,143, + 1,143,1,144,1,144,1,144,1,144,1,144,1,144,3,144,2491,8,144,1,145,1,145, + 1,146,1,146,3,146,2497,8,146,1,146,1,146,3,146,2501,8,146,1,146,1,146, + 3,146,2505,8,146,5,146,2507,8,146,10,146,12,146,2510,9,146,3,146,2512, + 8,146,1,146,1,146,1,147,1,147,3,147,2518,8,147,1,147,3,147,2521,8,147, + 1,148,1,148,3,148,2525,8,148,1,148,1,148,3,148,2529,8,148,1,148,1,148, + 3,148,2533,8,148,1,148,1,148,3,148,2537,8,148,5,148,2539,8,148,10,148, + 12,148,2542,9,148,1,148,1,148,1,149,1,149,3,149,2548,8,149,1,149,3,149, + 2551,8,149,1,149,1,149,3,149,2555,8,149,1,149,1,149,1,150,1,150,3,150, + 2561,8,150,1,150,1,150,3,150,2565,8,150,1,150,1,150,1,151,1,151,3,151, + 2571,8,151,1,151,1,151,3,151,2575,8,151,1,151,1,151,3,151,2579,8,151, + 1,151,1,151,1,151,3,151,2584,8,151,1,151,1,151,3,151,2588,8,151,1,151, + 1,151,3,151,2592,8,151,1,151,1,151,3,151,2596,8,151,1,151,1,151,1,151, + 3,151,2601,8,151,1,151,3,151,2604,8,151,1,151,3,151,2607,8,151,1,151, + 1,151,1,151,1,151,3,151,2613,8,151,1,151,1,151,3,151,2617,8,151,1,151, + 1,151,3,151,2621,8,151,3,151,2623,8,151,1,151,1,151,3,151,2627,8,151, + 1,151,1,151,3,151,2631,8,151,1,151,1,151,3,151,2635,8,151,5,151,2637, + 8,151,10,151,12,151,2640,9,151,3,151,2642,8,151,1,151,1,151,3,151,2646, + 8,151,1,152,1,152,1,153,1,153,3,153,2652,8,153,1,153,1,153,1,153,3,153, + 2657,8,153,3,153,2659,8,153,1,153,1,153,3,153,2663,8,153,1,154,1,154, + 3,154,2667,8,154,1,154,1,154,1,154,3,154,2672,8,154,1,154,1,154,3,154, + 2676,8,154,1,155,1,155,1,155,3,155,2681,8,155,1,155,1,155,3,155,2685, + 8,155,1,155,1,155,3,155,2689,8,155,1,155,1,155,3,155,2693,8,155,5,155, + 2695,8,155,10,155,12,155,2698,9,155,1,155,1,155,3,155,2702,8,155,1,156, + 1,156,3,156,2706,8,156,1,156,4,156,2709,8,156,11,156,12,156,2710,1,157, + 1,157,3,157,2715,8,157,1,157,1,157,3,157,2719,8,157,1,157,1,157,3,157, + 2723,8,157,1,157,1,157,3,157,2727,8,157,1,157,3,157,2730,8,157,1,157, + 3,157,2733,8,157,1,157,1,157,1,158,1,158,3,158,2739,8,158,1,158,1,158, + 3,158,2743,8,158,1,158,1,158,3,158,2747,8,158,1,158,1,158,3,158,2751, + 8,158,1,158,3,158,2754,8,158,1,158,3,158,2757,8,158,1,158,1,158,1,159, + 1,159,3,159,2763,8,159,1,159,1,159,3,159,2767,8,159,1,160,1,160,3,160, + 2771,8,160,1,160,1,160,1,161,1,161,3,161,2777,8,161,1,161,4,161,2780, + 8,161,11,161,12,161,2781,1,161,1,161,3,161,2786,8,161,1,161,1,161,3,161, + 2790,8,161,1,161,4,161,2793,8,161,11,161,12,161,2794,3,161,2797,8,161, + 1,161,3,161,2800,8,161,1,161,1,161,3,161,2804,8,161,1,161,3,161,2807, + 8,161,1,161,3,161,2810,8,161,1,161,1,161,1,162,1,162,3,162,2816,8,162, + 1,162,1,162,3,162,2820,8,162,1,162,1,162,3,162,2824,8,162,1,162,1,162, + 1,163,1,163,1,164,1,164,3,164,2832,8,164,1,165,1,165,1,165,3,165,2837, + 8,165,1,166,1,166,3,166,2841,8,166,1,166,1,166,1,167,1,167,1,168,1,168, + 1,169,1,169,1,170,1,170,1,171,1,171,1,171,1,171,1,171,3,171,2858,8,171, + 1,172,1,172,1,173,1,173,1,174,1,174,1,175,1,175,1,175,0,2,102,158,176, + 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,0,11,3,0,123,123,130,130,135,135,2,0,52,53,74,75,2,0,6,6,13,17, + 1,0,19,20,2,0,21,21,154,154,2,0,22,23,151,151,2,0,87,87,139,139,29,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,90,90,94,95,97,97,99,99,101,103,105,108,110,111,122,122,124,128,130, + 131,133,133,138,138,140,140,143,143,147,147,150,150,152,152,2,0,14,14, + 27,30,2,0,16,16,31,34,2,0,35,45,154,154,3248,0,352,1,0,0,0,2,372,1,0, + 0,0,4,407,1,0,0,0,6,409,1,0,0,0,8,431,1,0,0,0,10,473,1,0,0,0,12,475,1, + 0,0,0,14,505,1,0,0,0,16,526,1,0,0,0,18,537,1,0,0,0,20,543,1,0,0,0,22, + 575,1,0,0,0,24,585,1,0,0,0,26,599,1,0,0,0,28,603,1,0,0,0,30,607,1,0,0, + 0,32,619,1,0,0,0,34,631,1,0,0,0,36,674,1,0,0,0,38,688,1,0,0,0,40,732, + 1,0,0,0,42,734,1,0,0,0,44,744,1,0,0,0,46,750,1,0,0,0,48,784,1,0,0,0,50, + 811,1,0,0,0,52,856,1,0,0,0,54,915,1,0,0,0,56,923,1,0,0,0,58,934,1,0,0, + 0,60,951,1,0,0,0,62,968,1,0,0,0,64,970,1,0,0,0,66,990,1,0,0,0,68,1001, + 1,0,0,0,70,1003,1,0,0,0,72,1016,1,0,0,0,74,1020,1,0,0,0,76,1024,1,0,0, + 0,78,1035,1,0,0,0,80,1047,1,0,0,0,82,1049,1,0,0,0,84,1058,1,0,0,0,86, + 1062,1,0,0,0,88,1066,1,0,0,0,90,1072,1,0,0,0,92,1080,1,0,0,0,94,1094, + 1,0,0,0,96,1098,1,0,0,0,98,1112,1,0,0,0,100,1117,1,0,0,0,102,1207,1,0, + 0,0,104,1216,1,0,0,0,106,1223,1,0,0,0,108,1231,1,0,0,0,110,1233,1,0,0, + 0,112,1235,1,0,0,0,114,1250,1,0,0,0,116,1254,1,0,0,0,118,1256,1,0,0,0, + 120,1264,1,0,0,0,122,1272,1,0,0,0,124,1276,1,0,0,0,126,1294,1,0,0,0,128, + 1329,1,0,0,0,130,1343,1,0,0,0,132,1347,1,0,0,0,134,1394,1,0,0,0,136,1400, + 1,0,0,0,138,1412,1,0,0,0,140,1430,1,0,0,0,142,1436,1,0,0,0,144,1438,1, + 0,0,0,146,1478,1,0,0,0,148,1489,1,0,0,0,150,1505,1,0,0,0,152,1519,1,0, + 0,0,154,1530,1,0,0,0,156,1545,1,0,0,0,158,1561,1,0,0,0,160,1582,1,0,0, + 0,162,1592,1,0,0,0,164,1598,1,0,0,0,166,1620,1,0,0,0,168,1622,1,0,0,0, + 170,1640,1,0,0,0,172,1652,1,0,0,0,174,1672,1,0,0,0,176,1680,1,0,0,0,178, + 1687,1,0,0,0,180,1731,1,0,0,0,182,1740,1,0,0,0,184,1742,1,0,0,0,186,1757, + 1,0,0,0,188,1761,1,0,0,0,190,1765,1,0,0,0,192,1772,1,0,0,0,194,1776,1, + 0,0,0,196,1801,1,0,0,0,198,1803,1,0,0,0,200,1819,1,0,0,0,202,1821,1,0, + 0,0,204,1845,1,0,0,0,206,1895,1,0,0,0,208,1897,1,0,0,0,210,1927,1,0,0, + 0,212,1968,1,0,0,0,214,1989,1,0,0,0,216,1999,1,0,0,0,218,2005,1,0,0,0, + 220,2040,1,0,0,0,222,2089,1,0,0,0,224,2101,1,0,0,0,226,2113,1,0,0,0,228, + 2115,1,0,0,0,230,2117,1,0,0,0,232,2119,1,0,0,0,234,2121,1,0,0,0,236,2123, + 1,0,0,0,238,2133,1,0,0,0,240,2143,1,0,0,0,242,2159,1,0,0,0,244,2212,1, + 0,0,0,246,2214,1,0,0,0,248,2216,1,0,0,0,250,2230,1,0,0,0,252,2244,1,0, + 0,0,254,2259,1,0,0,0,256,2261,1,0,0,0,258,2276,1,0,0,0,260,2278,1,0,0, + 0,262,2293,1,0,0,0,264,2295,1,0,0,0,266,2315,1,0,0,0,268,2325,1,0,0,0, + 270,2354,1,0,0,0,272,2367,1,0,0,0,274,2375,1,0,0,0,276,2389,1,0,0,0,278, + 2391,1,0,0,0,280,2411,1,0,0,0,282,2469,1,0,0,0,284,2471,1,0,0,0,286,2478, + 1,0,0,0,288,2490,1,0,0,0,290,2492,1,0,0,0,292,2494,1,0,0,0,294,2515,1, + 0,0,0,296,2522,1,0,0,0,298,2547,1,0,0,0,300,2558,1,0,0,0,302,2645,1,0, + 0,0,304,2647,1,0,0,0,306,2662,1,0,0,0,308,2664,1,0,0,0,310,2701,1,0,0, + 0,312,2703,1,0,0,0,314,2712,1,0,0,0,316,2736,1,0,0,0,318,2760,1,0,0,0, + 320,2768,1,0,0,0,322,2796,1,0,0,0,324,2813,1,0,0,0,326,2827,1,0,0,0,328, + 2831,1,0,0,0,330,2833,1,0,0,0,332,2838,1,0,0,0,334,2844,1,0,0,0,336,2846, + 1,0,0,0,338,2848,1,0,0,0,340,2850,1,0,0,0,342,2857,1,0,0,0,344,2859,1, + 0,0,0,346,2861,1,0,0,0,348,2863,1,0,0,0,350,2865,1,0,0,0,352,363,3,2, + 1,0,353,355,5,171,0,0,354,353,1,0,0,0,354,355,1,0,0,0,355,356,1,0,0,0, + 356,358,5,1,0,0,357,359,5,171,0,0,358,357,1,0,0,0,358,359,1,0,0,0,359, + 360,1,0,0,0,360,362,3,2,1,0,361,354,1,0,0,0,362,365,1,0,0,0,363,361,1, + 0,0,0,363,364,1,0,0,0,364,367,1,0,0,0,365,363,1,0,0,0,366,368,5,171,0, + 0,367,366,1,0,0,0,367,368,1,0,0,0,368,369,1,0,0,0,369,370,5,0,0,1,370, + 1,1,0,0,0,371,373,3,108,54,0,372,371,1,0,0,0,372,373,1,0,0,0,373,375, + 1,0,0,0,374,376,5,171,0,0,375,374,1,0,0,0,375,376,1,0,0,0,376,377,1,0, + 0,0,377,382,3,4,2,0,378,380,5,171,0,0,379,378,1,0,0,0,379,380,1,0,0,0, + 380,381,1,0,0,0,381,383,5,1,0,0,382,379,1,0,0,0,382,383,1,0,0,0,383,3, + 1,0,0,0,384,408,3,122,61,0,385,408,3,46,23,0,386,408,3,48,24,0,387,408, + 3,50,25,0,388,408,3,52,26,0,389,408,3,56,28,0,390,408,3,58,29,0,391,408, + 3,60,30,0,392,408,3,76,38,0,393,408,3,78,39,0,394,408,3,6,3,0,395,408, + 3,12,6,0,396,408,3,14,7,0,397,408,3,30,15,0,398,408,3,34,17,0,399,408, + 3,32,16,0,400,408,3,114,57,0,401,408,3,116,58,0,402,408,3,16,8,0,403, + 408,3,18,9,0,404,408,3,20,10,0,405,408,3,26,13,0,406,408,3,28,14,0,407, + 384,1,0,0,0,407,385,1,0,0,0,407,386,1,0,0,0,407,387,1,0,0,0,407,388,1, + 0,0,0,407,389,1,0,0,0,407,390,1,0,0,0,407,391,1,0,0,0,407,392,1,0,0,0, + 407,393,1,0,0,0,407,394,1,0,0,0,407,395,1,0,0,0,407,396,1,0,0,0,407,397, + 1,0,0,0,407,398,1,0,0,0,407,399,1,0,0,0,407,400,1,0,0,0,407,401,1,0,0, + 0,407,402,1,0,0,0,407,403,1,0,0,0,407,404,1,0,0,0,407,405,1,0,0,0,407, + 406,1,0,0,0,408,5,1,0,0,0,409,410,5,66,0,0,410,411,5,171,0,0,411,420, + 3,340,170,0,412,414,5,171,0,0,413,412,1,0,0,0,413,414,1,0,0,0,414,415, + 1,0,0,0,415,417,3,8,4,0,416,418,5,171,0,0,417,416,1,0,0,0,417,418,1,0, + 0,0,418,421,1,0,0,0,419,421,5,171,0,0,420,413,1,0,0,0,420,419,1,0,0,0, + 421,422,1,0,0,0,422,423,5,88,0,0,423,424,5,171,0,0,424,429,3,10,5,0,425, + 427,5,171,0,0,426,425,1,0,0,0,426,427,1,0,0,0,427,428,1,0,0,0,428,430, + 3,42,21,0,429,426,1,0,0,0,429,430,1,0,0,0,430,7,1,0,0,0,431,433,5,2,0, + 0,432,434,5,171,0,0,433,432,1,0,0,0,433,434,1,0,0,0,434,435,1,0,0,0,435, + 446,3,340,170,0,436,438,5,171,0,0,437,436,1,0,0,0,437,438,1,0,0,0,438, + 439,1,0,0,0,439,441,5,3,0,0,440,442,5,171,0,0,441,440,1,0,0,0,441,442, + 1,0,0,0,442,443,1,0,0,0,443,445,3,340,170,0,444,437,1,0,0,0,445,448,1, + 0,0,0,446,444,1,0,0,0,446,447,1,0,0,0,447,450,1,0,0,0,448,446,1,0,0,0, + 449,451,5,171,0,0,450,449,1,0,0,0,450,451,1,0,0,0,451,452,1,0,0,0,452, + 453,5,4,0,0,453,9,1,0,0,0,454,474,3,40,20,0,455,457,5,2,0,0,456,458,5, + 171,0,0,457,456,1,0,0,0,457,458,1,0,0,0,458,459,1,0,0,0,459,461,3,122, + 61,0,460,462,5,171,0,0,461,460,1,0,0,0,461,462,1,0,0,0,462,463,1,0,0, + 0,463,464,5,4,0,0,464,474,1,0,0,0,465,474,3,326,163,0,466,467,3,326,163, + 0,467,469,5,5,0,0,468,470,5,171,0,0,469,468,1,0,0,0,469,470,1,0,0,0,470, + 471,1,0,0,0,471,472,3,340,170,0,472,474,1,0,0,0,473,454,1,0,0,0,473,455, + 1,0,0,0,473,465,1,0,0,0,473,466,1,0,0,0,474,11,1,0,0,0,475,476,5,66,0, + 0,476,477,5,171,0,0,477,478,3,340,170,0,478,479,5,171,0,0,479,480,5,88, + 0,0,480,481,5,171,0,0,481,483,5,2,0,0,482,484,5,171,0,0,483,482,1,0,0, + 0,483,484,1,0,0,0,484,485,1,0,0,0,485,496,5,157,0,0,486,488,5,171,0,0, + 487,486,1,0,0,0,487,488,1,0,0,0,488,489,1,0,0,0,489,491,5,3,0,0,490,492, + 5,171,0,0,491,490,1,0,0,0,491,492,1,0,0,0,492,493,1,0,0,0,493,495,5,157, + 0,0,494,487,1,0,0,0,495,498,1,0,0,0,496,494,1,0,0,0,496,497,1,0,0,0,497, + 499,1,0,0,0,498,496,1,0,0,0,499,500,5,4,0,0,500,501,5,171,0,0,501,502, + 5,56,0,0,502,503,5,171,0,0,503,504,5,61,0,0,504,13,1,0,0,0,505,506,5, + 66,0,0,506,507,5,171,0,0,507,509,5,2,0,0,508,510,5,171,0,0,509,508,1, + 0,0,0,509,510,1,0,0,0,510,511,1,0,0,0,511,513,3,122,61,0,512,514,5,171, + 0,0,513,512,1,0,0,0,513,514,1,0,0,0,514,515,1,0,0,0,515,516,5,4,0,0,516, + 517,5,171,0,0,517,518,5,137,0,0,518,519,5,171,0,0,519,524,5,157,0,0,520, + 522,5,171,0,0,521,520,1,0,0,0,521,522,1,0,0,0,522,523,1,0,0,0,523,525, + 3,42,21,0,524,521,1,0,0,0,524,525,1,0,0,0,525,15,1,0,0,0,526,527,5,84, + 0,0,527,528,5,171,0,0,528,529,5,70,0,0,529,530,5,171,0,0,530,535,5,157, + 0,0,531,533,5,171,0,0,532,531,1,0,0,0,532,533,1,0,0,0,533,534,1,0,0,0, + 534,536,3,42,21,0,535,532,1,0,0,0,535,536,1,0,0,0,536,17,1,0,0,0,537, + 538,5,94,0,0,538,539,5,171,0,0,539,540,5,70,0,0,540,541,5,171,0,0,541, + 542,5,157,0,0,542,19,1,0,0,0,543,544,5,54,0,0,544,545,5,171,0,0,545,550, + 5,157,0,0,546,547,5,171,0,0,547,548,5,51,0,0,548,549,5,171,0,0,549,551, + 3,340,170,0,550,546,1,0,0,0,550,551,1,0,0,0,551,552,1,0,0,0,552,553,5, + 171,0,0,553,555,5,2,0,0,554,556,5,171,0,0,555,554,1,0,0,0,555,556,1,0, + 0,0,556,557,1,0,0,0,557,558,5,71,0,0,558,559,5,171,0,0,559,568,3,342, + 171,0,560,562,5,171,0,0,561,560,1,0,0,0,561,562,1,0,0,0,562,563,1,0,0, + 0,563,565,5,3,0,0,564,566,5,171,0,0,565,564,1,0,0,0,565,566,1,0,0,0,566, + 567,1,0,0,0,567,569,3,24,12,0,568,561,1,0,0,0,568,569,1,0,0,0,569,571, + 1,0,0,0,570,572,5,171,0,0,571,570,1,0,0,0,571,572,1,0,0,0,572,573,1,0, + 0,0,573,574,5,4,0,0,574,21,1,0,0,0,575,577,3,342,171,0,576,578,5,171, + 0,0,577,576,1,0,0,0,577,578,1,0,0,0,578,579,1,0,0,0,579,581,5,6,0,0,580, + 582,5,171,0,0,581,580,1,0,0,0,581,582,1,0,0,0,582,583,1,0,0,0,583,584, + 3,288,144,0,584,23,1,0,0,0,585,596,3,22,11,0,586,588,5,171,0,0,587,586, + 1,0,0,0,587,588,1,0,0,0,588,589,1,0,0,0,589,591,5,3,0,0,590,592,5,171, + 0,0,591,590,1,0,0,0,591,592,1,0,0,0,592,593,1,0,0,0,593,595,3,22,11,0, + 594,587,1,0,0,0,595,598,1,0,0,0,596,594,1,0,0,0,596,597,1,0,0,0,597,25, + 1,0,0,0,598,596,1,0,0,0,599,600,5,76,0,0,600,601,5,171,0,0,601,602,3, + 340,170,0,602,27,1,0,0,0,603,604,5,143,0,0,604,605,5,171,0,0,605,606, + 3,340,170,0,606,29,1,0,0,0,607,608,5,57,0,0,608,609,5,171,0,0,609,611, + 3,342,171,0,610,612,5,171,0,0,611,610,1,0,0,0,611,612,1,0,0,0,612,613, + 1,0,0,0,613,615,5,6,0,0,614,616,5,171,0,0,615,614,1,0,0,0,615,616,1,0, + 0,0,616,617,1,0,0,0,617,618,3,234,117,0,618,31,1,0,0,0,619,620,5,62,0, + 0,620,621,5,171,0,0,621,622,5,115,0,0,622,623,5,171,0,0,623,624,5,135, + 0,0,624,625,5,171,0,0,625,626,3,340,170,0,626,627,5,171,0,0,627,628,5, + 99,0,0,628,629,5,171,0,0,629,630,5,157,0,0,630,33,1,0,0,0,631,632,5,68, + 0,0,632,633,5,171,0,0,633,634,5,104,0,0,634,635,5,171,0,0,635,637,3,304, + 152,0,636,638,5,171,0,0,637,636,1,0,0,0,637,638,1,0,0,0,638,639,1,0,0, + 0,639,641,5,2,0,0,640,642,5,171,0,0,641,640,1,0,0,0,641,642,1,0,0,0,642, + 644,1,0,0,0,643,645,3,36,18,0,644,643,1,0,0,0,644,645,1,0,0,0,645,647, + 1,0,0,0,646,648,5,171,0,0,647,646,1,0,0,0,647,648,1,0,0,0,648,650,1,0, + 0,0,649,651,3,38,19,0,650,649,1,0,0,0,650,651,1,0,0,0,651,662,1,0,0,0, + 652,654,5,171,0,0,653,652,1,0,0,0,653,654,1,0,0,0,654,655,1,0,0,0,655, + 657,5,3,0,0,656,658,5,171,0,0,657,656,1,0,0,0,657,658,1,0,0,0,658,659, + 1,0,0,0,659,661,3,38,19,0,660,653,1,0,0,0,661,664,1,0,0,0,662,660,1,0, + 0,0,662,663,1,0,0,0,663,666,1,0,0,0,664,662,1,0,0,0,665,667,5,171,0,0, + 666,665,1,0,0,0,666,667,1,0,0,0,667,668,1,0,0,0,668,669,5,4,0,0,669,670, + 5,171,0,0,670,671,5,51,0,0,671,672,5,171,0,0,672,673,3,234,117,0,673, + 35,1,0,0,0,674,685,3,342,171,0,675,677,5,171,0,0,676,675,1,0,0,0,676, + 677,1,0,0,0,677,678,1,0,0,0,678,680,5,3,0,0,679,681,5,171,0,0,680,679, + 1,0,0,0,680,681,1,0,0,0,681,682,1,0,0,0,682,684,3,342,171,0,683,676,1, + 0,0,0,684,687,1,0,0,0,685,683,1,0,0,0,685,686,1,0,0,0,686,37,1,0,0,0, + 687,685,1,0,0,0,688,690,3,342,171,0,689,691,5,171,0,0,690,689,1,0,0,0, + 690,691,1,0,0,0,691,692,1,0,0,0,692,693,5,156,0,0,693,695,5,6,0,0,694, + 696,5,171,0,0,695,694,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,698, + 3,288,144,0,698,39,1,0,0,0,699,701,5,7,0,0,700,702,5,171,0,0,701,700, + 1,0,0,0,701,702,1,0,0,0,702,703,1,0,0,0,703,714,5,157,0,0,704,706,5,171, + 0,0,705,704,1,0,0,0,705,706,1,0,0,0,706,707,1,0,0,0,707,709,5,3,0,0,708, + 710,5,171,0,0,709,708,1,0,0,0,709,710,1,0,0,0,710,711,1,0,0,0,711,713, + 5,157,0,0,712,705,1,0,0,0,713,716,1,0,0,0,714,712,1,0,0,0,714,715,1,0, + 0,0,715,717,1,0,0,0,716,714,1,0,0,0,717,733,5,8,0,0,718,733,5,157,0,0, + 719,721,5,89,0,0,720,722,5,171,0,0,721,720,1,0,0,0,721,722,1,0,0,0,722, + 723,1,0,0,0,723,725,5,2,0,0,724,726,5,171,0,0,725,724,1,0,0,0,725,726, + 1,0,0,0,726,727,1,0,0,0,727,729,5,157,0,0,728,730,5,171,0,0,729,728,1, + 0,0,0,729,730,1,0,0,0,730,731,1,0,0,0,731,733,5,4,0,0,732,699,1,0,0,0, + 732,718,1,0,0,0,732,719,1,0,0,0,733,41,1,0,0,0,734,736,5,2,0,0,735,737, + 5,171,0,0,736,735,1,0,0,0,736,737,1,0,0,0,737,738,1,0,0,0,738,740,3,24, + 12,0,739,741,5,171,0,0,740,739,1,0,0,0,740,741,1,0,0,0,741,742,1,0,0, + 0,742,743,5,4,0,0,743,43,1,0,0,0,744,745,5,95,0,0,745,746,5,171,0,0,746, + 747,5,112,0,0,747,748,5,171,0,0,748,749,5,82,0,0,749,45,1,0,0,0,750,751, + 5,68,0,0,751,752,5,171,0,0,752,753,5,111,0,0,753,754,5,171,0,0,754,755, + 5,135,0,0,755,759,5,171,0,0,756,757,3,44,22,0,757,758,5,171,0,0,758,760, + 1,0,0,0,759,756,1,0,0,0,759,760,1,0,0,0,760,761,1,0,0,0,761,763,3,340, + 170,0,762,764,5,171,0,0,763,762,1,0,0,0,763,764,1,0,0,0,764,765,1,0,0, + 0,765,767,5,2,0,0,766,768,5,171,0,0,767,766,1,0,0,0,767,768,1,0,0,0,768, + 769,1,0,0,0,769,771,3,96,48,0,770,772,5,171,0,0,771,770,1,0,0,0,771,772, + 1,0,0,0,772,773,1,0,0,0,773,775,5,3,0,0,774,776,5,171,0,0,775,774,1,0, + 0,0,775,776,1,0,0,0,776,777,1,0,0,0,777,778,3,100,50,0,778,780,1,0,0, + 0,779,781,5,171,0,0,780,779,1,0,0,0,780,781,1,0,0,0,781,782,1,0,0,0,782, + 783,5,4,0,0,783,47,1,0,0,0,784,785,5,68,0,0,785,786,5,171,0,0,786,787, + 5,86,0,0,787,788,5,171,0,0,788,789,5,111,0,0,789,790,5,171,0,0,790,791, + 5,135,0,0,791,792,5,171,0,0,792,793,3,340,170,0,793,794,5,171,0,0,794, + 795,5,51,0,0,795,796,5,171,0,0,796,797,3,340,170,0,797,799,3,320,160, + 0,798,800,5,171,0,0,799,798,1,0,0,0,799,800,1,0,0,0,800,801,1,0,0,0,801, + 803,5,2,0,0,802,804,5,171,0,0,803,802,1,0,0,0,803,804,1,0,0,0,804,805, + 1,0,0,0,805,807,3,100,50,0,806,808,5,171,0,0,807,806,1,0,0,0,807,808, + 1,0,0,0,808,809,1,0,0,0,809,810,5,4,0,0,810,49,1,0,0,0,811,812,5,68,0, + 0,812,813,5,171,0,0,813,814,5,125,0,0,814,815,5,171,0,0,815,816,5,135, + 0,0,816,820,5,171,0,0,817,818,3,44,22,0,818,819,5,171,0,0,819,821,1,0, + 0,0,820,817,1,0,0,0,820,821,1,0,0,0,821,822,1,0,0,0,822,824,3,340,170, + 0,823,825,5,171,0,0,824,823,1,0,0,0,824,825,1,0,0,0,825,826,1,0,0,0,826, + 828,5,2,0,0,827,829,5,171,0,0,828,827,1,0,0,0,828,829,1,0,0,0,829,830, + 1,0,0,0,830,832,3,54,27,0,831,833,5,171,0,0,832,831,1,0,0,0,832,833,1, + 0,0,0,833,842,1,0,0,0,834,836,5,3,0,0,835,837,5,171,0,0,836,835,1,0,0, + 0,836,837,1,0,0,0,837,838,1,0,0,0,838,840,3,96,48,0,839,841,5,171,0,0, + 840,839,1,0,0,0,840,841,1,0,0,0,841,843,1,0,0,0,842,834,1,0,0,0,842,843, + 1,0,0,0,843,852,1,0,0,0,844,846,5,3,0,0,845,847,5,171,0,0,846,845,1,0, + 0,0,846,847,1,0,0,0,847,848,1,0,0,0,848,850,3,342,171,0,849,851,5,171, + 0,0,850,849,1,0,0,0,850,851,1,0,0,0,851,853,1,0,0,0,852,844,1,0,0,0,852, + 853,1,0,0,0,853,854,1,0,0,0,854,855,5,4,0,0,855,51,1,0,0,0,856,857,5, + 68,0,0,857,858,5,171,0,0,858,859,5,125,0,0,859,860,5,171,0,0,860,861, + 5,135,0,0,861,862,5,171,0,0,862,863,5,91,0,0,863,867,5,171,0,0,864,865, + 3,44,22,0,865,866,5,171,0,0,866,868,1,0,0,0,867,864,1,0,0,0,867,868,1, + 0,0,0,868,869,1,0,0,0,869,871,3,340,170,0,870,872,5,171,0,0,871,870,1, + 0,0,0,871,872,1,0,0,0,872,873,1,0,0,0,873,875,5,2,0,0,874,876,5,171,0, + 0,875,874,1,0,0,0,875,876,1,0,0,0,876,877,1,0,0,0,877,886,3,54,27,0,878, + 880,5,171,0,0,879,878,1,0,0,0,879,880,1,0,0,0,880,881,1,0,0,0,881,883, + 5,3,0,0,882,884,5,171,0,0,883,882,1,0,0,0,883,884,1,0,0,0,884,885,1,0, + 0,0,885,887,3,54,27,0,886,879,1,0,0,0,887,888,1,0,0,0,888,886,1,0,0,0, + 888,889,1,0,0,0,889,891,1,0,0,0,890,892,5,171,0,0,891,890,1,0,0,0,891, + 892,1,0,0,0,892,901,1,0,0,0,893,895,5,3,0,0,894,896,5,171,0,0,895,894, + 1,0,0,0,895,896,1,0,0,0,896,897,1,0,0,0,897,899,3,96,48,0,898,900,5,171, + 0,0,899,898,1,0,0,0,899,900,1,0,0,0,900,902,1,0,0,0,901,893,1,0,0,0,901, + 902,1,0,0,0,902,911,1,0,0,0,903,905,5,3,0,0,904,906,5,171,0,0,905,904, + 1,0,0,0,905,906,1,0,0,0,906,907,1,0,0,0,907,909,3,342,171,0,908,910,5, + 171,0,0,909,908,1,0,0,0,909,910,1,0,0,0,910,912,1,0,0,0,911,903,1,0,0, + 0,911,912,1,0,0,0,912,913,1,0,0,0,913,914,5,4,0,0,914,53,1,0,0,0,915, + 916,5,88,0,0,916,917,5,171,0,0,917,918,3,340,170,0,918,919,5,171,0,0, + 919,920,5,137,0,0,920,921,5,171,0,0,921,922,3,340,170,0,922,55,1,0,0, + 0,923,924,5,68,0,0,924,925,5,171,0,0,925,926,5,123,0,0,926,930,5,171, + 0,0,927,928,3,44,22,0,928,929,5,171,0,0,929,931,1,0,0,0,930,927,1,0,0, + 0,930,931,1,0,0,0,931,932,1,0,0,0,932,933,3,340,170,0,933,57,1,0,0,0, + 934,935,5,68,0,0,935,936,5,171,0,0,936,937,5,130,0,0,937,941,5,171,0, + 0,938,939,3,44,22,0,939,940,5,171,0,0,940,942,1,0,0,0,941,938,1,0,0,0, + 941,942,1,0,0,0,942,943,1,0,0,0,943,948,3,340,170,0,944,945,5,171,0,0, + 945,947,3,62,31,0,946,944,1,0,0,0,947,950,1,0,0,0,948,946,1,0,0,0,948, + 949,1,0,0,0,949,59,1,0,0,0,950,948,1,0,0,0,951,952,5,68,0,0,952,953,5, + 171,0,0,953,954,5,140,0,0,954,955,5,171,0,0,955,956,3,340,170,0,956,957, + 5,171,0,0,957,958,5,51,0,0,958,959,5,171,0,0,959,961,3,102,51,0,960,962, + 5,171,0,0,961,960,1,0,0,0,961,962,1,0,0,0,962,61,1,0,0,0,963,969,3,64, + 32,0,964,969,3,66,33,0,965,969,3,68,34,0,966,969,3,70,35,0,967,969,3, + 72,36,0,968,963,1,0,0,0,968,964,1,0,0,0,968,965,1,0,0,0,968,966,1,0,0, + 0,968,967,1,0,0,0,969,63,1,0,0,0,970,971,5,97,0,0,971,974,5,171,0,0,972, + 973,5,56,0,0,973,975,5,171,0,0,974,972,1,0,0,0,974,975,1,0,0,0,975,977, + 1,0,0,0,976,978,5,154,0,0,977,976,1,0,0,0,977,978,1,0,0,0,978,979,1,0, + 0,0,979,980,3,336,168,0,980,65,1,0,0,0,981,982,5,110,0,0,982,983,5,171, + 0,0,983,991,5,108,0,0,984,985,5,108,0,0,985,987,5,171,0,0,986,988,5,154, + 0,0,987,986,1,0,0,0,987,988,1,0,0,0,988,989,1,0,0,0,989,991,3,336,168, + 0,990,981,1,0,0,0,990,984,1,0,0,0,991,67,1,0,0,0,992,993,5,110,0,0,993, + 994,5,171,0,0,994,1002,5,106,0,0,995,996,5,106,0,0,996,998,5,171,0,0, + 997,999,5,154,0,0,998,997,1,0,0,0,998,999,1,0,0,0,999,1000,1,0,0,0,1000, + 1002,3,336,168,0,1001,992,1,0,0,0,1001,995,1,0,0,0,1002,69,1,0,0,0,1003, + 1004,5,133,0,0,1004,1007,5,171,0,0,1005,1006,5,146,0,0,1006,1008,5,171, + 0,0,1007,1005,1,0,0,0,1007,1008,1,0,0,0,1008,1010,1,0,0,0,1009,1011,5, + 154,0,0,1010,1009,1,0,0,0,1010,1011,1,0,0,0,1011,1012,1,0,0,0,1012,1013, + 3,336,168,0,1013,71,1,0,0,0,1014,1015,5,110,0,0,1015,1017,5,171,0,0,1016, + 1014,1,0,0,0,1016,1017,1,0,0,0,1017,1018,1,0,0,0,1018,1019,5,69,0,0,1019, + 73,1,0,0,0,1020,1021,5,95,0,0,1021,1022,5,171,0,0,1022,1023,5,82,0,0, + 1023,75,1,0,0,0,1024,1025,5,78,0,0,1025,1026,5,171,0,0,1026,1027,7,0, + 0,0,1027,1031,5,171,0,0,1028,1029,3,74,37,0,1029,1030,5,171,0,0,1030, + 1032,1,0,0,0,1031,1028,1,0,0,0,1031,1032,1,0,0,0,1032,1033,1,0,0,0,1033, + 1034,3,340,170,0,1034,77,1,0,0,0,1035,1036,5,49,0,0,1036,1037,5,171,0, + 0,1037,1038,5,135,0,0,1038,1039,5,171,0,0,1039,1040,3,340,170,0,1040, + 1041,5,171,0,0,1041,1042,3,80,40,0,1042,79,1,0,0,0,1043,1048,3,82,41, + 0,1044,1048,3,86,43,0,1045,1048,3,88,44,0,1046,1048,3,90,45,0,1047,1043, + 1,0,0,0,1047,1044,1,0,0,0,1047,1045,1,0,0,0,1047,1046,1,0,0,0,1048,81, + 1,0,0,0,1049,1050,5,47,0,0,1050,1051,5,171,0,0,1051,1052,3,334,167,0, + 1052,1053,5,171,0,0,1053,1056,3,102,51,0,1054,1055,5,171,0,0,1055,1057, + 3,84,42,0,1056,1054,1,0,0,0,1056,1057,1,0,0,0,1057,83,1,0,0,0,1058,1059, + 5,72,0,0,1059,1060,5,171,0,0,1060,1061,3,234,117,0,1061,85,1,0,0,0,1062, + 1063,5,78,0,0,1063,1064,5,171,0,0,1064,1065,3,334,167,0,1065,87,1,0,0, + 0,1066,1067,5,126,0,0,1067,1068,5,171,0,0,1068,1069,5,137,0,0,1069,1070, + 5,171,0,0,1070,1071,3,340,170,0,1071,89,1,0,0,0,1072,1073,5,126,0,0,1073, + 1074,5,171,0,0,1074,1075,3,334,167,0,1075,1076,5,171,0,0,1076,1077,5, + 137,0,0,1077,1078,5,171,0,0,1078,1079,3,334,167,0,1079,91,1,0,0,0,1080, + 1091,3,94,47,0,1081,1083,5,171,0,0,1082,1081,1,0,0,0,1082,1083,1,0,0, + 0,1083,1084,1,0,0,0,1084,1086,5,3,0,0,1085,1087,5,171,0,0,1086,1085,1, + 0,0,0,1086,1087,1,0,0,0,1087,1088,1,0,0,0,1088,1090,3,94,47,0,1089,1082, + 1,0,0,0,1090,1093,1,0,0,0,1091,1089,1,0,0,0,1091,1092,1,0,0,0,1092,93, + 1,0,0,0,1093,1091,1,0,0,0,1094,1095,3,334,167,0,1095,1096,5,171,0,0,1096, + 1097,3,102,51,0,1097,95,1,0,0,0,1098,1109,3,98,49,0,1099,1101,5,171,0, + 0,1100,1099,1,0,0,0,1100,1101,1,0,0,0,1101,1102,1,0,0,0,1102,1104,5,3, + 0,0,1103,1105,5,171,0,0,1104,1103,1,0,0,0,1104,1105,1,0,0,0,1105,1106, + 1,0,0,0,1106,1108,3,98,49,0,1107,1100,1,0,0,0,1108,1111,1,0,0,0,1109, + 1107,1,0,0,0,1109,1110,1,0,0,0,1110,97,1,0,0,0,1111,1109,1,0,0,0,1112, + 1115,3,94,47,0,1113,1114,5,171,0,0,1114,1116,3,84,42,0,1115,1113,1,0, + 0,0,1115,1116,1,0,0,0,1116,99,1,0,0,0,1117,1118,5,120,0,0,1118,1119,5, + 171,0,0,1119,1121,5,101,0,0,1120,1122,5,171,0,0,1121,1120,1,0,0,0,1121, + 1122,1,0,0,0,1122,1123,1,0,0,0,1123,1125,5,2,0,0,1124,1126,5,171,0,0, + 1125,1124,1,0,0,0,1125,1126,1,0,0,0,1126,1127,1,0,0,0,1127,1129,3,334, + 167,0,1128,1130,5,171,0,0,1129,1128,1,0,0,0,1129,1130,1,0,0,0,1130,1131, + 1,0,0,0,1131,1132,5,4,0,0,1132,101,1,0,0,0,1133,1134,6,51,-1,0,1134,1208, + 3,342,171,0,1135,1137,5,141,0,0,1136,1138,5,171,0,0,1137,1136,1,0,0,0, + 1137,1138,1,0,0,0,1138,1139,1,0,0,0,1139,1141,5,2,0,0,1140,1142,5,171, + 0,0,1141,1140,1,0,0,0,1141,1142,1,0,0,0,1142,1143,1,0,0,0,1143,1145,3, + 92,46,0,1144,1146,5,171,0,0,1145,1144,1,0,0,0,1145,1146,1,0,0,0,1146, + 1147,1,0,0,0,1147,1148,5,4,0,0,1148,1208,1,0,0,0,1149,1151,3,342,171, + 0,1150,1152,5,171,0,0,1151,1150,1,0,0,0,1151,1152,1,0,0,0,1152,1153,1, + 0,0,0,1153,1155,5,2,0,0,1154,1156,5,171,0,0,1155,1154,1,0,0,0,1155,1156, + 1,0,0,0,1156,1157,1,0,0,0,1157,1159,3,92,46,0,1158,1160,5,171,0,0,1159, + 1158,1,0,0,0,1159,1160,1,0,0,0,1160,1161,1,0,0,0,1161,1162,5,4,0,0,1162, + 1208,1,0,0,0,1163,1165,3,342,171,0,1164,1166,5,171,0,0,1165,1164,1,0, + 0,0,1165,1166,1,0,0,0,1166,1167,1,0,0,0,1167,1169,5,2,0,0,1168,1170,5, + 171,0,0,1169,1168,1,0,0,0,1169,1170,1,0,0,0,1170,1171,1,0,0,0,1171,1173, + 3,102,51,0,1172,1174,5,171,0,0,1173,1172,1,0,0,0,1173,1174,1,0,0,0,1174, + 1175,1,0,0,0,1175,1177,5,3,0,0,1176,1178,5,171,0,0,1177,1176,1,0,0,0, + 1177,1178,1,0,0,0,1178,1179,1,0,0,0,1179,1181,3,102,51,0,1180,1182,5, + 171,0,0,1181,1180,1,0,0,0,1181,1182,1,0,0,0,1182,1183,1,0,0,0,1183,1184, + 5,4,0,0,1184,1208,1,0,0,0,1185,1187,5,150,0,0,1186,1188,5,171,0,0,1187, + 1186,1,0,0,0,1187,1188,1,0,0,0,1188,1189,1,0,0,0,1189,1191,5,2,0,0,1190, + 1192,5,171,0,0,1191,1190,1,0,0,0,1191,1192,1,0,0,0,1192,1193,1,0,0,0, + 1193,1195,3,336,168,0,1194,1196,5,171,0,0,1195,1194,1,0,0,0,1195,1196, + 1,0,0,0,1196,1197,1,0,0,0,1197,1199,5,3,0,0,1198,1200,5,171,0,0,1199, + 1198,1,0,0,0,1199,1200,1,0,0,0,1200,1201,1,0,0,0,1201,1203,3,336,168, + 0,1202,1204,5,171,0,0,1203,1202,1,0,0,0,1203,1204,1,0,0,0,1204,1205,1, + 0,0,0,1205,1206,5,4,0,0,1206,1208,1,0,0,0,1207,1133,1,0,0,0,1207,1135, + 1,0,0,0,1207,1149,1,0,0,0,1207,1163,1,0,0,0,1207,1185,1,0,0,0,1208,1213, + 1,0,0,0,1209,1210,10,5,0,0,1210,1212,3,104,52,0,1211,1209,1,0,0,0,1212, + 1215,1,0,0,0,1213,1211,1,0,0,0,1213,1214,1,0,0,0,1214,103,1,0,0,0,1215, + 1213,1,0,0,0,1216,1220,3,106,53,0,1217,1219,3,106,53,0,1218,1217,1,0, + 0,0,1219,1222,1,0,0,0,1220,1218,1,0,0,0,1220,1221,1,0,0,0,1221,105,1, + 0,0,0,1222,1220,1,0,0,0,1223,1225,5,7,0,0,1224,1226,3,336,168,0,1225, + 1224,1,0,0,0,1225,1226,1,0,0,0,1226,1227,1,0,0,0,1227,1228,5,8,0,0,1228, + 107,1,0,0,0,1229,1232,3,110,55,0,1230,1232,3,112,56,0,1231,1229,1,0,0, + 0,1231,1230,1,0,0,0,1232,109,1,0,0,0,1233,1234,5,83,0,0,1234,111,1,0, + 0,0,1235,1236,5,121,0,0,1236,113,1,0,0,0,1237,1238,5,55,0,0,1238,1239, + 5,171,0,0,1239,1251,5,138,0,0,1240,1241,5,55,0,0,1241,1242,5,171,0,0, + 1242,1243,5,138,0,0,1243,1244,5,171,0,0,1244,1245,5,124,0,0,1245,1246, + 5,171,0,0,1246,1251,5,116,0,0,1247,1251,5,63,0,0,1248,1251,5,128,0,0, + 1249,1251,5,60,0,0,1250,1237,1,0,0,0,1250,1240,1,0,0,0,1250,1247,1,0, + 0,0,1250,1248,1,0,0,0,1250,1249,1,0,0,0,1251,115,1,0,0,0,1252,1255,3, + 118,59,0,1253,1255,3,120,60,0,1254,1252,1,0,0,0,1254,1253,1,0,0,0,1255, + 117,1,0,0,0,1256,1257,5,103,0,0,1257,1258,5,171,0,0,1258,1259,5,85,0, + 0,1259,1262,5,171,0,0,1260,1263,5,157,0,0,1261,1263,3,326,163,0,1262, + 1260,1,0,0,0,1262,1261,1,0,0,0,1263,119,1,0,0,0,1264,1265,5,98,0,0,1265, + 1266,5,171,0,0,1266,1267,3,326,163,0,1267,121,1,0,0,0,1268,1270,3,124, + 62,0,1269,1271,5,171,0,0,1270,1269,1,0,0,0,1270,1271,1,0,0,0,1271,1273, + 1,0,0,0,1272,1268,1,0,0,0,1272,1273,1,0,0,0,1273,1274,1,0,0,0,1274,1275, + 3,128,64,0,1275,123,1,0,0,0,1276,1277,5,122,0,0,1277,1278,5,171,0,0,1278, + 1279,5,90,0,0,1279,1280,5,171,0,0,1280,1282,3,340,170,0,1281,1283,5,171, + 0,0,1282,1281,1,0,0,0,1282,1283,1,0,0,0,1283,1284,1,0,0,0,1284,1286,5, + 2,0,0,1285,1287,5,171,0,0,1286,1285,1,0,0,0,1286,1287,1,0,0,0,1287,1288, + 1,0,0,0,1288,1290,3,126,63,0,1289,1291,5,171,0,0,1290,1289,1,0,0,0,1290, + 1291,1,0,0,0,1291,1292,1,0,0,0,1292,1293,5,4,0,0,1293,125,1,0,0,0,1294, + 1305,3,148,74,0,1295,1297,5,171,0,0,1296,1295,1,0,0,0,1296,1297,1,0,0, + 0,1297,1298,1,0,0,0,1298,1300,5,3,0,0,1299,1301,5,171,0,0,1300,1299,1, + 0,0,0,1300,1301,1,0,0,0,1301,1302,1,0,0,0,1302,1304,3,148,74,0,1303,1296, + 1,0,0,0,1304,1307,1,0,0,0,1305,1303,1,0,0,0,1305,1306,1,0,0,0,1306,127, + 1,0,0,0,1307,1305,1,0,0,0,1308,1315,3,132,66,0,1309,1311,5,171,0,0,1310, + 1309,1,0,0,0,1310,1311,1,0,0,0,1311,1312,1,0,0,0,1312,1314,3,130,65,0, + 1313,1310,1,0,0,0,1314,1317,1,0,0,0,1315,1313,1,0,0,0,1315,1316,1,0,0, + 0,1316,1330,1,0,0,0,1317,1315,1,0,0,0,1318,1320,3,176,88,0,1319,1321, + 5,171,0,0,1320,1319,1,0,0,0,1320,1321,1,0,0,0,1321,1323,1,0,0,0,1322, + 1318,1,0,0,0,1323,1324,1,0,0,0,1324,1322,1,0,0,0,1324,1325,1,0,0,0,1325, + 1326,1,0,0,0,1326,1327,3,132,66,0,1327,1328,6,64,-1,0,1328,1330,1,0,0, + 0,1329,1308,1,0,0,0,1329,1322,1,0,0,0,1330,129,1,0,0,0,1331,1332,5,141, + 0,0,1332,1333,5,171,0,0,1333,1335,5,48,0,0,1334,1336,5,171,0,0,1335,1334, + 1,0,0,0,1335,1336,1,0,0,0,1336,1337,1,0,0,0,1337,1344,3,132,66,0,1338, + 1340,5,141,0,0,1339,1341,5,171,0,0,1340,1339,1,0,0,0,1340,1341,1,0,0, + 0,1341,1342,1,0,0,0,1342,1344,3,132,66,0,1343,1331,1,0,0,0,1343,1338, + 1,0,0,0,1344,131,1,0,0,0,1345,1348,3,134,67,0,1346,1348,3,136,68,0,1347, + 1345,1,0,0,0,1347,1346,1,0,0,0,1348,133,1,0,0,0,1349,1351,3,142,71,0, + 1350,1352,5,171,0,0,1351,1350,1,0,0,0,1351,1352,1,0,0,0,1352,1354,1,0, + 0,0,1353,1349,1,0,0,0,1354,1357,1,0,0,0,1355,1353,1,0,0,0,1355,1356,1, + 0,0,0,1356,1358,1,0,0,0,1357,1355,1,0,0,0,1358,1395,3,176,88,0,1359,1361, + 3,142,71,0,1360,1362,5,171,0,0,1361,1360,1,0,0,0,1361,1362,1,0,0,0,1362, + 1364,1,0,0,0,1363,1359,1,0,0,0,1364,1367,1,0,0,0,1365,1363,1,0,0,0,1365, + 1366,1,0,0,0,1366,1368,1,0,0,0,1367,1365,1,0,0,0,1368,1375,3,140,70,0, + 1369,1371,5,171,0,0,1370,1369,1,0,0,0,1370,1371,1,0,0,0,1371,1372,1,0, + 0,0,1372,1374,3,140,70,0,1373,1370,1,0,0,0,1374,1377,1,0,0,0,1375,1373, + 1,0,0,0,1375,1376,1,0,0,0,1376,1382,1,0,0,0,1377,1375,1,0,0,0,1378,1380, + 5,171,0,0,1379,1378,1,0,0,0,1379,1380,1,0,0,0,1380,1381,1,0,0,0,1381, + 1383,3,176,88,0,1382,1379,1,0,0,0,1382,1383,1,0,0,0,1383,1395,1,0,0,0, + 1384,1386,3,142,71,0,1385,1387,5,171,0,0,1386,1385,1,0,0,0,1386,1387, + 1,0,0,0,1387,1389,1,0,0,0,1388,1384,1,0,0,0,1389,1390,1,0,0,0,1390,1388, + 1,0,0,0,1390,1391,1,0,0,0,1391,1392,1,0,0,0,1392,1393,6,67,-1,0,1393, + 1395,1,0,0,0,1394,1355,1,0,0,0,1394,1365,1,0,0,0,1394,1388,1,0,0,0,1395, + 135,1,0,0,0,1396,1398,3,138,69,0,1397,1399,5,171,0,0,1398,1397,1,0,0, + 0,1398,1399,1,0,0,0,1399,1401,1,0,0,0,1400,1396,1,0,0,0,1401,1402,1,0, + 0,0,1402,1400,1,0,0,0,1402,1403,1,0,0,0,1403,1404,1,0,0,0,1404,1405,3, + 134,67,0,1405,137,1,0,0,0,1406,1408,3,142,71,0,1407,1409,5,171,0,0,1408, + 1407,1,0,0,0,1408,1409,1,0,0,0,1409,1411,1,0,0,0,1410,1406,1,0,0,0,1411, + 1414,1,0,0,0,1412,1410,1,0,0,0,1412,1413,1,0,0,0,1413,1421,1,0,0,0,1414, + 1412,1,0,0,0,1415,1417,3,140,70,0,1416,1418,5,171,0,0,1417,1416,1,0,0, + 0,1417,1418,1,0,0,0,1418,1420,1,0,0,0,1419,1415,1,0,0,0,1420,1423,1,0, + 0,0,1421,1419,1,0,0,0,1421,1422,1,0,0,0,1422,1424,1,0,0,0,1423,1421,1, + 0,0,0,1424,1425,3,174,87,0,1425,139,1,0,0,0,1426,1431,3,162,81,0,1427, + 1431,3,164,82,0,1428,1431,3,168,84,0,1429,1431,3,172,86,0,1430,1426,1, + 0,0,0,1430,1427,1,0,0,0,1430,1428,1,0,0,0,1430,1429,1,0,0,0,1431,141, + 1,0,0,0,1432,1437,3,154,77,0,1433,1437,3,160,80,0,1434,1437,3,146,73, + 0,1435,1437,3,144,72,0,1436,1432,1,0,0,0,1436,1433,1,0,0,0,1436,1434, + 1,0,0,0,1436,1435,1,0,0,0,1437,143,1,0,0,0,1438,1456,5,103,0,0,1439,1440, + 5,171,0,0,1440,1441,5,146,0,0,1441,1442,5,171,0,0,1442,1444,5,92,0,0, + 1443,1445,5,171,0,0,1444,1443,1,0,0,0,1444,1445,1,0,0,0,1445,1446,1,0, + 0,0,1446,1448,5,2,0,0,1447,1449,5,171,0,0,1448,1447,1,0,0,0,1448,1449, + 1,0,0,0,1449,1450,1,0,0,0,1450,1452,3,92,46,0,1451,1453,5,171,0,0,1452, + 1451,1,0,0,0,1452,1453,1,0,0,0,1453,1454,1,0,0,0,1454,1455,5,4,0,0,1455, + 1457,1,0,0,0,1456,1439,1,0,0,0,1456,1457,1,0,0,0,1457,1458,1,0,0,0,1458, + 1459,5,171,0,0,1459,1460,5,88,0,0,1460,1461,5,171,0,0,1461,1466,3,10, + 5,0,1462,1464,5,171,0,0,1463,1462,1,0,0,0,1463,1464,1,0,0,0,1464,1465, + 1,0,0,0,1465,1467,3,42,21,0,1466,1463,1,0,0,0,1466,1467,1,0,0,0,1467, + 1472,1,0,0,0,1468,1470,5,171,0,0,1469,1468,1,0,0,0,1469,1470,1,0,0,0, + 1470,1471,1,0,0,0,1471,1473,3,192,96,0,1472,1469,1,0,0,0,1472,1473,1, + 0,0,0,1473,145,1,0,0,0,1474,1476,3,124,62,0,1475,1477,5,171,0,0,1476, + 1475,1,0,0,0,1476,1477,1,0,0,0,1477,1479,1,0,0,0,1478,1474,1,0,0,0,1478, + 1479,1,0,0,0,1479,1480,1,0,0,0,1480,1481,5,57,0,0,1481,1482,5,171,0,0, + 1482,1487,3,302,151,0,1483,1485,5,171,0,0,1484,1483,1,0,0,0,1484,1485, + 1,0,0,0,1485,1486,1,0,0,0,1486,1488,3,192,96,0,1487,1484,1,0,0,0,1487, + 1488,1,0,0,0,1488,147,1,0,0,0,1489,1503,3,340,170,0,1490,1492,5,171,0, + 0,1491,1490,1,0,0,0,1491,1492,1,0,0,0,1492,1493,1,0,0,0,1493,1495,5,9, + 0,0,1494,1496,5,171,0,0,1495,1494,1,0,0,0,1495,1496,1,0,0,0,1496,1497, + 1,0,0,0,1497,1499,3,150,75,0,1498,1500,5,171,0,0,1499,1498,1,0,0,0,1499, + 1500,1,0,0,0,1500,1501,1,0,0,0,1501,1502,5,10,0,0,1502,1504,1,0,0,0,1503, + 1491,1,0,0,0,1503,1504,1,0,0,0,1504,149,1,0,0,0,1505,1516,3,152,76,0, + 1506,1508,5,171,0,0,1507,1506,1,0,0,0,1507,1508,1,0,0,0,1508,1509,1,0, + 0,0,1509,1511,5,3,0,0,1510,1512,5,171,0,0,1511,1510,1,0,0,0,1511,1512, + 1,0,0,0,1512,1513,1,0,0,0,1513,1515,3,152,76,0,1514,1507,1,0,0,0,1515, + 1518,1,0,0,0,1516,1514,1,0,0,0,1516,1517,1,0,0,0,1517,151,1,0,0,0,1518, + 1516,1,0,0,0,1519,1522,3,334,167,0,1520,1521,5,171,0,0,1521,1523,3,84, + 42,0,1522,1520,1,0,0,0,1522,1523,1,0,0,0,1523,1526,1,0,0,0,1524,1525, + 5,171,0,0,1525,1527,3,192,96,0,1526,1524,1,0,0,0,1526,1527,1,0,0,0,1527, + 153,1,0,0,0,1528,1529,5,117,0,0,1529,1531,5,171,0,0,1530,1528,1,0,0,0, + 1530,1531,1,0,0,0,1531,1532,1,0,0,0,1532,1534,5,105,0,0,1533,1535,5,171, + 0,0,1534,1533,1,0,0,0,1534,1535,1,0,0,0,1535,1536,1,0,0,0,1536,1539,3, + 194,97,0,1537,1538,5,171,0,0,1538,1540,3,192,96,0,1539,1537,1,0,0,0,1539, + 1540,1,0,0,0,1540,1543,1,0,0,0,1541,1542,5,171,0,0,1542,1544,3,156,78, + 0,1543,1541,1,0,0,0,1543,1544,1,0,0,0,1544,155,1,0,0,0,1545,1546,5,93, + 0,0,1546,1547,5,171,0,0,1547,1548,3,158,79,0,1548,157,1,0,0,0,1549,1550, + 6,79,-1,0,1550,1552,5,2,0,0,1551,1553,5,171,0,0,1552,1551,1,0,0,0,1552, + 1553,1,0,0,0,1553,1554,1,0,0,0,1554,1556,3,158,79,0,1555,1557,5,171,0, + 0,1556,1555,1,0,0,0,1556,1557,1,0,0,0,1557,1558,1,0,0,0,1558,1559,5,4, + 0,0,1559,1562,1,0,0,0,1560,1562,3,340,170,0,1561,1549,1,0,0,0,1561,1560, + 1,0,0,0,1562,1579,1,0,0,0,1563,1564,10,4,0,0,1564,1565,5,171,0,0,1565, + 1566,5,100,0,0,1566,1567,5,171,0,0,1567,1578,3,158,79,5,1568,1573,10, + 3,0,0,1569,1570,5,171,0,0,1570,1571,5,109,0,0,1571,1572,5,171,0,0,1572, + 1574,3,340,170,0,1573,1569,1,0,0,0,1574,1575,1,0,0,0,1575,1573,1,0,0, + 0,1575,1576,1,0,0,0,1576,1578,1,0,0,0,1577,1563,1,0,0,0,1577,1568,1,0, + 0,0,1578,1581,1,0,0,0,1579,1577,1,0,0,0,1579,1580,1,0,0,0,1580,159,1, + 0,0,0,1581,1579,1,0,0,0,1582,1584,5,142,0,0,1583,1585,5,171,0,0,1584, + 1583,1,0,0,0,1584,1585,1,0,0,0,1585,1586,1,0,0,0,1586,1587,3,234,117, + 0,1587,1588,5,171,0,0,1588,1589,5,51,0,0,1589,1590,5,171,0,0,1590,1591, + 3,326,163,0,1591,161,1,0,0,0,1592,1594,5,68,0,0,1593,1595,5,171,0,0,1594, + 1593,1,0,0,0,1594,1595,1,0,0,0,1595,1596,1,0,0,0,1596,1597,3,194,97,0, + 1597,163,1,0,0,0,1598,1600,5,107,0,0,1599,1601,5,171,0,0,1600,1599,1, + 0,0,0,1600,1601,1,0,0,0,1601,1602,1,0,0,0,1602,1607,3,194,97,0,1603,1604, + 5,171,0,0,1604,1606,3,166,83,0,1605,1603,1,0,0,0,1606,1609,1,0,0,0,1607, + 1605,1,0,0,0,1607,1608,1,0,0,0,1608,165,1,0,0,0,1609,1607,1,0,0,0,1610, + 1611,5,115,0,0,1611,1612,5,171,0,0,1612,1613,5,105,0,0,1613,1614,5,171, + 0,0,1614,1621,3,168,84,0,1615,1616,5,115,0,0,1616,1617,5,171,0,0,1617, + 1618,5,68,0,0,1618,1619,5,171,0,0,1619,1621,3,168,84,0,1620,1610,1,0, + 0,0,1620,1615,1,0,0,0,1621,167,1,0,0,0,1622,1624,5,131,0,0,1623,1625, + 5,171,0,0,1624,1623,1,0,0,0,1624,1625,1,0,0,0,1625,1626,1,0,0,0,1626, + 1637,3,170,85,0,1627,1629,5,171,0,0,1628,1627,1,0,0,0,1628,1629,1,0,0, + 0,1629,1630,1,0,0,0,1630,1632,5,3,0,0,1631,1633,5,171,0,0,1632,1631,1, + 0,0,0,1632,1633,1,0,0,0,1633,1634,1,0,0,0,1634,1636,3,170,85,0,1635,1628, + 1,0,0,0,1636,1639,1,0,0,0,1637,1635,1,0,0,0,1637,1638,1,0,0,0,1638,169, + 1,0,0,0,1639,1637,1,0,0,0,1640,1642,3,332,166,0,1641,1643,5,171,0,0,1642, + 1641,1,0,0,0,1642,1643,1,0,0,0,1643,1644,1,0,0,0,1644,1646,5,6,0,0,1645, + 1647,5,171,0,0,1646,1645,1,0,0,0,1646,1647,1,0,0,0,1647,1648,1,0,0,0, + 1648,1649,3,234,117,0,1649,171,1,0,0,0,1650,1651,5,76,0,0,1651,1653,5, + 171,0,0,1652,1650,1,0,0,0,1652,1653,1,0,0,0,1653,1654,1,0,0,0,1654,1656, + 5,73,0,0,1655,1657,5,171,0,0,1656,1655,1,0,0,0,1656,1657,1,0,0,0,1657, + 1658,1,0,0,0,1658,1669,3,234,117,0,1659,1661,5,171,0,0,1660,1659,1,0, + 0,0,1660,1661,1,0,0,0,1661,1662,1,0,0,0,1662,1664,5,3,0,0,1663,1665,5, + 171,0,0,1664,1663,1,0,0,0,1664,1665,1,0,0,0,1665,1666,1,0,0,0,1666,1668, + 3,234,117,0,1667,1660,1,0,0,0,1668,1671,1,0,0,0,1669,1667,1,0,0,0,1669, + 1670,1,0,0,0,1670,173,1,0,0,0,1671,1669,1,0,0,0,1672,1673,5,146,0,0,1673, + 1678,3,178,89,0,1674,1676,5,171,0,0,1675,1674,1,0,0,0,1675,1676,1,0,0, + 0,1676,1677,1,0,0,0,1677,1679,3,192,96,0,1678,1675,1,0,0,0,1678,1679, + 1,0,0,0,1679,175,1,0,0,0,1680,1681,5,127,0,0,1681,1682,3,178,89,0,1682, + 177,1,0,0,0,1683,1685,5,171,0,0,1684,1683,1,0,0,0,1684,1685,1,0,0,0,1685, + 1686,1,0,0,0,1686,1688,5,77,0,0,1687,1684,1,0,0,0,1687,1688,1,0,0,0,1688, + 1689,1,0,0,0,1689,1690,5,171,0,0,1690,1693,3,180,90,0,1691,1692,5,171, + 0,0,1692,1694,3,184,92,0,1693,1691,1,0,0,0,1693,1694,1,0,0,0,1694,1697, + 1,0,0,0,1695,1696,5,171,0,0,1696,1698,3,186,93,0,1697,1695,1,0,0,0,1697, + 1698,1,0,0,0,1698,1701,1,0,0,0,1699,1700,5,171,0,0,1700,1702,3,188,94, + 0,1701,1699,1,0,0,0,1701,1702,1,0,0,0,1702,179,1,0,0,0,1703,1714,5,151, + 0,0,1704,1706,5,171,0,0,1705,1704,1,0,0,0,1705,1706,1,0,0,0,1706,1707, + 1,0,0,0,1707,1709,5,3,0,0,1708,1710,5,171,0,0,1709,1708,1,0,0,0,1709, + 1710,1,0,0,0,1710,1711,1,0,0,0,1711,1713,3,182,91,0,1712,1705,1,0,0,0, + 1713,1716,1,0,0,0,1714,1712,1,0,0,0,1714,1715,1,0,0,0,1715,1732,1,0,0, + 0,1716,1714,1,0,0,0,1717,1728,3,182,91,0,1718,1720,5,171,0,0,1719,1718, + 1,0,0,0,1719,1720,1,0,0,0,1720,1721,1,0,0,0,1721,1723,5,3,0,0,1722,1724, + 5,171,0,0,1723,1722,1,0,0,0,1723,1724,1,0,0,0,1724,1725,1,0,0,0,1725, + 1727,3,182,91,0,1726,1719,1,0,0,0,1727,1730,1,0,0,0,1728,1726,1,0,0,0, + 1728,1729,1,0,0,0,1729,1732,1,0,0,0,1730,1728,1,0,0,0,1731,1703,1,0,0, + 0,1731,1717,1,0,0,0,1732,181,1,0,0,0,1733,1734,3,234,117,0,1734,1735, + 5,171,0,0,1735,1736,5,51,0,0,1736,1737,5,171,0,0,1737,1738,3,326,163, + 0,1738,1741,1,0,0,0,1739,1741,3,234,117,0,1740,1733,1,0,0,0,1740,1739, + 1,0,0,0,1741,183,1,0,0,0,1742,1743,5,119,0,0,1743,1744,5,171,0,0,1744, + 1745,5,56,0,0,1745,1746,5,171,0,0,1746,1754,3,190,95,0,1747,1749,5,3, + 0,0,1748,1750,5,171,0,0,1749,1748,1,0,0,0,1749,1750,1,0,0,0,1750,1751, + 1,0,0,0,1751,1753,3,190,95,0,1752,1747,1,0,0,0,1753,1756,1,0,0,0,1754, + 1752,1,0,0,0,1754,1755,1,0,0,0,1755,185,1,0,0,0,1756,1754,1,0,0,0,1757, + 1758,5,152,0,0,1758,1759,5,171,0,0,1759,1760,3,234,117,0,1760,187,1,0, + 0,0,1761,1762,5,102,0,0,1762,1763,5,171,0,0,1763,1764,3,234,117,0,1764, + 189,1,0,0,0,1765,1770,3,234,117,0,1766,1768,5,171,0,0,1767,1766,1,0,0, + 0,1767,1768,1,0,0,0,1768,1769,1,0,0,0,1769,1771,7,1,0,0,1770,1767,1,0, + 0,0,1770,1771,1,0,0,0,1771,191,1,0,0,0,1772,1773,5,145,0,0,1773,1774, + 5,171,0,0,1774,1775,3,234,117,0,1775,193,1,0,0,0,1776,1787,3,196,98,0, + 1777,1779,5,171,0,0,1778,1777,1,0,0,0,1778,1779,1,0,0,0,1779,1780,1,0, + 0,0,1780,1782,5,3,0,0,1781,1783,5,171,0,0,1782,1781,1,0,0,0,1782,1783, + 1,0,0,0,1783,1784,1,0,0,0,1784,1786,3,196,98,0,1785,1778,1,0,0,0,1786, + 1789,1,0,0,0,1787,1785,1,0,0,0,1787,1788,1,0,0,0,1788,195,1,0,0,0,1789, + 1787,1,0,0,0,1790,1792,3,326,163,0,1791,1793,5,171,0,0,1792,1791,1,0, + 0,0,1792,1793,1,0,0,0,1793,1794,1,0,0,0,1794,1796,5,6,0,0,1795,1797,5, + 171,0,0,1796,1795,1,0,0,0,1796,1797,1,0,0,0,1797,1798,1,0,0,0,1798,1799, + 3,198,99,0,1799,1802,1,0,0,0,1800,1802,3,198,99,0,1801,1790,1,0,0,0,1801, + 1800,1,0,0,0,1802,197,1,0,0,0,1803,1804,3,200,100,0,1804,199,1,0,0,0, + 1805,1812,3,202,101,0,1806,1808,5,171,0,0,1807,1806,1,0,0,0,1807,1808, + 1,0,0,0,1808,1809,1,0,0,0,1809,1811,3,204,102,0,1810,1807,1,0,0,0,1811, + 1814,1,0,0,0,1812,1810,1,0,0,0,1812,1813,1,0,0,0,1813,1820,1,0,0,0,1814, + 1812,1,0,0,0,1815,1816,5,2,0,0,1816,1817,3,200,100,0,1817,1818,5,4,0, + 0,1818,1820,1,0,0,0,1819,1805,1,0,0,0,1819,1815,1,0,0,0,1820,201,1,0, + 0,0,1821,1823,5,2,0,0,1822,1824,5,171,0,0,1823,1822,1,0,0,0,1823,1824, + 1,0,0,0,1824,1829,1,0,0,0,1825,1827,3,326,163,0,1826,1828,5,171,0,0,1827, + 1826,1,0,0,0,1827,1828,1,0,0,0,1828,1830,1,0,0,0,1829,1825,1,0,0,0,1829, + 1830,1,0,0,0,1830,1835,1,0,0,0,1831,1833,3,214,107,0,1832,1834,5,171, + 0,0,1833,1832,1,0,0,0,1833,1834,1,0,0,0,1834,1836,1,0,0,0,1835,1831,1, + 0,0,0,1835,1836,1,0,0,0,1836,1841,1,0,0,0,1837,1839,3,210,105,0,1838, + 1840,5,171,0,0,1839,1838,1,0,0,0,1839,1840,1,0,0,0,1840,1842,1,0,0,0, + 1841,1837,1,0,0,0,1841,1842,1,0,0,0,1842,1843,1,0,0,0,1843,1844,5,4,0, + 0,1844,203,1,0,0,0,1845,1847,3,206,103,0,1846,1848,5,171,0,0,1847,1846, + 1,0,0,0,1847,1848,1,0,0,0,1848,1849,1,0,0,0,1849,1850,3,202,101,0,1850, + 205,1,0,0,0,1851,1853,3,346,173,0,1852,1854,5,171,0,0,1853,1852,1,0,0, + 0,1853,1854,1,0,0,0,1854,1855,1,0,0,0,1855,1857,3,350,175,0,1856,1858, + 5,171,0,0,1857,1856,1,0,0,0,1857,1858,1,0,0,0,1858,1860,1,0,0,0,1859, + 1861,3,208,104,0,1860,1859,1,0,0,0,1860,1861,1,0,0,0,1861,1863,1,0,0, + 0,1862,1864,5,171,0,0,1863,1862,1,0,0,0,1863,1864,1,0,0,0,1864,1865,1, + 0,0,0,1865,1866,3,350,175,0,1866,1896,1,0,0,0,1867,1869,3,350,175,0,1868, + 1870,5,171,0,0,1869,1868,1,0,0,0,1869,1870,1,0,0,0,1870,1872,1,0,0,0, + 1871,1873,3,208,104,0,1872,1871,1,0,0,0,1872,1873,1,0,0,0,1873,1875,1, + 0,0,0,1874,1876,5,171,0,0,1875,1874,1,0,0,0,1875,1876,1,0,0,0,1876,1877, + 1,0,0,0,1877,1879,3,350,175,0,1878,1880,5,171,0,0,1879,1878,1,0,0,0,1879, + 1880,1,0,0,0,1880,1881,1,0,0,0,1881,1882,3,348,174,0,1882,1896,1,0,0, + 0,1883,1885,3,350,175,0,1884,1886,5,171,0,0,1885,1884,1,0,0,0,1885,1886, + 1,0,0,0,1886,1888,1,0,0,0,1887,1889,3,208,104,0,1888,1887,1,0,0,0,1888, + 1889,1,0,0,0,1889,1891,1,0,0,0,1890,1892,5,171,0,0,1891,1890,1,0,0,0, + 1891,1892,1,0,0,0,1892,1893,1,0,0,0,1893,1894,3,350,175,0,1894,1896,1, + 0,0,0,1895,1851,1,0,0,0,1895,1867,1,0,0,0,1895,1883,1,0,0,0,1896,207, + 1,0,0,0,1897,1899,5,7,0,0,1898,1900,5,171,0,0,1899,1898,1,0,0,0,1899, + 1900,1,0,0,0,1900,1905,1,0,0,0,1901,1903,3,326,163,0,1902,1904,5,171, + 0,0,1903,1902,1,0,0,0,1903,1904,1,0,0,0,1904,1906,1,0,0,0,1905,1901,1, + 0,0,0,1905,1906,1,0,0,0,1906,1911,1,0,0,0,1907,1909,3,212,106,0,1908, + 1910,5,171,0,0,1909,1908,1,0,0,0,1909,1910,1,0,0,0,1910,1912,1,0,0,0, + 1911,1907,1,0,0,0,1911,1912,1,0,0,0,1912,1917,1,0,0,0,1913,1915,3,218, + 109,0,1914,1916,5,171,0,0,1915,1914,1,0,0,0,1915,1916,1,0,0,0,1916,1918, + 1,0,0,0,1917,1913,1,0,0,0,1917,1918,1,0,0,0,1918,1923,1,0,0,0,1919,1921, + 3,210,105,0,1920,1922,5,171,0,0,1921,1920,1,0,0,0,1921,1922,1,0,0,0,1922, + 1924,1,0,0,0,1923,1919,1,0,0,0,1923,1924,1,0,0,0,1924,1925,1,0,0,0,1925, + 1926,5,8,0,0,1926,209,1,0,0,0,1927,1929,5,9,0,0,1928,1930,5,171,0,0,1929, + 1928,1,0,0,0,1929,1930,1,0,0,0,1930,1964,1,0,0,0,1931,1933,3,334,167, + 0,1932,1934,5,171,0,0,1933,1932,1,0,0,0,1933,1934,1,0,0,0,1934,1935,1, + 0,0,0,1935,1937,5,156,0,0,1936,1938,5,171,0,0,1937,1936,1,0,0,0,1937, + 1938,1,0,0,0,1938,1939,1,0,0,0,1939,1941,3,234,117,0,1940,1942,5,171, + 0,0,1941,1940,1,0,0,0,1941,1942,1,0,0,0,1942,1961,1,0,0,0,1943,1945,5, + 3,0,0,1944,1946,5,171,0,0,1945,1944,1,0,0,0,1945,1946,1,0,0,0,1946,1947, + 1,0,0,0,1947,1949,3,334,167,0,1948,1950,5,171,0,0,1949,1948,1,0,0,0,1949, + 1950,1,0,0,0,1950,1951,1,0,0,0,1951,1953,5,156,0,0,1952,1954,5,171,0, + 0,1953,1952,1,0,0,0,1953,1954,1,0,0,0,1954,1955,1,0,0,0,1955,1957,3,234, + 117,0,1956,1958,5,171,0,0,1957,1956,1,0,0,0,1957,1958,1,0,0,0,1958,1960, + 1,0,0,0,1959,1943,1,0,0,0,1960,1963,1,0,0,0,1961,1959,1,0,0,0,1961,1962, + 1,0,0,0,1962,1965,1,0,0,0,1963,1961,1,0,0,0,1964,1931,1,0,0,0,1964,1965, + 1,0,0,0,1965,1966,1,0,0,0,1966,1967,5,10,0,0,1967,211,1,0,0,0,1968,1970, + 5,156,0,0,1969,1971,5,171,0,0,1970,1969,1,0,0,0,1970,1971,1,0,0,0,1971, + 1972,1,0,0,0,1972,1986,3,232,116,0,1973,1975,5,171,0,0,1974,1973,1,0, + 0,0,1974,1975,1,0,0,0,1975,1976,1,0,0,0,1976,1978,5,11,0,0,1977,1979, + 5,156,0,0,1978,1977,1,0,0,0,1978,1979,1,0,0,0,1979,1981,1,0,0,0,1980, + 1982,5,171,0,0,1981,1980,1,0,0,0,1981,1982,1,0,0,0,1982,1983,1,0,0,0, + 1983,1985,3,232,116,0,1984,1974,1,0,0,0,1985,1988,1,0,0,0,1986,1984,1, + 0,0,0,1986,1987,1,0,0,0,1987,213,1,0,0,0,1988,1986,1,0,0,0,1989,1996, + 3,216,108,0,1990,1992,5,171,0,0,1991,1990,1,0,0,0,1991,1992,1,0,0,0,1992, + 1993,1,0,0,0,1993,1995,3,216,108,0,1994,1991,1,0,0,0,1995,1998,1,0,0, + 0,1996,1994,1,0,0,0,1996,1997,1,0,0,0,1997,215,1,0,0,0,1998,1996,1,0, + 0,0,1999,2001,5,156,0,0,2000,2002,5,171,0,0,2001,2000,1,0,0,0,2001,2002, + 1,0,0,0,2002,2003,1,0,0,0,2003,2004,3,230,115,0,2004,217,1,0,0,0,2005, + 2007,5,151,0,0,2006,2008,5,171,0,0,2007,2006,1,0,0,0,2007,2008,1,0,0, + 0,2008,2013,1,0,0,0,2009,2014,5,132,0,0,2010,2011,5,48,0,0,2011,2012, + 5,171,0,0,2012,2014,5,132,0,0,2013,2009,1,0,0,0,2013,2010,1,0,0,0,2013, + 2014,1,0,0,0,2014,2016,1,0,0,0,2015,2017,5,171,0,0,2016,2015,1,0,0,0, + 2016,2017,1,0,0,0,2017,2032,1,0,0,0,2018,2020,3,226,113,0,2019,2018,1, + 0,0,0,2019,2020,1,0,0,0,2020,2022,1,0,0,0,2021,2023,5,171,0,0,2022,2021, + 1,0,0,0,2022,2023,1,0,0,0,2023,2024,1,0,0,0,2024,2026,5,12,0,0,2025,2027, + 5,171,0,0,2026,2025,1,0,0,0,2026,2027,1,0,0,0,2027,2029,1,0,0,0,2028, + 2030,3,228,114,0,2029,2028,1,0,0,0,2029,2030,1,0,0,0,2030,2033,1,0,0, + 0,2031,2033,3,336,168,0,2032,2019,1,0,0,0,2032,2031,1,0,0,0,2032,2033, + 1,0,0,0,2033,2038,1,0,0,0,2034,2036,5,171,0,0,2035,2034,1,0,0,0,2035, + 2036,1,0,0,0,2036,2037,1,0,0,0,2037,2039,3,220,110,0,2038,2035,1,0,0, + 0,2038,2039,1,0,0,0,2039,219,1,0,0,0,2040,2042,5,2,0,0,2041,2043,5,171, + 0,0,2042,2041,1,0,0,0,2042,2043,1,0,0,0,2043,2044,1,0,0,0,2044,2046,3, + 326,163,0,2045,2047,5,171,0,0,2046,2045,1,0,0,0,2046,2047,1,0,0,0,2047, + 2048,1,0,0,0,2048,2050,5,3,0,0,2049,2051,5,171,0,0,2050,2049,1,0,0,0, + 2050,2051,1,0,0,0,2051,2052,1,0,0,0,2052,2064,3,326,163,0,2053,2055,5, + 171,0,0,2054,2053,1,0,0,0,2054,2055,1,0,0,0,2055,2056,1,0,0,0,2056,2058, + 5,11,0,0,2057,2059,5,171,0,0,2058,2057,1,0,0,0,2058,2059,1,0,0,0,2059, + 2060,1,0,0,0,2060,2062,3,192,96,0,2061,2063,5,171,0,0,2062,2061,1,0,0, + 0,2062,2063,1,0,0,0,2063,2065,1,0,0,0,2064,2054,1,0,0,0,2064,2065,1,0, + 0,0,2065,2085,1,0,0,0,2066,2068,5,171,0,0,2067,2066,1,0,0,0,2067,2068, + 1,0,0,0,2068,2069,1,0,0,0,2069,2071,5,11,0,0,2070,2072,5,171,0,0,2071, + 2070,1,0,0,0,2071,2072,1,0,0,0,2072,2073,1,0,0,0,2073,2075,3,224,112, + 0,2074,2076,5,171,0,0,2075,2074,1,0,0,0,2075,2076,1,0,0,0,2076,2077,1, + 0,0,0,2077,2079,5,3,0,0,2078,2080,5,171,0,0,2079,2078,1,0,0,0,2079,2080, + 1,0,0,0,2080,2081,1,0,0,0,2081,2083,3,222,111,0,2082,2084,5,171,0,0,2083, + 2082,1,0,0,0,2083,2084,1,0,0,0,2084,2086,1,0,0,0,2085,2067,1,0,0,0,2085, + 2086,1,0,0,0,2086,2087,1,0,0,0,2087,2088,5,4,0,0,2088,221,1,0,0,0,2089, + 2091,5,9,0,0,2090,2092,5,171,0,0,2091,2090,1,0,0,0,2091,2092,1,0,0,0, + 2092,2094,1,0,0,0,2093,2095,3,180,90,0,2094,2093,1,0,0,0,2094,2095,1, + 0,0,0,2095,2097,1,0,0,0,2096,2098,5,171,0,0,2097,2096,1,0,0,0,2097,2098, + 1,0,0,0,2098,2099,1,0,0,0,2099,2100,5,10,0,0,2100,223,1,0,0,0,2101,2103, + 5,9,0,0,2102,2104,5,171,0,0,2103,2102,1,0,0,0,2103,2104,1,0,0,0,2104, + 2106,1,0,0,0,2105,2107,3,180,90,0,2106,2105,1,0,0,0,2106,2107,1,0,0,0, + 2107,2109,1,0,0,0,2108,2110,5,171,0,0,2109,2108,1,0,0,0,2109,2110,1,0, + 0,0,2110,2111,1,0,0,0,2111,2112,5,10,0,0,2112,225,1,0,0,0,2113,2114,5, + 159,0,0,2114,227,1,0,0,0,2115,2116,5,159,0,0,2116,229,1,0,0,0,2117,2118, + 3,340,170,0,2118,231,1,0,0,0,2119,2120,3,340,170,0,2120,233,1,0,0,0,2121, + 2122,3,236,118,0,2122,235,1,0,0,0,2123,2130,3,238,119,0,2124,2125,5,171, + 0,0,2125,2126,5,118,0,0,2126,2127,5,171,0,0,2127,2129,3,238,119,0,2128, + 2124,1,0,0,0,2129,2132,1,0,0,0,2130,2128,1,0,0,0,2130,2131,1,0,0,0,2131, + 237,1,0,0,0,2132,2130,1,0,0,0,2133,2140,3,240,120,0,2134,2135,5,171,0, + 0,2135,2136,5,148,0,0,2136,2137,5,171,0,0,2137,2139,3,240,120,0,2138, + 2134,1,0,0,0,2139,2142,1,0,0,0,2140,2138,1,0,0,0,2140,2141,1,0,0,0,2141, + 239,1,0,0,0,2142,2140,1,0,0,0,2143,2150,3,242,121,0,2144,2145,5,171,0, + 0,2145,2146,5,50,0,0,2146,2147,5,171,0,0,2147,2149,3,242,121,0,2148,2144, + 1,0,0,0,2149,2152,1,0,0,0,2150,2148,1,0,0,0,2150,2151,1,0,0,0,2151,241, + 1,0,0,0,2152,2150,1,0,0,0,2153,2155,5,112,0,0,2154,2156,5,171,0,0,2155, + 2154,1,0,0,0,2155,2156,1,0,0,0,2156,2158,1,0,0,0,2157,2153,1,0,0,0,2158, + 2161,1,0,0,0,2159,2157,1,0,0,0,2159,2160,1,0,0,0,2160,2162,1,0,0,0,2161, + 2159,1,0,0,0,2162,2163,3,244,122,0,2163,243,1,0,0,0,2164,2174,3,248,124, + 0,2165,2167,5,171,0,0,2166,2165,1,0,0,0,2166,2167,1,0,0,0,2167,2168,1, + 0,0,0,2168,2170,3,246,123,0,2169,2171,5,171,0,0,2170,2169,1,0,0,0,2170, + 2171,1,0,0,0,2171,2172,1,0,0,0,2172,2173,3,248,124,0,2173,2175,1,0,0, + 0,2174,2166,1,0,0,0,2174,2175,1,0,0,0,2175,2213,1,0,0,0,2176,2178,3,248, + 124,0,2177,2179,5,171,0,0,2178,2177,1,0,0,0,2178,2179,1,0,0,0,2179,2180, + 1,0,0,0,2180,2182,5,153,0,0,2181,2183,5,171,0,0,2182,2181,1,0,0,0,2182, + 2183,1,0,0,0,2183,2184,1,0,0,0,2184,2185,3,248,124,0,2185,2186,1,0,0, + 0,2186,2187,6,122,-1,0,2187,2213,1,0,0,0,2188,2190,3,248,124,0,2189,2191, + 5,171,0,0,2190,2189,1,0,0,0,2190,2191,1,0,0,0,2191,2192,1,0,0,0,2192, + 2194,3,246,123,0,2193,2195,5,171,0,0,2194,2193,1,0,0,0,2194,2195,1,0, + 0,0,2195,2196,1,0,0,0,2196,2206,3,248,124,0,2197,2199,5,171,0,0,2198, + 2197,1,0,0,0,2198,2199,1,0,0,0,2199,2200,1,0,0,0,2200,2202,3,246,123, + 0,2201,2203,5,171,0,0,2202,2201,1,0,0,0,2202,2203,1,0,0,0,2203,2204,1, + 0,0,0,2204,2205,3,248,124,0,2205,2207,1,0,0,0,2206,2198,1,0,0,0,2207, + 2208,1,0,0,0,2208,2206,1,0,0,0,2208,2209,1,0,0,0,2209,2210,1,0,0,0,2210, + 2211,6,122,-1,0,2211,2213,1,0,0,0,2212,2164,1,0,0,0,2212,2176,1,0,0,0, + 2212,2188,1,0,0,0,2213,245,1,0,0,0,2214,2215,7,2,0,0,2215,247,1,0,0,0, + 2216,2227,3,250,125,0,2217,2219,5,171,0,0,2218,2217,1,0,0,0,2218,2219, + 1,0,0,0,2219,2220,1,0,0,0,2220,2222,5,11,0,0,2221,2223,5,171,0,0,2222, + 2221,1,0,0,0,2222,2223,1,0,0,0,2223,2224,1,0,0,0,2224,2226,3,250,125, + 0,2225,2218,1,0,0,0,2226,2229,1,0,0,0,2227,2225,1,0,0,0,2227,2228,1,0, + 0,0,2228,249,1,0,0,0,2229,2227,1,0,0,0,2230,2241,3,252,126,0,2231,2233, + 5,171,0,0,2232,2231,1,0,0,0,2232,2233,1,0,0,0,2233,2234,1,0,0,0,2234, + 2236,5,18,0,0,2235,2237,5,171,0,0,2236,2235,1,0,0,0,2236,2237,1,0,0,0, + 2237,2238,1,0,0,0,2238,2240,3,252,126,0,2239,2232,1,0,0,0,2240,2243,1, + 0,0,0,2241,2239,1,0,0,0,2241,2242,1,0,0,0,2242,251,1,0,0,0,2243,2241, + 1,0,0,0,2244,2256,3,256,128,0,2245,2247,5,171,0,0,2246,2245,1,0,0,0,2246, + 2247,1,0,0,0,2247,2248,1,0,0,0,2248,2250,3,254,127,0,2249,2251,5,171, + 0,0,2250,2249,1,0,0,0,2250,2251,1,0,0,0,2251,2252,1,0,0,0,2252,2253,3, + 256,128,0,2253,2255,1,0,0,0,2254,2246,1,0,0,0,2255,2258,1,0,0,0,2256, + 2254,1,0,0,0,2256,2257,1,0,0,0,2257,253,1,0,0,0,2258,2256,1,0,0,0,2259, + 2260,7,3,0,0,2260,255,1,0,0,0,2261,2273,3,260,130,0,2262,2264,5,171,0, + 0,2263,2262,1,0,0,0,2263,2264,1,0,0,0,2264,2265,1,0,0,0,2265,2267,3,258, + 129,0,2266,2268,5,171,0,0,2267,2266,1,0,0,0,2267,2268,1,0,0,0,2268,2269, + 1,0,0,0,2269,2270,3,260,130,0,2270,2272,1,0,0,0,2271,2263,1,0,0,0,2272, + 2275,1,0,0,0,2273,2271,1,0,0,0,2273,2274,1,0,0,0,2274,257,1,0,0,0,2275, + 2273,1,0,0,0,2276,2277,7,4,0,0,2277,259,1,0,0,0,2278,2290,3,264,132,0, + 2279,2281,5,171,0,0,2280,2279,1,0,0,0,2280,2281,1,0,0,0,2281,2282,1,0, + 0,0,2282,2284,3,262,131,0,2283,2285,5,171,0,0,2284,2283,1,0,0,0,2284, + 2285,1,0,0,0,2285,2286,1,0,0,0,2286,2287,3,264,132,0,2287,2289,1,0,0, + 0,2288,2280,1,0,0,0,2289,2292,1,0,0,0,2290,2288,1,0,0,0,2290,2291,1,0, + 0,0,2291,261,1,0,0,0,2292,2290,1,0,0,0,2293,2294,7,5,0,0,2294,263,1,0, + 0,0,2295,2306,3,266,133,0,2296,2298,5,171,0,0,2297,2296,1,0,0,0,2297, + 2298,1,0,0,0,2298,2299,1,0,0,0,2299,2301,5,24,0,0,2300,2302,5,171,0,0, + 2301,2300,1,0,0,0,2301,2302,1,0,0,0,2302,2303,1,0,0,0,2303,2305,3,266, + 133,0,2304,2297,1,0,0,0,2305,2308,1,0,0,0,2306,2304,1,0,0,0,2306,2307, + 1,0,0,0,2307,265,1,0,0,0,2308,2306,1,0,0,0,2309,2311,5,154,0,0,2310,2312, + 5,171,0,0,2311,2310,1,0,0,0,2311,2312,1,0,0,0,2312,2314,1,0,0,0,2313, + 2309,1,0,0,0,2314,2317,1,0,0,0,2315,2313,1,0,0,0,2315,2316,1,0,0,0,2316, + 2318,1,0,0,0,2317,2315,1,0,0,0,2318,2323,3,268,134,0,2319,2321,5,171, + 0,0,2320,2319,1,0,0,0,2320,2321,1,0,0,0,2321,2322,1,0,0,0,2322,2324,5, + 155,0,0,2323,2320,1,0,0,0,2323,2324,1,0,0,0,2324,267,1,0,0,0,2325,2333, + 3,278,139,0,2326,2334,3,272,136,0,2327,2329,3,270,135,0,2328,2327,1,0, + 0,0,2329,2330,1,0,0,0,2330,2328,1,0,0,0,2330,2331,1,0,0,0,2331,2334,1, + 0,0,0,2332,2334,3,276,138,0,2333,2326,1,0,0,0,2333,2328,1,0,0,0,2333, + 2332,1,0,0,0,2333,2334,1,0,0,0,2334,269,1,0,0,0,2335,2336,5,171,0,0,2336, + 2338,5,96,0,0,2337,2339,5,171,0,0,2338,2337,1,0,0,0,2338,2339,1,0,0,0, + 2339,2340,1,0,0,0,2340,2355,3,278,139,0,2341,2342,5,7,0,0,2342,2343,3, + 234,117,0,2343,2344,5,8,0,0,2344,2355,1,0,0,0,2345,2347,5,7,0,0,2346, + 2348,3,234,117,0,2347,2346,1,0,0,0,2347,2348,1,0,0,0,2348,2349,1,0,0, + 0,2349,2351,5,156,0,0,2350,2352,3,234,117,0,2351,2350,1,0,0,0,2351,2352, + 1,0,0,0,2352,2353,1,0,0,0,2353,2355,5,8,0,0,2354,2335,1,0,0,0,2354,2341, + 1,0,0,0,2354,2345,1,0,0,0,2355,271,1,0,0,0,2356,2368,3,274,137,0,2357, + 2358,5,171,0,0,2358,2359,5,134,0,0,2359,2360,5,171,0,0,2360,2368,5,146, + 0,0,2361,2362,5,171,0,0,2362,2363,5,81,0,0,2363,2364,5,171,0,0,2364,2368, + 5,146,0,0,2365,2366,5,171,0,0,2366,2368,5,65,0,0,2367,2356,1,0,0,0,2367, + 2357,1,0,0,0,2367,2361,1,0,0,0,2367,2365,1,0,0,0,2368,2370,1,0,0,0,2369, + 2371,5,171,0,0,2370,2369,1,0,0,0,2370,2371,1,0,0,0,2371,2372,1,0,0,0, + 2372,2373,3,278,139,0,2373,273,1,0,0,0,2374,2376,5,171,0,0,2375,2374, + 1,0,0,0,2375,2376,1,0,0,0,2376,2377,1,0,0,0,2377,2378,5,25,0,0,2378,275, + 1,0,0,0,2379,2380,5,171,0,0,2380,2381,5,99,0,0,2381,2382,5,171,0,0,2382, + 2390,5,114,0,0,2383,2384,5,171,0,0,2384,2385,5,99,0,0,2385,2386,5,171, + 0,0,2386,2387,5,112,0,0,2387,2388,5,171,0,0,2388,2390,5,114,0,0,2389, + 2379,1,0,0,0,2389,2383,1,0,0,0,2390,277,1,0,0,0,2391,2398,3,280,140,0, + 2392,2394,5,171,0,0,2393,2392,1,0,0,0,2393,2394,1,0,0,0,2394,2395,1,0, + 0,0,2395,2397,3,318,159,0,2396,2393,1,0,0,0,2397,2400,1,0,0,0,2398,2396, + 1,0,0,0,2398,2399,1,0,0,0,2399,279,1,0,0,0,2400,2398,1,0,0,0,2401,2412, + 3,288,144,0,2402,2412,3,330,165,0,2403,2412,3,322,161,0,2404,2412,3,300, + 150,0,2405,2412,3,302,151,0,2406,2412,3,312,156,0,2407,2412,3,314,157, + 0,2408,2412,3,316,158,0,2409,2412,3,326,163,0,2410,2412,3,282,141,0,2411, + 2401,1,0,0,0,2411,2402,1,0,0,0,2411,2403,1,0,0,0,2411,2404,1,0,0,0,2411, + 2405,1,0,0,0,2411,2406,1,0,0,0,2411,2407,1,0,0,0,2411,2408,1,0,0,0,2411, + 2409,1,0,0,0,2411,2410,1,0,0,0,2412,281,1,0,0,0,2413,2415,5,48,0,0,2414, + 2416,5,171,0,0,2415,2414,1,0,0,0,2415,2416,1,0,0,0,2416,2417,1,0,0,0, + 2417,2419,5,2,0,0,2418,2420,5,171,0,0,2419,2418,1,0,0,0,2419,2420,1,0, + 0,0,2420,2421,1,0,0,0,2421,2423,3,284,142,0,2422,2424,5,171,0,0,2423, + 2422,1,0,0,0,2423,2424,1,0,0,0,2424,2425,1,0,0,0,2425,2426,5,4,0,0,2426, + 2470,1,0,0,0,2427,2429,5,46,0,0,2428,2430,5,171,0,0,2429,2428,1,0,0,0, + 2429,2430,1,0,0,0,2430,2431,1,0,0,0,2431,2433,5,2,0,0,2432,2434,5,171, + 0,0,2433,2432,1,0,0,0,2433,2434,1,0,0,0,2434,2435,1,0,0,0,2435,2437,3, + 284,142,0,2436,2438,5,171,0,0,2437,2436,1,0,0,0,2437,2438,1,0,0,0,2438, + 2439,1,0,0,0,2439,2440,5,4,0,0,2440,2470,1,0,0,0,2441,2443,5,113,0,0, + 2442,2444,5,171,0,0,2443,2442,1,0,0,0,2443,2444,1,0,0,0,2444,2445,1,0, + 0,0,2445,2447,5,2,0,0,2446,2448,5,171,0,0,2447,2446,1,0,0,0,2447,2448, + 1,0,0,0,2448,2449,1,0,0,0,2449,2451,3,284,142,0,2450,2452,5,171,0,0,2451, + 2450,1,0,0,0,2451,2452,1,0,0,0,2452,2453,1,0,0,0,2453,2454,5,4,0,0,2454, + 2470,1,0,0,0,2455,2457,5,149,0,0,2456,2458,5,171,0,0,2457,2456,1,0,0, + 0,2457,2458,1,0,0,0,2458,2459,1,0,0,0,2459,2461,5,2,0,0,2460,2462,5,171, + 0,0,2461,2460,1,0,0,0,2461,2462,1,0,0,0,2462,2463,1,0,0,0,2463,2465,3, + 284,142,0,2464,2466,5,171,0,0,2465,2464,1,0,0,0,2465,2466,1,0,0,0,2466, + 2467,1,0,0,0,2467,2468,5,4,0,0,2468,2470,1,0,0,0,2469,2413,1,0,0,0,2469, + 2427,1,0,0,0,2469,2441,1,0,0,0,2469,2455,1,0,0,0,2470,283,1,0,0,0,2471, + 2476,3,286,143,0,2472,2474,5,171,0,0,2473,2472,1,0,0,0,2473,2474,1,0, + 0,0,2474,2475,1,0,0,0,2475,2477,3,192,96,0,2476,2473,1,0,0,0,2476,2477, + 1,0,0,0,2477,285,1,0,0,0,2478,2479,3,326,163,0,2479,2480,5,171,0,0,2480, + 2481,5,96,0,0,2481,2482,5,171,0,0,2482,2483,3,234,117,0,2483,287,1,0, + 0,0,2484,2491,3,328,164,0,2485,2491,5,157,0,0,2486,2491,3,290,145,0,2487, + 2491,5,114,0,0,2488,2491,3,292,146,0,2489,2491,3,296,148,0,2490,2484, + 1,0,0,0,2490,2485,1,0,0,0,2490,2486,1,0,0,0,2490,2487,1,0,0,0,2490,2488, + 1,0,0,0,2490,2489,1,0,0,0,2491,289,1,0,0,0,2492,2493,7,6,0,0,2493,291, + 1,0,0,0,2494,2496,5,7,0,0,2495,2497,5,171,0,0,2496,2495,1,0,0,0,2496, + 2497,1,0,0,0,2497,2511,1,0,0,0,2498,2500,3,234,117,0,2499,2501,5,171, + 0,0,2500,2499,1,0,0,0,2500,2501,1,0,0,0,2501,2508,1,0,0,0,2502,2504,3, + 294,147,0,2503,2505,5,171,0,0,2504,2503,1,0,0,0,2504,2505,1,0,0,0,2505, + 2507,1,0,0,0,2506,2502,1,0,0,0,2507,2510,1,0,0,0,2508,2506,1,0,0,0,2508, + 2509,1,0,0,0,2509,2512,1,0,0,0,2510,2508,1,0,0,0,2511,2498,1,0,0,0,2511, + 2512,1,0,0,0,2512,2513,1,0,0,0,2513,2514,5,8,0,0,2514,293,1,0,0,0,2515, + 2517,5,3,0,0,2516,2518,5,171,0,0,2517,2516,1,0,0,0,2517,2518,1,0,0,0, + 2518,2520,1,0,0,0,2519,2521,3,234,117,0,2520,2519,1,0,0,0,2520,2521,1, + 0,0,0,2521,295,1,0,0,0,2522,2524,5,9,0,0,2523,2525,5,171,0,0,2524,2523, + 1,0,0,0,2524,2525,1,0,0,0,2525,2526,1,0,0,0,2526,2528,3,298,149,0,2527, + 2529,5,171,0,0,2528,2527,1,0,0,0,2528,2529,1,0,0,0,2529,2540,1,0,0,0, + 2530,2532,5,3,0,0,2531,2533,5,171,0,0,2532,2531,1,0,0,0,2532,2533,1,0, + 0,0,2533,2534,1,0,0,0,2534,2536,3,298,149,0,2535,2537,5,171,0,0,2536, + 2535,1,0,0,0,2536,2537,1,0,0,0,2537,2539,1,0,0,0,2538,2530,1,0,0,0,2539, + 2542,1,0,0,0,2540,2538,1,0,0,0,2540,2541,1,0,0,0,2541,2543,1,0,0,0,2542, + 2540,1,0,0,0,2543,2544,5,10,0,0,2544,297,1,0,0,0,2545,2548,3,342,171, + 0,2546,2548,5,157,0,0,2547,2545,1,0,0,0,2547,2546,1,0,0,0,2548,2550,1, + 0,0,0,2549,2551,5,171,0,0,2550,2549,1,0,0,0,2550,2551,1,0,0,0,2551,2552, + 1,0,0,0,2552,2554,5,156,0,0,2553,2555,5,171,0,0,2554,2553,1,0,0,0,2554, + 2555,1,0,0,0,2555,2556,1,0,0,0,2556,2557,3,234,117,0,2557,299,1,0,0,0, + 2558,2560,5,2,0,0,2559,2561,5,171,0,0,2560,2559,1,0,0,0,2560,2561,1,0, + 0,0,2561,2562,1,0,0,0,2562,2564,3,234,117,0,2563,2565,5,171,0,0,2564, + 2563,1,0,0,0,2564,2565,1,0,0,0,2565,2566,1,0,0,0,2566,2567,5,4,0,0,2567, + 301,1,0,0,0,2568,2570,5,67,0,0,2569,2571,5,171,0,0,2570,2569,1,0,0,0, + 2570,2571,1,0,0,0,2571,2572,1,0,0,0,2572,2574,5,2,0,0,2573,2575,5,171, + 0,0,2574,2573,1,0,0,0,2574,2575,1,0,0,0,2575,2576,1,0,0,0,2576,2578,5, + 151,0,0,2577,2579,5,171,0,0,2578,2577,1,0,0,0,2578,2579,1,0,0,0,2579, + 2580,1,0,0,0,2580,2646,5,4,0,0,2581,2583,5,59,0,0,2582,2584,5,171,0,0, + 2583,2582,1,0,0,0,2583,2584,1,0,0,0,2584,2585,1,0,0,0,2585,2587,5,2,0, + 0,2586,2588,5,171,0,0,2587,2586,1,0,0,0,2587,2588,1,0,0,0,2588,2589,1, + 0,0,0,2589,2591,3,306,153,0,2590,2592,5,171,0,0,2591,2590,1,0,0,0,2591, + 2592,1,0,0,0,2592,2603,1,0,0,0,2593,2595,5,51,0,0,2594,2596,5,171,0,0, + 2595,2594,1,0,0,0,2595,2596,1,0,0,0,2596,2597,1,0,0,0,2597,2604,3,102, + 51,0,2598,2600,5,3,0,0,2599,2601,5,171,0,0,2600,2599,1,0,0,0,2600,2601, + 1,0,0,0,2601,2602,1,0,0,0,2602,2604,3,306,153,0,2603,2593,1,0,0,0,2603, + 2598,1,0,0,0,2604,2606,1,0,0,0,2605,2607,5,171,0,0,2606,2605,1,0,0,0, + 2606,2607,1,0,0,0,2607,2608,1,0,0,0,2608,2609,5,4,0,0,2609,2646,1,0,0, + 0,2610,2612,3,304,152,0,2611,2613,5,171,0,0,2612,2611,1,0,0,0,2612,2613, + 1,0,0,0,2613,2614,1,0,0,0,2614,2616,5,2,0,0,2615,2617,5,171,0,0,2616, + 2615,1,0,0,0,2616,2617,1,0,0,0,2617,2622,1,0,0,0,2618,2620,5,77,0,0,2619, + 2621,5,171,0,0,2620,2619,1,0,0,0,2620,2621,1,0,0,0,2621,2623,1,0,0,0, + 2622,2618,1,0,0,0,2622,2623,1,0,0,0,2623,2641,1,0,0,0,2624,2626,3,306, + 153,0,2625,2627,5,171,0,0,2626,2625,1,0,0,0,2626,2627,1,0,0,0,2627,2638, + 1,0,0,0,2628,2630,5,3,0,0,2629,2631,5,171,0,0,2630,2629,1,0,0,0,2630, + 2631,1,0,0,0,2631,2632,1,0,0,0,2632,2634,3,306,153,0,2633,2635,5,171, + 0,0,2634,2633,1,0,0,0,2634,2635,1,0,0,0,2635,2637,1,0,0,0,2636,2628,1, + 0,0,0,2637,2640,1,0,0,0,2638,2636,1,0,0,0,2638,2639,1,0,0,0,2639,2642, + 1,0,0,0,2640,2638,1,0,0,0,2641,2624,1,0,0,0,2641,2642,1,0,0,0,2642,2643, + 1,0,0,0,2643,2644,5,4,0,0,2644,2646,1,0,0,0,2645,2568,1,0,0,0,2645,2581, + 1,0,0,0,2645,2610,1,0,0,0,2646,303,1,0,0,0,2647,2648,3,342,171,0,2648, + 305,1,0,0,0,2649,2651,3,342,171,0,2650,2652,5,171,0,0,2651,2650,1,0,0, + 0,2651,2652,1,0,0,0,2652,2653,1,0,0,0,2653,2654,5,156,0,0,2654,2656,5, + 6,0,0,2655,2657,5,171,0,0,2656,2655,1,0,0,0,2656,2657,1,0,0,0,2657,2659, + 1,0,0,0,2658,2649,1,0,0,0,2658,2659,1,0,0,0,2659,2660,1,0,0,0,2660,2663, + 3,234,117,0,2661,2663,3,308,154,0,2662,2658,1,0,0,0,2662,2661,1,0,0,0, + 2663,307,1,0,0,0,2664,2666,3,310,155,0,2665,2667,5,171,0,0,2666,2665, + 1,0,0,0,2666,2667,1,0,0,0,2667,2668,1,0,0,0,2668,2669,5,154,0,0,2669, + 2671,5,16,0,0,2670,2672,5,171,0,0,2671,2670,1,0,0,0,2671,2672,1,0,0,0, + 2672,2673,1,0,0,0,2673,2675,3,234,117,0,2674,2676,5,171,0,0,2675,2674, + 1,0,0,0,2675,2676,1,0,0,0,2676,309,1,0,0,0,2677,2702,3,342,171,0,2678, + 2680,5,2,0,0,2679,2681,5,171,0,0,2680,2679,1,0,0,0,2680,2681,1,0,0,0, + 2681,2682,1,0,0,0,2682,2684,3,342,171,0,2683,2685,5,171,0,0,2684,2683, + 1,0,0,0,2684,2685,1,0,0,0,2685,2696,1,0,0,0,2686,2688,5,3,0,0,2687,2689, + 5,171,0,0,2688,2687,1,0,0,0,2688,2689,1,0,0,0,2689,2690,1,0,0,0,2690, + 2692,3,342,171,0,2691,2693,5,171,0,0,2692,2691,1,0,0,0,2692,2693,1,0, + 0,0,2693,2695,1,0,0,0,2694,2686,1,0,0,0,2695,2698,1,0,0,0,2696,2694,1, + 0,0,0,2696,2697,1,0,0,0,2697,2699,1,0,0,0,2698,2696,1,0,0,0,2699,2700, + 5,4,0,0,2700,2702,1,0,0,0,2701,2677,1,0,0,0,2701,2678,1,0,0,0,2702,311, + 1,0,0,0,2703,2708,3,202,101,0,2704,2706,5,171,0,0,2705,2704,1,0,0,0,2705, + 2706,1,0,0,0,2706,2707,1,0,0,0,2707,2709,3,204,102,0,2708,2705,1,0,0, + 0,2709,2710,1,0,0,0,2710,2708,1,0,0,0,2710,2711,1,0,0,0,2711,313,1,0, + 0,0,2712,2714,5,82,0,0,2713,2715,5,171,0,0,2714,2713,1,0,0,0,2714,2715, + 1,0,0,0,2715,2716,1,0,0,0,2716,2718,5,9,0,0,2717,2719,5,171,0,0,2718, + 2717,1,0,0,0,2718,2719,1,0,0,0,2719,2720,1,0,0,0,2720,2722,5,105,0,0, + 2721,2723,5,171,0,0,2722,2721,1,0,0,0,2722,2723,1,0,0,0,2723,2724,1,0, + 0,0,2724,2729,3,194,97,0,2725,2727,5,171,0,0,2726,2725,1,0,0,0,2726,2727, + 1,0,0,0,2727,2728,1,0,0,0,2728,2730,3,192,96,0,2729,2726,1,0,0,0,2729, + 2730,1,0,0,0,2730,2732,1,0,0,0,2731,2733,5,171,0,0,2732,2731,1,0,0,0, + 2732,2733,1,0,0,0,2733,2734,1,0,0,0,2734,2735,5,10,0,0,2735,315,1,0,0, + 0,2736,2738,5,67,0,0,2737,2739,5,171,0,0,2738,2737,1,0,0,0,2738,2739, + 1,0,0,0,2739,2740,1,0,0,0,2740,2742,5,9,0,0,2741,2743,5,171,0,0,2742, + 2741,1,0,0,0,2742,2743,1,0,0,0,2743,2744,1,0,0,0,2744,2746,5,105,0,0, + 2745,2747,5,171,0,0,2746,2745,1,0,0,0,2746,2747,1,0,0,0,2747,2748,1,0, + 0,0,2748,2753,3,194,97,0,2749,2751,5,171,0,0,2750,2749,1,0,0,0,2750,2751, + 1,0,0,0,2751,2752,1,0,0,0,2752,2754,3,192,96,0,2753,2750,1,0,0,0,2753, + 2754,1,0,0,0,2754,2756,1,0,0,0,2755,2757,5,171,0,0,2756,2755,1,0,0,0, + 2756,2757,1,0,0,0,2757,2758,1,0,0,0,2758,2759,5,10,0,0,2759,317,1,0,0, + 0,2760,2762,5,5,0,0,2761,2763,5,171,0,0,2762,2761,1,0,0,0,2762,2763,1, + 0,0,0,2763,2766,1,0,0,0,2764,2767,3,334,167,0,2765,2767,5,151,0,0,2766, + 2764,1,0,0,0,2766,2765,1,0,0,0,2767,319,1,0,0,0,2768,2770,5,5,0,0,2769, + 2771,5,171,0,0,2770,2769,1,0,0,0,2770,2771,1,0,0,0,2771,2772,1,0,0,0, + 2772,2773,3,340,170,0,2773,321,1,0,0,0,2774,2779,5,58,0,0,2775,2777,5, + 171,0,0,2776,2775,1,0,0,0,2776,2777,1,0,0,0,2777,2778,1,0,0,0,2778,2780, + 3,324,162,0,2779,2776,1,0,0,0,2780,2781,1,0,0,0,2781,2779,1,0,0,0,2781, + 2782,1,0,0,0,2782,2797,1,0,0,0,2783,2785,5,58,0,0,2784,2786,5,171,0,0, + 2785,2784,1,0,0,0,2785,2786,1,0,0,0,2786,2787,1,0,0,0,2787,2792,3,234, + 117,0,2788,2790,5,171,0,0,2789,2788,1,0,0,0,2789,2790,1,0,0,0,2790,2791, + 1,0,0,0,2791,2793,3,324,162,0,2792,2789,1,0,0,0,2793,2794,1,0,0,0,2794, + 2792,1,0,0,0,2794,2795,1,0,0,0,2795,2797,1,0,0,0,2796,2774,1,0,0,0,2796, + 2783,1,0,0,0,2797,2806,1,0,0,0,2798,2800,5,171,0,0,2799,2798,1,0,0,0, + 2799,2800,1,0,0,0,2800,2801,1,0,0,0,2801,2803,5,79,0,0,2802,2804,5,171, + 0,0,2803,2802,1,0,0,0,2803,2804,1,0,0,0,2804,2805,1,0,0,0,2805,2807,3, + 234,117,0,2806,2799,1,0,0,0,2806,2807,1,0,0,0,2807,2809,1,0,0,0,2808, + 2810,5,171,0,0,2809,2808,1,0,0,0,2809,2810,1,0,0,0,2810,2811,1,0,0,0, + 2811,2812,5,80,0,0,2812,323,1,0,0,0,2813,2815,5,144,0,0,2814,2816,5,171, + 0,0,2815,2814,1,0,0,0,2815,2816,1,0,0,0,2816,2817,1,0,0,0,2817,2819,3, + 234,117,0,2818,2820,5,171,0,0,2819,2818,1,0,0,0,2819,2820,1,0,0,0,2820, + 2821,1,0,0,0,2821,2823,5,136,0,0,2822,2824,5,171,0,0,2823,2822,1,0,0, + 0,2823,2824,1,0,0,0,2824,2825,1,0,0,0,2825,2826,3,234,117,0,2826,325, + 1,0,0,0,2827,2828,3,342,171,0,2828,327,1,0,0,0,2829,2832,3,338,169,0, + 2830,2832,3,336,168,0,2831,2829,1,0,0,0,2831,2830,1,0,0,0,2832,329,1, + 0,0,0,2833,2836,5,26,0,0,2834,2837,3,342,171,0,2835,2837,5,159,0,0,2836, + 2834,1,0,0,0,2836,2835,1,0,0,0,2837,331,1,0,0,0,2838,2840,3,280,140,0, + 2839,2841,5,171,0,0,2840,2839,1,0,0,0,2840,2841,1,0,0,0,2841,2842,1,0, + 0,0,2842,2843,3,318,159,0,2843,333,1,0,0,0,2844,2845,3,340,170,0,2845, + 335,1,0,0,0,2846,2847,5,159,0,0,2847,337,1,0,0,0,2848,2849,5,166,0,0, + 2849,339,1,0,0,0,2850,2851,3,342,171,0,2851,341,1,0,0,0,2852,2858,5,167, + 0,0,2853,2854,5,170,0,0,2854,2858,6,171,-1,0,2855,2858,5,160,0,0,2856, + 2858,3,344,172,0,2857,2852,1,0,0,0,2857,2853,1,0,0,0,2857,2855,1,0,0, + 0,2857,2856,1,0,0,0,2858,343,1,0,0,0,2859,2860,7,7,0,0,2860,345,1,0,0, + 0,2861,2862,7,8,0,0,2862,347,1,0,0,0,2863,2864,7,9,0,0,2864,349,1,0,0, + 0,2865,2866,7,10,0,0,2866,351,1,0,0,0,491,354,358,363,367,372,375,379, + 382,407,413,417,420,426,429,433,437,441,446,450,457,461,469,473,483,487, + 491,496,509,513,521,524,532,535,550,555,561,565,568,571,577,581,587,591, + 596,611,615,637,641,644,647,650,653,657,662,666,676,680,685,690,695,701, + 705,709,714,721,725,729,732,736,740,759,763,767,771,775,780,799,803,807, + 820,824,828,832,836,840,842,846,850,852,867,871,875,879,883,888,891,895, + 899,901,905,909,911,930,941,948,961,968,974,977,987,990,998,1001,1007, + 1010,1016,1031,1047,1056,1082,1086,1091,1100,1104,1109,1115,1121,1125, + 1129,1137,1141,1145,1151,1155,1159,1165,1169,1173,1177,1181,1187,1191, + 1195,1199,1203,1207,1213,1220,1225,1231,1250,1254,1262,1270,1272,1282, + 1286,1290,1296,1300,1305,1310,1315,1320,1324,1329,1335,1340,1343,1347, + 1351,1355,1361,1365,1370,1375,1379,1382,1386,1390,1394,1398,1402,1408, + 1412,1417,1421,1430,1436,1444,1448,1452,1456,1463,1466,1469,1472,1476, + 1478,1484,1487,1491,1495,1499,1503,1507,1511,1516,1522,1526,1530,1534, + 1539,1543,1552,1556,1561,1575,1577,1579,1584,1594,1600,1607,1620,1624, + 1628,1632,1637,1642,1646,1652,1656,1660,1664,1669,1675,1678,1684,1687, + 1693,1697,1701,1705,1709,1714,1719,1723,1728,1731,1740,1749,1754,1767, + 1770,1778,1782,1787,1792,1796,1801,1807,1812,1819,1823,1827,1829,1833, + 1835,1839,1841,1847,1853,1857,1860,1863,1869,1872,1875,1879,1885,1888, + 1891,1895,1899,1903,1905,1909,1911,1915,1917,1921,1923,1929,1933,1937, + 1941,1945,1949,1953,1957,1961,1964,1970,1974,1978,1981,1986,1991,1996, + 2001,2007,2013,2016,2019,2022,2026,2029,2032,2035,2038,2042,2046,2050, + 2054,2058,2062,2064,2067,2071,2075,2079,2083,2085,2091,2094,2097,2103, + 2106,2109,2130,2140,2150,2155,2159,2166,2170,2174,2178,2182,2190,2194, + 2198,2202,2208,2212,2218,2222,2227,2232,2236,2241,2246,2250,2256,2263, + 2267,2273,2280,2284,2290,2297,2301,2306,2311,2315,2320,2323,2330,2333, + 2338,2347,2351,2354,2367,2370,2375,2389,2393,2398,2411,2415,2419,2423, + 2429,2433,2437,2443,2447,2451,2457,2461,2465,2469,2473,2476,2490,2496, + 2500,2504,2508,2511,2517,2520,2524,2528,2532,2536,2540,2547,2550,2554, + 2560,2564,2570,2574,2578,2583,2587,2591,2595,2600,2603,2606,2612,2616, + 2620,2622,2626,2630,2634,2638,2641,2645,2651,2656,2658,2662,2666,2671, + 2675,2680,2684,2688,2692,2696,2701,2705,2710,2714,2718,2722,2726,2729, + 2732,2738,2742,2746,2750,2753,2756,2762,2766,2770,2776,2781,2785,2789, + 2794,2796,2799,2803,2806,2809,2815,2819,2823,2831,2836,2840,2857 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); @@ -1367,29 +1381,29 @@ CypherParser::Ku_StatementsContext* CypherParser::ku_Statements() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(348); + setState(352); oC_Cypher(); - setState(359); + setState(363); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 2, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(350); + setState(354); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(349); + setState(353); match(CypherParser::SP); } - setState(352); + setState(356); match(CypherParser::T__0); - setState(354); + setState(358); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 1, _ctx)) { case 1: { - setState(353); + setState(357); match(CypherParser::SP); break; } @@ -1397,22 +1411,22 @@ CypherParser::Ku_StatementsContext* CypherParser::ku_Statements() { default: break; } - setState(356); + setState(360); oC_Cypher(); } - setState(361); + setState(365); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 2, _ctx); } - setState(363); + setState(367); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(362); + setState(366); match(CypherParser::SP); } - setState(365); + setState(369); match(CypherParser::EOF); } @@ -1467,41 +1481,41 @@ CypherParser::OC_CypherContext* CypherParser::oC_Cypher() { }); try { enterOuterAlt(_localctx, 1); - setState(368); + setState(372); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::EXPLAIN || _la == CypherParser::PROFILE) { - setState(367); + setState(371); oC_AnyCypherOption(); } - setState(371); + setState(375); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(370); + setState(374); match(CypherParser::SP); } - setState(373); + setState(377); oC_Statement(); - setState(378); + setState(382); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { case 1: { - setState(375); + setState(379); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(374); + setState(378); match(CypherParser::SP); } - setState(377); + setState(381); match(CypherParser::T__0); break; } @@ -1534,6 +1548,10 @@ CypherParser::KU_CreateNodeTableContext* CypherParser::OC_StatementContext::kU_C return getRuleContext(0); } +CypherParser::KU_CreateExternalNodeTableContext* CypherParser::OC_StatementContext::kU_CreateExternalNodeTable() { + return getRuleContext(0); +} + CypherParser::KU_CreateRelTableContext* CypherParser::OC_StatementContext::kU_CreateRelTable() { return getRuleContext(0); } @@ -1632,159 +1650,166 @@ CypherParser::OC_StatementContext* CypherParser::oC_Statement() { exitRule(); }); try { - setState(402); + setState(407); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 8, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(380); + setState(384); oC_Query(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(381); + setState(385); kU_CreateNodeTable(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(382); - kU_CreateRelTable(); + setState(386); + kU_CreateExternalNodeTable(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(383); - kU_CreateRelTableGroup(); + setState(387); + kU_CreateRelTable(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(384); - kU_CreateRdfGraph(); + setState(388); + kU_CreateRelTableGroup(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(385); - kU_CreateSequence(); + setState(389); + kU_CreateRdfGraph(); break; } case 7: { enterOuterAlt(_localctx, 7); - setState(386); - kU_CreateType(); + setState(390); + kU_CreateSequence(); break; } case 8: { enterOuterAlt(_localctx, 8); - setState(387); - kU_Drop(); + setState(391); + kU_CreateType(); break; } case 9: { enterOuterAlt(_localctx, 9); - setState(388); - kU_AlterTable(); + setState(392); + kU_Drop(); break; } case 10: { enterOuterAlt(_localctx, 10); - setState(389); - kU_CopyFrom(); + setState(393); + kU_AlterTable(); break; } case 11: { enterOuterAlt(_localctx, 11); - setState(390); - kU_CopyFromByColumn(); + setState(394); + kU_CopyFrom(); break; } case 12: { enterOuterAlt(_localctx, 12); - setState(391); - kU_CopyTO(); + setState(395); + kU_CopyFromByColumn(); break; } case 13: { enterOuterAlt(_localctx, 13); - setState(392); - kU_StandaloneCall(); + setState(396); + kU_CopyTO(); break; } case 14: { enterOuterAlt(_localctx, 14); - setState(393); - kU_CreateMacro(); + setState(397); + kU_StandaloneCall(); break; } case 15: { enterOuterAlt(_localctx, 15); - setState(394); - kU_CommentOn(); + setState(398); + kU_CreateMacro(); break; } case 16: { enterOuterAlt(_localctx, 16); - setState(395); - kU_Transaction(); + setState(399); + kU_CommentOn(); break; } case 17: { enterOuterAlt(_localctx, 17); - setState(396); - kU_Extension(); + setState(400); + kU_Transaction(); break; } case 18: { enterOuterAlt(_localctx, 18); - setState(397); - kU_ExportDatabase(); + setState(401); + kU_Extension(); break; } case 19: { enterOuterAlt(_localctx, 19); - setState(398); - kU_ImportDatabase(); + setState(402); + kU_ExportDatabase(); break; } case 20: { enterOuterAlt(_localctx, 20); - setState(399); - kU_AttachDatabase(); + setState(403); + kU_ImportDatabase(); break; } case 21: { enterOuterAlt(_localctx, 21); - setState(400); - kU_DetachDatabase(); + setState(404); + kU_AttachDatabase(); break; } case 22: { enterOuterAlt(_localctx, 22); - setState(401); + setState(405); + kU_DetachDatabase(); + break; + } + + case 23: { + enterOuterAlt(_localctx, 23); + setState(406); kU_UseDatabase(); break; } @@ -1861,39 +1886,39 @@ CypherParser::KU_CopyFromContext* CypherParser::kU_CopyFrom() { }); try { enterOuterAlt(_localctx, 1); - setState(404); + setState(409); match(CypherParser::COPY); - setState(405); + setState(410); match(CypherParser::SP); - setState(406); + setState(411); oC_SchemaName(); - setState(415); + setState(420); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { case 1: { - setState(408); + setState(413); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(407); + setState(412); match(CypherParser::SP); } - setState(410); + setState(415); kU_ColumnNames(); - setState(412); + setState(417); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(411); + setState(416); match(CypherParser::SP); } break; } case 2: { - setState(414); + setState(419); match(CypherParser::SP); break; } @@ -1901,26 +1926,26 @@ CypherParser::KU_CopyFromContext* CypherParser::kU_CopyFrom() { default: break; } - setState(417); + setState(422); match(CypherParser::FROM); - setState(418); + setState(423); match(CypherParser::SP); - setState(419); - kU_ScanSource(); setState(424); + kU_ScanSource(); + setState(429); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 13, _ctx)) { case 1: { - setState(421); + setState(426); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(420); + setState(425); match(CypherParser::SP); } - setState(423); + setState(428); kU_ParsingOptions(); break; } @@ -1982,57 +2007,57 @@ CypherParser::KU_ColumnNamesContext* CypherParser::kU_ColumnNames() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(426); + setState(431); match(CypherParser::T__1); - setState(428); + setState(433); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(427); + setState(432); match(CypherParser::SP); } - setState(430); + setState(435); oC_SchemaName(); - setState(441); + setState(446); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 17, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(432); + setState(437); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(431); + setState(436); match(CypherParser::SP); } - setState(434); + setState(439); match(CypherParser::T__2); - setState(436); + setState(441); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(435); + setState(440); match(CypherParser::SP); } - setState(438); + setState(443); oC_SchemaName(); } - setState(443); + setState(448); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 17, _ctx); } - setState(445); + setState(450); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(444); + setState(449); match(CypherParser::SP); } - setState(447); + setState(452); match(CypherParser::T__3); } @@ -2094,65 +2119,65 @@ CypherParser::KU_ScanSourceContext* CypherParser::kU_ScanSource() { exitRule(); }); try { - setState(468); + setState(473); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 22, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(449); + setState(454); kU_FilePaths(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(450); + setState(455); match(CypherParser::T__1); - setState(452); + setState(457); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(451); + setState(456); match(CypherParser::SP); } - setState(454); + setState(459); oC_Query(); - setState(456); + setState(461); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(455); + setState(460); match(CypherParser::SP); } - setState(458); + setState(463); match(CypherParser::T__3); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(460); + setState(465); oC_Variable(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(461); + setState(466); oC_Variable(); - setState(462); + setState(467); match(CypherParser::T__4); - setState(464); + setState(469); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(463); + setState(468); match(CypherParser::SP); } - setState(466); + setState(471); oC_SchemaName(); break; } @@ -2233,67 +2258,67 @@ CypherParser::KU_CopyFromByColumnContext* CypherParser::kU_CopyFromByColumn() { }); try { enterOuterAlt(_localctx, 1); - setState(470); + setState(475); match(CypherParser::COPY); - setState(471); + setState(476); match(CypherParser::SP); - setState(472); + setState(477); oC_SchemaName(); - setState(473); + setState(478); match(CypherParser::SP); - setState(474); + setState(479); match(CypherParser::FROM); - setState(475); + setState(480); match(CypherParser::SP); - setState(476); + setState(481); match(CypherParser::T__1); - setState(478); + setState(483); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(477); + setState(482); match(CypherParser::SP); } - setState(480); + setState(485); match(CypherParser::StringLiteral); - setState(491); + setState(496); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2 || _la == CypherParser::SP) { - setState(482); + setState(487); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(481); + setState(486); match(CypherParser::SP); } - setState(484); + setState(489); match(CypherParser::T__2); - setState(486); + setState(491); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(485); + setState(490); match(CypherParser::SP); } - setState(488); - match(CypherParser::StringLiteral); setState(493); + match(CypherParser::StringLiteral); + setState(498); _errHandler->sync(this); _la = _input->LA(1); } - setState(494); + setState(499); match(CypherParser::T__3); - setState(495); + setState(500); match(CypherParser::SP); - setState(496); + setState(501); match(CypherParser::BY); - setState(497); + setState(502); match(CypherParser::SP); - setState(498); + setState(503); match(CypherParser::COLUMN); } @@ -2360,54 +2385,54 @@ CypherParser::KU_CopyTOContext* CypherParser::kU_CopyTO() { }); try { enterOuterAlt(_localctx, 1); - setState(500); + setState(505); match(CypherParser::COPY); - setState(501); + setState(506); match(CypherParser::SP); - setState(502); + setState(507); match(CypherParser::T__1); - setState(504); + setState(509); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(503); + setState(508); match(CypherParser::SP); } - setState(506); + setState(511); oC_Query(); - setState(508); + setState(513); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(507); + setState(512); match(CypherParser::SP); } - setState(510); + setState(515); match(CypherParser::T__3); - setState(511); + setState(516); match(CypherParser::SP); - setState(512); + setState(517); match(CypherParser::TO); - setState(513); + setState(518); match(CypherParser::SP); - setState(514); - match(CypherParser::StringLiteral); setState(519); + match(CypherParser::StringLiteral); + setState(524); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 30, _ctx)) { case 1: { - setState(516); + setState(521); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(515); + setState(520); match(CypherParser::SP); } - setState(518); + setState(523); kU_ParsingOptions(); break; } @@ -2476,30 +2501,30 @@ CypherParser::KU_ExportDatabaseContext* CypherParser::kU_ExportDatabase() { }); try { enterOuterAlt(_localctx, 1); - setState(521); + setState(526); match(CypherParser::EXPORT); - setState(522); + setState(527); match(CypherParser::SP); - setState(523); + setState(528); match(CypherParser::DATABASE); - setState(524); + setState(529); match(CypherParser::SP); - setState(525); - match(CypherParser::StringLiteral); setState(530); + match(CypherParser::StringLiteral); + setState(535); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 32, _ctx)) { case 1: { - setState(527); + setState(532); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(526); + setState(531); match(CypherParser::SP); } - setState(529); + setState(534); kU_ParsingOptions(); break; } @@ -2563,15 +2588,15 @@ CypherParser::KU_ImportDatabaseContext* CypherParser::kU_ImportDatabase() { }); try { enterOuterAlt(_localctx, 1); - setState(532); + setState(537); match(CypherParser::IMPORT); - setState(533); + setState(538); match(CypherParser::SP); - setState(534); + setState(539); match(CypherParser::DATABASE); - setState(535); + setState(540); match(CypherParser::SP); - setState(536); + setState(541); match(CypherParser::StringLiteral); } @@ -2646,24 +2671,24 @@ CypherParser::KU_AttachDatabaseContext* CypherParser::kU_AttachDatabase() { }); try { enterOuterAlt(_localctx, 1); - setState(538); + setState(543); match(CypherParser::ATTACH); - setState(539); + setState(544); match(CypherParser::SP); - setState(540); - match(CypherParser::StringLiteral); setState(545); + match(CypherParser::StringLiteral); + setState(550); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 33, _ctx)) { case 1: { - setState(541); + setState(546); match(CypherParser::SP); - setState(542); + setState(547); match(CypherParser::AS); - setState(543); + setState(548); match(CypherParser::SP); - setState(544); + setState(549); oC_SchemaName(); break; } @@ -2671,48 +2696,48 @@ CypherParser::KU_AttachDatabaseContext* CypherParser::kU_AttachDatabase() { default: break; } - setState(547); + setState(552); match(CypherParser::SP); - setState(548); + setState(553); match(CypherParser::T__1); - setState(550); + setState(555); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(549); + setState(554); match(CypherParser::SP); } - setState(552); + setState(557); match(CypherParser::DBTYPE); - setState(553); + setState(558); match(CypherParser::SP); - setState(554); + setState(559); oC_SymbolicName(); - setState(563); + setState(568); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 37, _ctx)) { case 1: { - setState(556); + setState(561); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(555); + setState(560); match(CypherParser::SP); } - setState(558); + setState(563); match(CypherParser::T__2); - setState(560); + setState(565); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(559); + setState(564); match(CypherParser::SP); } - setState(562); + setState(567); kU_Options(); break; } @@ -2720,15 +2745,15 @@ CypherParser::KU_AttachDatabaseContext* CypherParser::kU_AttachDatabase() { default: break; } - setState(566); + setState(571); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(565); + setState(570); match(CypherParser::SP); } - setState(568); + setState(573); match(CypherParser::T__3); } @@ -2783,27 +2808,27 @@ CypherParser::KU_OptionContext* CypherParser::kU_Option() { }); try { enterOuterAlt(_localctx, 1); - setState(570); + setState(575); oC_SymbolicName(); - setState(572); + setState(577); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(571); + setState(576); match(CypherParser::SP); } - setState(574); + setState(579); match(CypherParser::T__5); - setState(576); + setState(581); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(575); + setState(580); match(CypherParser::SP); } - setState(578); + setState(583); oC_Literal(); } @@ -2859,35 +2884,35 @@ CypherParser::KU_OptionsContext* CypherParser::kU_Options() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(580); + setState(585); kU_Option(); - setState(591); + setState(596); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 43, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(582); + setState(587); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(581); + setState(586); match(CypherParser::SP); } - setState(584); + setState(589); match(CypherParser::T__2); - setState(586); + setState(591); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(585); + setState(590); match(CypherParser::SP); } - setState(588); + setState(593); kU_Option(); } - setState(593); + setState(598); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 43, _ctx); } @@ -2939,11 +2964,11 @@ CypherParser::KU_DetachDatabaseContext* CypherParser::kU_DetachDatabase() { }); try { enterOuterAlt(_localctx, 1); - setState(594); + setState(599); match(CypherParser::DETACH); - setState(595); + setState(600); match(CypherParser::SP); - setState(596); + setState(601); oC_SchemaName(); } @@ -2993,11 +3018,11 @@ CypherParser::KU_UseDatabaseContext* CypherParser::kU_UseDatabase() { }); try { enterOuterAlt(_localctx, 1); - setState(598); + setState(603); match(CypherParser::USE); - setState(599); + setState(604); match(CypherParser::SP); - setState(600); + setState(605); oC_SchemaName(); } @@ -3056,31 +3081,31 @@ CypherParser::KU_StandaloneCallContext* CypherParser::kU_StandaloneCall() { }); try { enterOuterAlt(_localctx, 1); - setState(602); + setState(607); match(CypherParser::CALL); - setState(603); + setState(608); match(CypherParser::SP); - setState(604); + setState(609); oC_SymbolicName(); - setState(606); + setState(611); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(605); + setState(610); match(CypherParser::SP); } - setState(608); + setState(613); match(CypherParser::T__5); - setState(610); + setState(615); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(609); + setState(614); match(CypherParser::SP); } - setState(612); + setState(617); oC_Expression(); } @@ -3150,27 +3175,27 @@ CypherParser::KU_CommentOnContext* CypherParser::kU_CommentOn() { }); try { enterOuterAlt(_localctx, 1); - setState(614); + setState(619); match(CypherParser::COMMENT); - setState(615); + setState(620); match(CypherParser::SP); - setState(616); + setState(621); match(CypherParser::ON); - setState(617); + setState(622); match(CypherParser::SP); - setState(618); + setState(623); match(CypherParser::TABLE); - setState(619); + setState(624); match(CypherParser::SP); - setState(620); + setState(625); oC_SchemaName(); - setState(621); + setState(626); match(CypherParser::SP); - setState(622); + setState(627); match(CypherParser::IS); - setState(623); + setState(628); match(CypherParser::SP); - setState(624); + setState(629); match(CypherParser::StringLiteral); } @@ -3250,32 +3275,32 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(626); + setState(631); match(CypherParser::CREATE); - setState(627); + setState(632); match(CypherParser::SP); - setState(628); + setState(633); match(CypherParser::MACRO); - setState(629); + setState(634); match(CypherParser::SP); - setState(630); + setState(635); oC_FunctionName(); - setState(632); + setState(637); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(631); + setState(636); match(CypherParser::SP); } - setState(634); + setState(639); match(CypherParser::T__1); - setState(636); + setState(641); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 47, _ctx)) { case 1: { - setState(635); + setState(640); match(CypherParser::SP); break; } @@ -3283,12 +3308,12 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { default: break; } - setState(639); + setState(644); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 48, _ctx)) { case 1: { - setState(638); + setState(643); kU_PositionalArgs(); break; } @@ -3296,12 +3321,12 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { default: break; } - setState(642); + setState(647); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 49, _ctx)) { case 1: { - setState(641); + setState(646); match(CypherParser::SP); break; } @@ -3309,63 +3334,63 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { default: break; } - setState(645); + setState(650); _errHandler->sync(this); _la = _input->LA(1); if (((((_la - 47) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 47)) & -2383877064657885291) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 121)) & 316935604865917) != 0)) { - setState(644); + ((1ULL << (_la - 47)) & -4767754613118097515) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 111)) & 649084118765398017) != 0)) { + setState(649); kU_DefaultArg(); } - setState(657); + setState(662); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 53, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(648); + setState(653); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(647); + setState(652); match(CypherParser::SP); } - setState(650); + setState(655); match(CypherParser::T__2); - setState(652); + setState(657); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(651); + setState(656); match(CypherParser::SP); } - setState(654); + setState(659); kU_DefaultArg(); } - setState(659); + setState(664); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 53, _ctx); } - setState(661); + setState(666); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(660); + setState(665); match(CypherParser::SP); } - setState(663); + setState(668); match(CypherParser::T__3); - setState(664); + setState(669); match(CypherParser::SP); - setState(665); + setState(670); match(CypherParser::AS); - setState(666); + setState(671); match(CypherParser::SP); - setState(667); + setState(672); oC_Expression(); } @@ -3421,35 +3446,35 @@ CypherParser::KU_PositionalArgsContext* CypherParser::kU_PositionalArgs() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(669); + setState(674); oC_SymbolicName(); - setState(680); + setState(685); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 57, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(671); + setState(676); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(670); + setState(675); match(CypherParser::SP); } - setState(673); + setState(678); match(CypherParser::T__2); - setState(675); + setState(680); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(674); + setState(679); match(CypherParser::SP); } - setState(677); + setState(682); oC_SymbolicName(); } - setState(682); + setState(687); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 57, _ctx); } @@ -3510,29 +3535,29 @@ CypherParser::KU_DefaultArgContext* CypherParser::kU_DefaultArg() { }); try { enterOuterAlt(_localctx, 1); - setState(683); + setState(688); oC_SymbolicName(); - setState(685); + setState(690); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(684); + setState(689); match(CypherParser::SP); } - setState(687); + setState(692); match(CypherParser::COLON); - setState(688); + setState(693); match(CypherParser::T__5); - setState(690); + setState(695); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(689); + setState(694); match(CypherParser::SP); } - setState(692); + setState(697); oC_Literal(); } @@ -3590,96 +3615,96 @@ CypherParser::KU_FilePathsContext* CypherParser::kU_FilePaths() { exitRule(); }); try { - setState(727); + setState(732); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::T__6: { enterOuterAlt(_localctx, 1); - setState(694); + setState(699); match(CypherParser::T__6); - setState(696); + setState(701); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(695); + setState(700); match(CypherParser::SP); } - setState(698); + setState(703); match(CypherParser::StringLiteral); - setState(709); + setState(714); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2 || _la == CypherParser::SP) { - setState(700); + setState(705); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(699); + setState(704); match(CypherParser::SP); } - setState(702); + setState(707); match(CypherParser::T__2); - setState(704); + setState(709); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(703); + setState(708); match(CypherParser::SP); } - setState(706); - match(CypherParser::StringLiteral); setState(711); + match(CypherParser::StringLiteral); + setState(716); _errHandler->sync(this); _la = _input->LA(1); } - setState(712); + setState(717); match(CypherParser::T__7); break; } case CypherParser::StringLiteral: { enterOuterAlt(_localctx, 2); - setState(713); + setState(718); match(CypherParser::StringLiteral); break; } case CypherParser::GLOB: { enterOuterAlt(_localctx, 3); - setState(714); + setState(719); match(CypherParser::GLOB); - setState(716); + setState(721); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(715); + setState(720); match(CypherParser::SP); } - setState(718); + setState(723); match(CypherParser::T__1); - setState(720); + setState(725); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(719); + setState(724); match(CypherParser::SP); } - setState(722); + setState(727); match(CypherParser::StringLiteral); - setState(724); + setState(729); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(723); + setState(728); match(CypherParser::SP); } - setState(726); + setState(731); match(CypherParser::T__3); break; } @@ -3736,27 +3761,27 @@ CypherParser::KU_ParsingOptionsContext* CypherParser::kU_ParsingOptions() { }); try { enterOuterAlt(_localctx, 1); - setState(729); + setState(734); match(CypherParser::T__1); - setState(731); + setState(736); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(730); + setState(735); match(CypherParser::SP); } - setState(733); + setState(738); kU_Options(); - setState(735); + setState(740); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(734); + setState(739); match(CypherParser::SP); } - setState(737); + setState(742); match(CypherParser::T__3); } @@ -3814,15 +3839,15 @@ CypherParser::KU_IfNotExistsContext* CypherParser::kU_IfNotExists() { }); try { enterOuterAlt(_localctx, 1); - setState(739); + setState(744); match(CypherParser::IF); - setState(740); + setState(745); match(CypherParser::SP); - setState(741); + setState(746); match(CypherParser::NOT); - setState(742); + setState(747); match(CypherParser::SP); - setState(743); + setState(748); match(CypherParser::EXISTS); } @@ -3869,8 +3894,8 @@ CypherParser::KU_PropertyDefinitionsContext* CypherParser::KU_CreateNodeTableCon return getRuleContext(0); } -CypherParser::KU_CreateNodeConstraintContext* CypherParser::KU_CreateNodeTableContext::kU_CreateNodeConstraint() { - return getRuleContext(0); +CypherParser::KU_PrimaryKeyContext* CypherParser::KU_CreateNodeTableContext::kU_PrimaryKey() { + return getRuleContext(0); } CypherParser::KU_IfNotExistsContext* CypherParser::KU_CreateNodeTableContext::kU_IfNotExists() { @@ -3897,26 +3922,26 @@ CypherParser::KU_CreateNodeTableContext* CypherParser::kU_CreateNodeTable() { }); try { enterOuterAlt(_localctx, 1); - setState(745); + setState(750); match(CypherParser::CREATE); - setState(746); + setState(751); match(CypherParser::SP); - setState(747); + setState(752); match(CypherParser::NODE); - setState(748); + setState(753); match(CypherParser::SP); - setState(749); + setState(754); match(CypherParser::TABLE); - setState(750); + setState(755); match(CypherParser::SP); - setState(754); + setState(759); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 70, _ctx)) { case 1: { - setState(751); + setState(756); kU_IfNotExists(); - setState(752); + setState(757); match(CypherParser::SP); break; } @@ -3924,58 +3949,197 @@ CypherParser::KU_CreateNodeTableContext* CypherParser::kU_CreateNodeTable() { default: break; } - setState(756); + setState(761); oC_SchemaName(); - setState(758); + setState(763); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(757); + setState(762); match(CypherParser::SP); } - setState(760); + setState(765); match(CypherParser::T__1); - setState(762); + setState(767); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(761); + setState(766); match(CypherParser::SP); } - setState(764); + setState(769); kU_PropertyDefinitions(); - setState(766); + setState(771); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(765); + setState(770); match(CypherParser::SP); } - setState(768); + setState(773); match(CypherParser::T__2); - setState(770); + setState(775); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(769); + setState(774); match(CypherParser::SP); } - setState(772); - kU_CreateNodeConstraint(); - setState(775); + setState(777); + kU_PrimaryKey(); + setState(780); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(774); + setState(779); match(CypherParser::SP); } - setState(777); + setState(782); + match(CypherParser::T__3); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- KU_CreateExternalNodeTableContext ------------------------------------------------------------------ + +CypherParser::KU_CreateExternalNodeTableContext::KU_CreateExternalNodeTableContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* CypherParser::KU_CreateExternalNodeTableContext::CREATE() { + return getToken(CypherParser::CREATE, 0); +} + +std::vector CypherParser::KU_CreateExternalNodeTableContext::SP() { + return getTokens(CypherParser::SP); +} + +tree::TerminalNode* CypherParser::KU_CreateExternalNodeTableContext::SP(size_t i) { + return getToken(CypherParser::SP, i); +} + +tree::TerminalNode* CypherParser::KU_CreateExternalNodeTableContext::EXTERNAL() { + return getToken(CypherParser::EXTERNAL, 0); +} + +tree::TerminalNode* CypherParser::KU_CreateExternalNodeTableContext::NODE() { + return getToken(CypherParser::NODE, 0); +} + +tree::TerminalNode* CypherParser::KU_CreateExternalNodeTableContext::TABLE() { + return getToken(CypherParser::TABLE, 0); +} + +std::vector CypherParser::KU_CreateExternalNodeTableContext::oC_SchemaName() { + return getRuleContexts(); +} + +CypherParser::OC_SchemaNameContext* CypherParser::KU_CreateExternalNodeTableContext::oC_SchemaName(size_t i) { + return getRuleContext(i); +} + +tree::TerminalNode* CypherParser::KU_CreateExternalNodeTableContext::AS() { + return getToken(CypherParser::AS, 0); +} + +CypherParser::KU_TableLookupContext* CypherParser::KU_CreateExternalNodeTableContext::kU_TableLookup() { + return getRuleContext(0); +} + +CypherParser::KU_PrimaryKeyContext* CypherParser::KU_CreateExternalNodeTableContext::kU_PrimaryKey() { + return getRuleContext(0); +} + + +size_t CypherParser::KU_CreateExternalNodeTableContext::getRuleIndex() const { + return CypherParser::RuleKU_CreateExternalNodeTable; +} + + +CypherParser::KU_CreateExternalNodeTableContext* CypherParser::kU_CreateExternalNodeTable() { + KU_CreateExternalNodeTableContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, CypherParser::RuleKU_CreateExternalNodeTable); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(784); + match(CypherParser::CREATE); + setState(785); + match(CypherParser::SP); + setState(786); + match(CypherParser::EXTERNAL); + setState(787); + match(CypherParser::SP); + setState(788); + match(CypherParser::NODE); + setState(789); + match(CypherParser::SP); + setState(790); + match(CypherParser::TABLE); + setState(791); + match(CypherParser::SP); + setState(792); + oC_SchemaName(); + setState(793); + match(CypherParser::SP); + setState(794); + match(CypherParser::AS); + setState(795); + match(CypherParser::SP); + setState(796); + oC_SchemaName(); + setState(797); + kU_TableLookup(); + setState(799); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(798); + match(CypherParser::SP); + } + setState(801); + match(CypherParser::T__1); + setState(803); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(802); + match(CypherParser::SP); + } + setState(805); + kU_PrimaryKey(); + setState(807); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(806); + match(CypherParser::SP); + } + setState(809); match(CypherParser::T__3); } @@ -4042,7 +4206,7 @@ size_t CypherParser::KU_CreateRelTableContext::getRuleIndex() const { CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { KU_CreateRelTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 48, CypherParser::RuleKU_CreateRelTable); + enterRule(_localctx, 50, CypherParser::RuleKU_CreateRelTable); size_t _la = 0; #if __cplusplus > 201703L @@ -4054,26 +4218,26 @@ CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { }); try { enterOuterAlt(_localctx, 1); - setState(779); + setState(811); match(CypherParser::CREATE); - setState(780); + setState(812); match(CypherParser::SP); - setState(781); + setState(813); match(CypherParser::REL); - setState(782); + setState(814); match(CypherParser::SP); - setState(783); + setState(815); match(CypherParser::TABLE); - setState(784); + setState(816); match(CypherParser::SP); - setState(788); + setState(820); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 76, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 79, _ctx)) { case 1: { - setState(785); + setState(817); kU_IfNotExists(); - setState(786); + setState(818); match(CypherParser::SP); break; } @@ -4081,59 +4245,59 @@ CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { default: break; } - setState(790); + setState(822); oC_SchemaName(); - setState(792); + setState(824); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(791); + setState(823); match(CypherParser::SP); } - setState(794); + setState(826); match(CypherParser::T__1); - setState(796); + setState(828); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(795); + setState(827); match(CypherParser::SP); } - setState(798); + setState(830); kU_RelTableConnection(); - setState(800); + setState(832); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(799); + setState(831); match(CypherParser::SP); } - setState(810); + setState(842); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 82, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 85, _ctx)) { case 1: { - setState(802); + setState(834); match(CypherParser::T__2); - setState(804); + setState(836); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(803); + setState(835); match(CypherParser::SP); } - setState(806); + setState(838); kU_PropertyDefinitions(); - setState(808); + setState(840); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(807); + setState(839); match(CypherParser::SP); } break; @@ -4142,33 +4306,33 @@ CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { default: break; } - setState(820); + setState(852); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__2) { - setState(812); + setState(844); match(CypherParser::T__2); - setState(814); + setState(846); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(813); + setState(845); match(CypherParser::SP); } - setState(816); + setState(848); oC_SymbolicName(); - setState(818); + setState(850); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(817); + setState(849); match(CypherParser::SP); } } - setState(822); + setState(854); match(CypherParser::T__3); } @@ -4243,7 +4407,7 @@ size_t CypherParser::KU_CreateRelTableGroupContext::getRuleIndex() const { CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGroup() { KU_CreateRelTableGroupContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 50, CypherParser::RuleKU_CreateRelTableGroup); + enterRule(_localctx, 52, CypherParser::RuleKU_CreateRelTableGroup); size_t _la = 0; #if __cplusplus > 201703L @@ -4256,30 +4420,30 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou try { size_t alt; enterOuterAlt(_localctx, 1); - setState(824); + setState(856); match(CypherParser::CREATE); - setState(825); + setState(857); match(CypherParser::SP); - setState(826); + setState(858); match(CypherParser::REL); - setState(827); + setState(859); match(CypherParser::SP); - setState(828); + setState(860); match(CypherParser::TABLE); - setState(829); + setState(861); match(CypherParser::SP); - setState(830); + setState(862); match(CypherParser::GROUP); - setState(831); + setState(863); match(CypherParser::SP); - setState(835); + setState(867); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 86, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 89, _ctx)) { case 1: { - setState(832); + setState(864); kU_IfNotExists(); - setState(833); + setState(865); match(CypherParser::SP); break; } @@ -4287,53 +4451,53 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou default: break; } - setState(837); + setState(869); oC_SchemaName(); - setState(839); + setState(871); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(838); + setState(870); match(CypherParser::SP); } - setState(841); + setState(873); match(CypherParser::T__1); - setState(843); + setState(875); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(842); + setState(874); match(CypherParser::SP); } - setState(845); + setState(877); kU_RelTableConnection(); - setState(854); + setState(886); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(847); + setState(879); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(846); + setState(878); match(CypherParser::SP); } - setState(849); + setState(881); match(CypherParser::T__2); - setState(851); + setState(883); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(850); + setState(882); match(CypherParser::SP); } - setState(853); + setState(885); kU_RelTableConnection(); break; } @@ -4341,41 +4505,41 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou default: throw NoViableAltException(this); } - setState(856); + setState(888); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 91, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 94, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); - setState(859); + setState(891); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(858); + setState(890); match(CypherParser::SP); } - setState(869); + setState(901); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 95, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 98, _ctx)) { case 1: { - setState(861); + setState(893); match(CypherParser::T__2); - setState(863); + setState(895); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(862); + setState(894); match(CypherParser::SP); } - setState(865); + setState(897); kU_PropertyDefinitions(); - setState(867); + setState(899); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(866); + setState(898); match(CypherParser::SP); } break; @@ -4384,33 +4548,33 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou default: break; } - setState(879); + setState(911); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__2) { - setState(871); + setState(903); match(CypherParser::T__2); - setState(873); + setState(905); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(872); + setState(904); match(CypherParser::SP); } - setState(875); + setState(907); oC_SymbolicName(); - setState(877); + setState(909); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(876); + setState(908); match(CypherParser::SP); } } - setState(881); + setState(913); match(CypherParser::T__3); } @@ -4461,7 +4625,7 @@ size_t CypherParser::KU_RelTableConnectionContext::getRuleIndex() const { CypherParser::KU_RelTableConnectionContext* CypherParser::kU_RelTableConnection() { KU_RelTableConnectionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 52, CypherParser::RuleKU_RelTableConnection); + enterRule(_localctx, 54, CypherParser::RuleKU_RelTableConnection); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4472,19 +4636,19 @@ CypherParser::KU_RelTableConnectionContext* CypherParser::kU_RelTableConnection( }); try { enterOuterAlt(_localctx, 1); - setState(883); + setState(915); match(CypherParser::FROM); - setState(884); + setState(916); match(CypherParser::SP); - setState(885); + setState(917); oC_SchemaName(); - setState(886); + setState(918); match(CypherParser::SP); - setState(887); + setState(919); match(CypherParser::TO); - setState(888); + setState(920); match(CypherParser::SP); - setState(889); + setState(921); oC_SchemaName(); } @@ -4535,7 +4699,7 @@ size_t CypherParser::KU_CreateRdfGraphContext::getRuleIndex() const { CypherParser::KU_CreateRdfGraphContext* CypherParser::kU_CreateRdfGraph() { KU_CreateRdfGraphContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 54, CypherParser::RuleKU_CreateRdfGraph); + enterRule(_localctx, 56, CypherParser::RuleKU_CreateRdfGraph); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4546,22 +4710,22 @@ CypherParser::KU_CreateRdfGraphContext* CypherParser::kU_CreateRdfGraph() { }); try { enterOuterAlt(_localctx, 1); - setState(891); + setState(923); match(CypherParser::CREATE); - setState(892); + setState(924); match(CypherParser::SP); - setState(893); + setState(925); match(CypherParser::RDFGRAPH); - setState(894); + setState(926); match(CypherParser::SP); - setState(898); + setState(930); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 99, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 102, _ctx)) { case 1: { - setState(895); + setState(927); kU_IfNotExists(); - setState(896); + setState(928); match(CypherParser::SP); break; } @@ -4569,7 +4733,7 @@ CypherParser::KU_CreateRdfGraphContext* CypherParser::kU_CreateRdfGraph() { default: break; } - setState(900); + setState(932); oC_SchemaName(); } @@ -4628,7 +4792,7 @@ size_t CypherParser::KU_CreateSequenceContext::getRuleIndex() const { CypherParser::KU_CreateSequenceContext* CypherParser::kU_CreateSequence() { KU_CreateSequenceContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 56, CypherParser::RuleKU_CreateSequence); + enterRule(_localctx, 58, CypherParser::RuleKU_CreateSequence); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4640,22 +4804,22 @@ CypherParser::KU_CreateSequenceContext* CypherParser::kU_CreateSequence() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(902); + setState(934); match(CypherParser::CREATE); - setState(903); + setState(935); match(CypherParser::SP); - setState(904); + setState(936); match(CypherParser::SEQUENCE); - setState(905); + setState(937); match(CypherParser::SP); - setState(909); + setState(941); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 100, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 103, _ctx)) { case 1: { - setState(906); + setState(938); kU_IfNotExists(); - setState(907); + setState(939); match(CypherParser::SP); break; } @@ -4663,21 +4827,21 @@ CypherParser::KU_CreateSequenceContext* CypherParser::kU_CreateSequence() { default: break; } - setState(911); + setState(943); oC_SchemaName(); - setState(916); + setState(948); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 101, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 104, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(912); + setState(944); match(CypherParser::SP); - setState(913); + setState(945); kU_SequenceOptions(); } - setState(918); + setState(950); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 101, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 104, _ctx); } } @@ -4732,7 +4896,7 @@ size_t CypherParser::KU_CreateTypeContext::getRuleIndex() const { CypherParser::KU_CreateTypeContext* CypherParser::kU_CreateType() { KU_CreateTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 58, CypherParser::RuleKU_CreateType); + enterRule(_localctx, 60, CypherParser::RuleKU_CreateType); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4743,30 +4907,30 @@ CypherParser::KU_CreateTypeContext* CypherParser::kU_CreateType() { }); try { enterOuterAlt(_localctx, 1); - setState(919); + setState(951); match(CypherParser::CREATE); - setState(920); + setState(952); match(CypherParser::SP); - setState(921); + setState(953); match(CypherParser::TYPE); - setState(922); + setState(954); match(CypherParser::SP); - setState(923); + setState(955); oC_SchemaName(); - setState(924); + setState(956); match(CypherParser::SP); - setState(925); + setState(957); match(CypherParser::AS); - setState(926); + setState(958); match(CypherParser::SP); - setState(927); + setState(959); kU_DataType(0); - setState(929); + setState(961); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 102, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 105, _ctx)) { case 1: { - setState(928); + setState(960); match(CypherParser::SP); break; } @@ -4819,7 +4983,7 @@ size_t CypherParser::KU_SequenceOptionsContext::getRuleIndex() const { CypherParser::KU_SequenceOptionsContext* CypherParser::kU_SequenceOptions() { KU_SequenceOptionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 60, CypherParser::RuleKU_SequenceOptions); + enterRule(_localctx, 62, CypherParser::RuleKU_SequenceOptions); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4829,40 +4993,40 @@ CypherParser::KU_SequenceOptionsContext* CypherParser::kU_SequenceOptions() { exitRule(); }); try { - setState(936); + setState(968); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 103, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 106, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(931); + setState(963); kU_IncrementBy(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(932); + setState(964); kU_MinValue(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(933); + setState(965); kU_MaxValue(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(934); + setState(966); kU_StartWith(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(935); + setState(967); kU_Cycle(); break; } @@ -4919,7 +5083,7 @@ size_t CypherParser::KU_IncrementByContext::getRuleIndex() const { CypherParser::KU_IncrementByContext* CypherParser::kU_IncrementBy() { KU_IncrementByContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 62, CypherParser::RuleKU_IncrementBy); + enterRule(_localctx, 64, CypherParser::RuleKU_IncrementBy); size_t _la = 0; #if __cplusplus > 201703L @@ -4931,29 +5095,29 @@ CypherParser::KU_IncrementByContext* CypherParser::kU_IncrementBy() { }); try { enterOuterAlt(_localctx, 1); - setState(938); + setState(970); match(CypherParser::INCREMENT); - setState(939); + setState(971); match(CypherParser::SP); - setState(942); + setState(974); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::BY) { - setState(940); + setState(972); match(CypherParser::BY); - setState(941); + setState(973); match(CypherParser::SP); } - setState(945); + setState(977); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::MINUS) { - setState(944); + setState(976); match(CypherParser::MINUS); } - setState(947); + setState(979); oC_IntegerLiteral(); } @@ -5000,7 +5164,7 @@ size_t CypherParser::KU_MinValueContext::getRuleIndex() const { CypherParser::KU_MinValueContext* CypherParser::kU_MinValue() { KU_MinValueContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 64, CypherParser::RuleKU_MinValue); + enterRule(_localctx, 66, CypherParser::RuleKU_MinValue); size_t _la = 0; #if __cplusplus > 201703L @@ -5011,35 +5175,35 @@ CypherParser::KU_MinValueContext* CypherParser::kU_MinValue() { exitRule(); }); try { - setState(958); + setState(990); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::NO: { enterOuterAlt(_localctx, 1); - setState(949); + setState(981); match(CypherParser::NO); - setState(950); + setState(982); match(CypherParser::SP); - setState(951); + setState(983); match(CypherParser::MINVALUE); break; } case CypherParser::MINVALUE: { enterOuterAlt(_localctx, 2); - setState(952); + setState(984); match(CypherParser::MINVALUE); - setState(953); + setState(985); match(CypherParser::SP); - setState(955); + setState(987); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::MINUS) { - setState(954); + setState(986); match(CypherParser::MINUS); } - setState(957); + setState(989); oC_IntegerLiteral(); break; } @@ -5092,7 +5256,7 @@ size_t CypherParser::KU_MaxValueContext::getRuleIndex() const { CypherParser::KU_MaxValueContext* CypherParser::kU_MaxValue() { KU_MaxValueContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 66, CypherParser::RuleKU_MaxValue); + enterRule(_localctx, 68, CypherParser::RuleKU_MaxValue); size_t _la = 0; #if __cplusplus > 201703L @@ -5103,35 +5267,35 @@ CypherParser::KU_MaxValueContext* CypherParser::kU_MaxValue() { exitRule(); }); try { - setState(969); + setState(1001); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::NO: { enterOuterAlt(_localctx, 1); - setState(960); + setState(992); match(CypherParser::NO); - setState(961); + setState(993); match(CypherParser::SP); - setState(962); + setState(994); match(CypherParser::MAXVALUE); break; } case CypherParser::MAXVALUE: { enterOuterAlt(_localctx, 2); - setState(963); + setState(995); match(CypherParser::MAXVALUE); - setState(964); + setState(996); match(CypherParser::SP); - setState(966); + setState(998); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::MINUS) { - setState(965); + setState(997); match(CypherParser::MINUS); } - setState(968); + setState(1000); oC_IntegerLiteral(); break; } @@ -5188,7 +5352,7 @@ size_t CypherParser::KU_StartWithContext::getRuleIndex() const { CypherParser::KU_StartWithContext* CypherParser::kU_StartWith() { KU_StartWithContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 68, CypherParser::RuleKU_StartWith); + enterRule(_localctx, 70, CypherParser::RuleKU_StartWith); size_t _la = 0; #if __cplusplus > 201703L @@ -5200,29 +5364,29 @@ CypherParser::KU_StartWithContext* CypherParser::kU_StartWith() { }); try { enterOuterAlt(_localctx, 1); - setState(971); + setState(1003); match(CypherParser::START); - setState(972); + setState(1004); match(CypherParser::SP); - setState(975); + setState(1007); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::WITH) { - setState(973); + setState(1005); match(CypherParser::WITH); - setState(974); + setState(1006); match(CypherParser::SP); } - setState(978); + setState(1010); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::MINUS) { - setState(977); + setState(1009); match(CypherParser::MINUS); } - setState(980); + setState(1012); oC_IntegerLiteral(); } @@ -5261,7 +5425,7 @@ size_t CypherParser::KU_CycleContext::getRuleIndex() const { CypherParser::KU_CycleContext* CypherParser::kU_Cycle() { KU_CycleContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 70, CypherParser::RuleKU_Cycle); + enterRule(_localctx, 72, CypherParser::RuleKU_Cycle); size_t _la = 0; #if __cplusplus > 201703L @@ -5273,17 +5437,17 @@ CypherParser::KU_CycleContext* CypherParser::kU_Cycle() { }); try { enterOuterAlt(_localctx, 1); - setState(984); + setState(1016); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::NO) { - setState(982); + setState(1014); match(CypherParser::NO); - setState(983); + setState(1015); match(CypherParser::SP); } - setState(986); + setState(1018); match(CypherParser::CYCLE); } @@ -5322,7 +5486,7 @@ size_t CypherParser::KU_IfExistsContext::getRuleIndex() const { CypherParser::KU_IfExistsContext* CypherParser::kU_IfExists() { KU_IfExistsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 72, CypherParser::RuleKU_IfExists); + enterRule(_localctx, 74, CypherParser::RuleKU_IfExists); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5333,11 +5497,11 @@ CypherParser::KU_IfExistsContext* CypherParser::kU_IfExists() { }); try { enterOuterAlt(_localctx, 1); - setState(988); + setState(1020); match(CypherParser::IF); - setState(989); + setState(1021); match(CypherParser::SP); - setState(990); + setState(1022); match(CypherParser::EXISTS); } @@ -5396,7 +5560,7 @@ size_t CypherParser::KU_DropContext::getRuleIndex() const { CypherParser::KU_DropContext* CypherParser::kU_Drop() { KU_DropContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 74, CypherParser::RuleKU_Drop); + enterRule(_localctx, 76, CypherParser::RuleKU_Drop); size_t _la = 0; #if __cplusplus > 201703L @@ -5408,30 +5572,30 @@ CypherParser::KU_DropContext* CypherParser::kU_Drop() { }); try { enterOuterAlt(_localctx, 1); - setState(992); + setState(1024); match(CypherParser::DROP); - setState(993); + setState(1025); match(CypherParser::SP); - setState(994); + setState(1026); _la = _input->LA(1); - if (!(((((_la - 122) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 122)) & 4225) != 0))) { + if (!(((((_la - 123) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 123)) & 4225) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } - setState(995); + setState(1027); match(CypherParser::SP); - setState(999); + setState(1031); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 113, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 116, _ctx)) { case 1: { - setState(996); + setState(1028); kU_IfExists(); - setState(997); + setState(1029); match(CypherParser::SP); break; } @@ -5439,7 +5603,7 @@ CypherParser::KU_DropContext* CypherParser::kU_Drop() { default: break; } - setState(1001); + setState(1033); oC_SchemaName(); } @@ -5490,7 +5654,7 @@ size_t CypherParser::KU_AlterTableContext::getRuleIndex() const { CypherParser::KU_AlterTableContext* CypherParser::kU_AlterTable() { KU_AlterTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 76, CypherParser::RuleKU_AlterTable); + enterRule(_localctx, 78, CypherParser::RuleKU_AlterTable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5501,19 +5665,19 @@ CypherParser::KU_AlterTableContext* CypherParser::kU_AlterTable() { }); try { enterOuterAlt(_localctx, 1); - setState(1003); + setState(1035); match(CypherParser::ALTER); - setState(1004); + setState(1036); match(CypherParser::SP); - setState(1005); + setState(1037); match(CypherParser::TABLE); - setState(1006); + setState(1038); match(CypherParser::SP); - setState(1007); + setState(1039); oC_SchemaName(); - setState(1008); + setState(1040); match(CypherParser::SP); - setState(1009); + setState(1041); kU_AlterOptions(); } @@ -5556,7 +5720,7 @@ size_t CypherParser::KU_AlterOptionsContext::getRuleIndex() const { CypherParser::KU_AlterOptionsContext* CypherParser::kU_AlterOptions() { KU_AlterOptionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 78, CypherParser::RuleKU_AlterOptions); + enterRule(_localctx, 80, CypherParser::RuleKU_AlterOptions); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5566,33 +5730,33 @@ CypherParser::KU_AlterOptionsContext* CypherParser::kU_AlterOptions() { exitRule(); }); try { - setState(1015); + setState(1047); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 114, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 117, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1011); + setState(1043); kU_AddProperty(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1012); + setState(1044); kU_DropProperty(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(1013); + setState(1045); kU_RenameTable(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(1014); + setState(1046); kU_RenameProperty(); break; } @@ -5649,7 +5813,7 @@ size_t CypherParser::KU_AddPropertyContext::getRuleIndex() const { CypherParser::KU_AddPropertyContext* CypherParser::kU_AddProperty() { KU_AddPropertyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 80, CypherParser::RuleKU_AddProperty); + enterRule(_localctx, 82, CypherParser::RuleKU_AddProperty); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5660,24 +5824,24 @@ CypherParser::KU_AddPropertyContext* CypherParser::kU_AddProperty() { }); try { enterOuterAlt(_localctx, 1); - setState(1017); + setState(1049); match(CypherParser::ADD); - setState(1018); + setState(1050); match(CypherParser::SP); - setState(1019); + setState(1051); oC_PropertyKeyName(); - setState(1020); + setState(1052); match(CypherParser::SP); - setState(1021); + setState(1053); kU_DataType(0); - setState(1024); + setState(1056); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 115, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 118, _ctx)) { case 1: { - setState(1022); + setState(1054); match(CypherParser::SP); - setState(1023); + setState(1055); kU_Default(); break; } @@ -5722,7 +5886,7 @@ size_t CypherParser::KU_DefaultContext::getRuleIndex() const { CypherParser::KU_DefaultContext* CypherParser::kU_Default() { KU_DefaultContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 82, CypherParser::RuleKU_Default); + enterRule(_localctx, 84, CypherParser::RuleKU_Default); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5733,11 +5897,11 @@ CypherParser::KU_DefaultContext* CypherParser::kU_Default() { }); try { enterOuterAlt(_localctx, 1); - setState(1026); + setState(1058); match(CypherParser::DEFAULT); - setState(1027); + setState(1059); match(CypherParser::SP); - setState(1028); + setState(1060); oC_Expression(); } @@ -5776,7 +5940,7 @@ size_t CypherParser::KU_DropPropertyContext::getRuleIndex() const { CypherParser::KU_DropPropertyContext* CypherParser::kU_DropProperty() { KU_DropPropertyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 84, CypherParser::RuleKU_DropProperty); + enterRule(_localctx, 86, CypherParser::RuleKU_DropProperty); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5787,11 +5951,11 @@ CypherParser::KU_DropPropertyContext* CypherParser::kU_DropProperty() { }); try { enterOuterAlt(_localctx, 1); - setState(1030); + setState(1062); match(CypherParser::DROP); - setState(1031); + setState(1063); match(CypherParser::SP); - setState(1032); + setState(1064); oC_PropertyKeyName(); } @@ -5838,7 +6002,7 @@ size_t CypherParser::KU_RenameTableContext::getRuleIndex() const { CypherParser::KU_RenameTableContext* CypherParser::kU_RenameTable() { KU_RenameTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 86, CypherParser::RuleKU_RenameTable); + enterRule(_localctx, 88, CypherParser::RuleKU_RenameTable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5849,15 +6013,15 @@ CypherParser::KU_RenameTableContext* CypherParser::kU_RenameTable() { }); try { enterOuterAlt(_localctx, 1); - setState(1034); + setState(1066); match(CypherParser::RENAME); - setState(1035); + setState(1067); match(CypherParser::SP); - setState(1036); + setState(1068); match(CypherParser::TO); - setState(1037); + setState(1069); match(CypherParser::SP); - setState(1038); + setState(1070); oC_SchemaName(); } @@ -5908,7 +6072,7 @@ size_t CypherParser::KU_RenamePropertyContext::getRuleIndex() const { CypherParser::KU_RenamePropertyContext* CypherParser::kU_RenameProperty() { KU_RenamePropertyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 88, CypherParser::RuleKU_RenameProperty); + enterRule(_localctx, 90, CypherParser::RuleKU_RenameProperty); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5919,19 +6083,19 @@ CypherParser::KU_RenamePropertyContext* CypherParser::kU_RenameProperty() { }); try { enterOuterAlt(_localctx, 1); - setState(1040); + setState(1072); match(CypherParser::RENAME); - setState(1041); + setState(1073); match(CypherParser::SP); - setState(1042); + setState(1074); oC_PropertyKeyName(); - setState(1043); + setState(1075); match(CypherParser::SP); - setState(1044); + setState(1076); match(CypherParser::TO); - setState(1045); + setState(1077); match(CypherParser::SP); - setState(1046); + setState(1078); oC_PropertyKeyName(); } @@ -5974,7 +6138,7 @@ size_t CypherParser::KU_ColumnDefinitionsContext::getRuleIndex() const { CypherParser::KU_ColumnDefinitionsContext* CypherParser::kU_ColumnDefinitions() { KU_ColumnDefinitionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 90, CypherParser::RuleKU_ColumnDefinitions); + enterRule(_localctx, 92, CypherParser::RuleKU_ColumnDefinitions); size_t _la = 0; #if __cplusplus > 201703L @@ -5987,37 +6151,37 @@ CypherParser::KU_ColumnDefinitionsContext* CypherParser::kU_ColumnDefinitions() try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1048); + setState(1080); kU_ColumnDefinition(); - setState(1059); + setState(1091); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 118, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 121, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1050); + setState(1082); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1049); + setState(1081); match(CypherParser::SP); } - setState(1052); + setState(1084); match(CypherParser::T__2); - setState(1054); + setState(1086); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1053); + setState(1085); match(CypherParser::SP); } - setState(1056); + setState(1088); kU_ColumnDefinition(); } - setState(1061); + setState(1093); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 118, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 121, _ctx); } } @@ -6056,7 +6220,7 @@ size_t CypherParser::KU_ColumnDefinitionContext::getRuleIndex() const { CypherParser::KU_ColumnDefinitionContext* CypherParser::kU_ColumnDefinition() { KU_ColumnDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 92, CypherParser::RuleKU_ColumnDefinition); + enterRule(_localctx, 94, CypherParser::RuleKU_ColumnDefinition); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6067,11 +6231,11 @@ CypherParser::KU_ColumnDefinitionContext* CypherParser::kU_ColumnDefinition() { }); try { enterOuterAlt(_localctx, 1); - setState(1062); + setState(1094); oC_PropertyKeyName(); - setState(1063); + setState(1095); match(CypherParser::SP); - setState(1064); + setState(1096); kU_DataType(0); } @@ -6114,7 +6278,7 @@ size_t CypherParser::KU_PropertyDefinitionsContext::getRuleIndex() const { CypherParser::KU_PropertyDefinitionsContext* CypherParser::kU_PropertyDefinitions() { KU_PropertyDefinitionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 94, CypherParser::RuleKU_PropertyDefinitions); + enterRule(_localctx, 96, CypherParser::RuleKU_PropertyDefinitions); size_t _la = 0; #if __cplusplus > 201703L @@ -6127,37 +6291,37 @@ CypherParser::KU_PropertyDefinitionsContext* CypherParser::kU_PropertyDefinition try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1066); + setState(1098); kU_PropertyDefinition(); - setState(1077); + setState(1109); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 121, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 124, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1068); + setState(1100); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1067); + setState(1099); match(CypherParser::SP); } - setState(1070); + setState(1102); match(CypherParser::T__2); - setState(1072); + setState(1104); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1071); + setState(1103); match(CypherParser::SP); } - setState(1074); + setState(1106); kU_PropertyDefinition(); } - setState(1079); + setState(1111); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 121, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 124, _ctx); } } @@ -6196,7 +6360,7 @@ size_t CypherParser::KU_PropertyDefinitionContext::getRuleIndex() const { CypherParser::KU_PropertyDefinitionContext* CypherParser::kU_PropertyDefinition() { KU_PropertyDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 96, CypherParser::RuleKU_PropertyDefinition); + enterRule(_localctx, 98, CypherParser::RuleKU_PropertyDefinition); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6207,16 +6371,16 @@ CypherParser::KU_PropertyDefinitionContext* CypherParser::kU_PropertyDefinition( }); try { enterOuterAlt(_localctx, 1); - setState(1080); + setState(1112); kU_ColumnDefinition(); - setState(1083); + setState(1115); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 122, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 125, _ctx)) { case 1: { - setState(1081); + setState(1113); match(CypherParser::SP); - setState(1082); + setState(1114); kU_Default(); break; } @@ -6235,41 +6399,41 @@ CypherParser::KU_PropertyDefinitionContext* CypherParser::kU_PropertyDefinition( return _localctx; } -//----------------- KU_CreateNodeConstraintContext ------------------------------------------------------------------ +//----------------- KU_PrimaryKeyContext ------------------------------------------------------------------ -CypherParser::KU_CreateNodeConstraintContext::KU_CreateNodeConstraintContext(ParserRuleContext *parent, size_t invokingState) +CypherParser::KU_PrimaryKeyContext::KU_PrimaryKeyContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -tree::TerminalNode* CypherParser::KU_CreateNodeConstraintContext::PRIMARY() { +tree::TerminalNode* CypherParser::KU_PrimaryKeyContext::PRIMARY() { return getToken(CypherParser::PRIMARY, 0); } -std::vector CypherParser::KU_CreateNodeConstraintContext::SP() { +std::vector CypherParser::KU_PrimaryKeyContext::SP() { return getTokens(CypherParser::SP); } -tree::TerminalNode* CypherParser::KU_CreateNodeConstraintContext::SP(size_t i) { +tree::TerminalNode* CypherParser::KU_PrimaryKeyContext::SP(size_t i) { return getToken(CypherParser::SP, i); } -tree::TerminalNode* CypherParser::KU_CreateNodeConstraintContext::KEY() { +tree::TerminalNode* CypherParser::KU_PrimaryKeyContext::KEY() { return getToken(CypherParser::KEY, 0); } -CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_CreateNodeConstraintContext::oC_PropertyKeyName() { +CypherParser::OC_PropertyKeyNameContext* CypherParser::KU_PrimaryKeyContext::oC_PropertyKeyName() { return getRuleContext(0); } -size_t CypherParser::KU_CreateNodeConstraintContext::getRuleIndex() const { - return CypherParser::RuleKU_CreateNodeConstraint; +size_t CypherParser::KU_PrimaryKeyContext::getRuleIndex() const { + return CypherParser::RuleKU_PrimaryKey; } -CypherParser::KU_CreateNodeConstraintContext* CypherParser::kU_CreateNodeConstraint() { - KU_CreateNodeConstraintContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 98, CypherParser::RuleKU_CreateNodeConstraint); +CypherParser::KU_PrimaryKeyContext* CypherParser::kU_PrimaryKey() { + KU_PrimaryKeyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 100, CypherParser::RuleKU_PrimaryKey); size_t _la = 0; #if __cplusplus > 201703L @@ -6281,41 +6445,41 @@ CypherParser::KU_CreateNodeConstraintContext* CypherParser::kU_CreateNodeConstra }); try { enterOuterAlt(_localctx, 1); - setState(1085); + setState(1117); match(CypherParser::PRIMARY); - setState(1086); + setState(1118); match(CypherParser::SP); - setState(1087); + setState(1119); match(CypherParser::KEY); - setState(1089); + setState(1121); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1088); + setState(1120); match(CypherParser::SP); } - setState(1091); + setState(1123); match(CypherParser::T__1); - setState(1093); + setState(1125); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1092); + setState(1124); match(CypherParser::SP); } - setState(1095); + setState(1127); oC_PropertyKeyName(); - setState(1097); + setState(1129); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1096); + setState(1128); match(CypherParser::SP); } - setState(1099); + setState(1131); match(CypherParser::T__3); } @@ -6395,8 +6559,8 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { CypherParser::KU_DataTypeContext *_localctx = _tracker.createInstance(_ctx, parentState); CypherParser::KU_DataTypeContext *previousContext = _localctx; (void)previousContext; // Silence compiler, in case the context is not used by generated code. - size_t startState = 100; - enterRecursionRule(_localctx, 100, CypherParser::RuleKU_DataType, precedence); + size_t startState = 102; + enterRecursionRule(_localctx, 102, CypherParser::RuleKU_DataType, precedence); size_t _la = 0; @@ -6410,195 +6574,195 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1175); + setState(1207); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 142, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 145, _ctx)) { case 1: { - setState(1102); + setState(1134); oC_SymbolicName(); break; } case 2: { - setState(1103); + setState(1135); match(CypherParser::UNION); - setState(1105); + setState(1137); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1104); + setState(1136); match(CypherParser::SP); } - setState(1107); + setState(1139); match(CypherParser::T__1); - setState(1109); + setState(1141); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1108); + setState(1140); match(CypherParser::SP); } - setState(1111); + setState(1143); kU_ColumnDefinitions(); - setState(1113); + setState(1145); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1112); + setState(1144); match(CypherParser::SP); } - setState(1115); + setState(1147); match(CypherParser::T__3); break; } case 3: { - setState(1117); + setState(1149); oC_SymbolicName(); - setState(1119); + setState(1151); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1118); + setState(1150); match(CypherParser::SP); } - setState(1121); + setState(1153); match(CypherParser::T__1); - setState(1123); + setState(1155); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1122); + setState(1154); match(CypherParser::SP); } - setState(1125); + setState(1157); kU_ColumnDefinitions(); - setState(1127); + setState(1159); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1126); + setState(1158); match(CypherParser::SP); } - setState(1129); + setState(1161); match(CypherParser::T__3); break; } case 4: { - setState(1131); + setState(1163); oC_SymbolicName(); - setState(1133); + setState(1165); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1132); + setState(1164); match(CypherParser::SP); } - setState(1135); + setState(1167); match(CypherParser::T__1); - setState(1137); + setState(1169); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1136); + setState(1168); match(CypherParser::SP); } - setState(1139); + setState(1171); kU_DataType(0); - setState(1141); + setState(1173); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1140); + setState(1172); match(CypherParser::SP); } - setState(1143); + setState(1175); match(CypherParser::T__2); - setState(1145); + setState(1177); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1144); + setState(1176); match(CypherParser::SP); } - setState(1147); + setState(1179); kU_DataType(0); - setState(1149); + setState(1181); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1148); + setState(1180); match(CypherParser::SP); } - setState(1151); + setState(1183); match(CypherParser::T__3); break; } case 5: { - setState(1153); + setState(1185); match(CypherParser::DECIMAL); - setState(1155); + setState(1187); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1154); + setState(1186); match(CypherParser::SP); } - setState(1157); + setState(1189); match(CypherParser::T__1); - setState(1159); + setState(1191); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1158); + setState(1190); match(CypherParser::SP); } - setState(1161); + setState(1193); oC_IntegerLiteral(); - setState(1163); + setState(1195); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1162); + setState(1194); match(CypherParser::SP); } - setState(1165); + setState(1197); match(CypherParser::T__2); - setState(1167); + setState(1199); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1166); + setState(1198); match(CypherParser::SP); } - setState(1169); + setState(1201); oC_IntegerLiteral(); - setState(1171); + setState(1203); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1170); + setState(1202); match(CypherParser::SP); } - setState(1173); + setState(1205); match(CypherParser::T__3); break; } @@ -6607,9 +6771,9 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { break; } _ctx->stop = _input->LT(-1); - setState(1181); + setState(1213); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 143, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 146, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) @@ -6617,15 +6781,15 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { previousContext = _localctx; _localctx = _tracker.createInstance(parentContext, parentState); pushNewRecursionContext(_localctx, startState, RuleKU_DataType); - setState(1177); + setState(1209); if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)"); - setState(1178); + setState(1210); kU_ListIdentifiers(); } - setState(1183); + setState(1215); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 143, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 146, _ctx); } } catch (RecognitionException &e) { @@ -6658,7 +6822,7 @@ size_t CypherParser::KU_ListIdentifiersContext::getRuleIndex() const { CypherParser::KU_ListIdentifiersContext* CypherParser::kU_ListIdentifiers() { KU_ListIdentifiersContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 102, CypherParser::RuleKU_ListIdentifiers); + enterRule(_localctx, 104, CypherParser::RuleKU_ListIdentifiers); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6670,19 +6834,19 @@ CypherParser::KU_ListIdentifiersContext* CypherParser::kU_ListIdentifiers() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1184); + setState(1216); kU_ListIdentifier(); - setState(1188); + setState(1220); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 144, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 147, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1185); + setState(1217); kU_ListIdentifier(); } - setState(1190); + setState(1222); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 144, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 147, _ctx); } } @@ -6713,7 +6877,7 @@ size_t CypherParser::KU_ListIdentifierContext::getRuleIndex() const { CypherParser::KU_ListIdentifierContext* CypherParser::kU_ListIdentifier() { KU_ListIdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 104, CypherParser::RuleKU_ListIdentifier); + enterRule(_localctx, 106, CypherParser::RuleKU_ListIdentifier); size_t _la = 0; #if __cplusplus > 201703L @@ -6725,17 +6889,17 @@ CypherParser::KU_ListIdentifierContext* CypherParser::kU_ListIdentifier() { }); try { enterOuterAlt(_localctx, 1); - setState(1191); + setState(1223); match(CypherParser::T__6); - setState(1193); + setState(1225); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DecimalInteger) { - setState(1192); + setState(1224); oC_IntegerLiteral(); } - setState(1195); + setState(1227); match(CypherParser::T__7); } @@ -6770,7 +6934,7 @@ size_t CypherParser::OC_AnyCypherOptionContext::getRuleIndex() const { CypherParser::OC_AnyCypherOptionContext* CypherParser::oC_AnyCypherOption() { OC_AnyCypherOptionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 106, CypherParser::RuleOC_AnyCypherOption); + enterRule(_localctx, 108, CypherParser::RuleOC_AnyCypherOption); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6780,19 +6944,19 @@ CypherParser::OC_AnyCypherOptionContext* CypherParser::oC_AnyCypherOption() { exitRule(); }); try { - setState(1199); + setState(1231); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::EXPLAIN: { enterOuterAlt(_localctx, 1); - setState(1197); + setState(1229); oC_Explain(); break; } case CypherParser::PROFILE: { enterOuterAlt(_localctx, 2); - setState(1198); + setState(1230); oC_Profile(); break; } @@ -6829,7 +6993,7 @@ size_t CypherParser::OC_ExplainContext::getRuleIndex() const { CypherParser::OC_ExplainContext* CypherParser::oC_Explain() { OC_ExplainContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 108, CypherParser::RuleOC_Explain); + enterRule(_localctx, 110, CypherParser::RuleOC_Explain); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6840,7 +7004,7 @@ CypherParser::OC_ExplainContext* CypherParser::oC_Explain() { }); try { enterOuterAlt(_localctx, 1); - setState(1201); + setState(1233); match(CypherParser::EXPLAIN); } @@ -6871,7 +7035,7 @@ size_t CypherParser::OC_ProfileContext::getRuleIndex() const { CypherParser::OC_ProfileContext* CypherParser::oC_Profile() { OC_ProfileContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 110, CypherParser::RuleOC_Profile); + enterRule(_localctx, 112, CypherParser::RuleOC_Profile); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6882,7 +7046,7 @@ CypherParser::OC_ProfileContext* CypherParser::oC_Profile() { }); try { enterOuterAlt(_localctx, 1); - setState(1203); + setState(1235); match(CypherParser::PROFILE); } @@ -6945,7 +7109,7 @@ size_t CypherParser::KU_TransactionContext::getRuleIndex() const { CypherParser::KU_TransactionContext* CypherParser::kU_Transaction() { KU_TransactionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 112, CypherParser::RuleKU_Transaction); + enterRule(_localctx, 114, CypherParser::RuleKU_Transaction); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6955,56 +7119,56 @@ CypherParser::KU_TransactionContext* CypherParser::kU_Transaction() { exitRule(); }); try { - setState(1218); + setState(1250); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 147, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 150, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1205); + setState(1237); match(CypherParser::BEGIN); - setState(1206); + setState(1238); match(CypherParser::SP); - setState(1207); + setState(1239); match(CypherParser::TRANSACTION); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1208); + setState(1240); match(CypherParser::BEGIN); - setState(1209); + setState(1241); match(CypherParser::SP); - setState(1210); + setState(1242); match(CypherParser::TRANSACTION); - setState(1211); + setState(1243); match(CypherParser::SP); - setState(1212); + setState(1244); match(CypherParser::READ); - setState(1213); + setState(1245); match(CypherParser::SP); - setState(1214); + setState(1246); match(CypherParser::ONLY); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(1215); + setState(1247); match(CypherParser::COMMIT); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(1216); + setState(1248); match(CypherParser::ROLLBACK); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(1217); + setState(1249); match(CypherParser::CHECKPOINT); break; } @@ -7045,7 +7209,7 @@ size_t CypherParser::KU_ExtensionContext::getRuleIndex() const { CypherParser::KU_ExtensionContext* CypherParser::kU_Extension() { KU_ExtensionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 114, CypherParser::RuleKU_Extension); + enterRule(_localctx, 116, CypherParser::RuleKU_Extension); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7055,19 +7219,19 @@ CypherParser::KU_ExtensionContext* CypherParser::kU_Extension() { exitRule(); }); try { - setState(1222); + setState(1254); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::LOAD: { enterOuterAlt(_localctx, 1); - setState(1220); + setState(1252); kU_LoadExtension(); break; } case CypherParser::INSTALL: { enterOuterAlt(_localctx, 2); - setState(1221); + setState(1253); kU_InstallExtension(); break; } @@ -7124,7 +7288,7 @@ size_t CypherParser::KU_LoadExtensionContext::getRuleIndex() const { CypherParser::KU_LoadExtensionContext* CypherParser::kU_LoadExtension() { KU_LoadExtensionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 116, CypherParser::RuleKU_LoadExtension); + enterRule(_localctx, 118, CypherParser::RuleKU_LoadExtension); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7135,19 +7299,19 @@ CypherParser::KU_LoadExtensionContext* CypherParser::kU_LoadExtension() { }); try { enterOuterAlt(_localctx, 1); - setState(1224); + setState(1256); match(CypherParser::LOAD); - setState(1225); + setState(1257); match(CypherParser::SP); - setState(1226); + setState(1258); match(CypherParser::EXTENSION); - setState(1227); + setState(1259); match(CypherParser::SP); - setState(1230); + setState(1262); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::StringLiteral: { - setState(1228); + setState(1260); match(CypherParser::StringLiteral); break; } @@ -7205,7 +7369,7 @@ CypherParser::KU_LoadExtensionContext* CypherParser::kU_LoadExtension() { case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(1229); + setState(1261); oC_Variable(); break; } @@ -7250,7 +7414,7 @@ size_t CypherParser::KU_InstallExtensionContext::getRuleIndex() const { CypherParser::KU_InstallExtensionContext* CypherParser::kU_InstallExtension() { KU_InstallExtensionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 118, CypherParser::RuleKU_InstallExtension); + enterRule(_localctx, 120, CypherParser::RuleKU_InstallExtension); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7261,11 +7425,11 @@ CypherParser::KU_InstallExtensionContext* CypherParser::kU_InstallExtension() { }); try { enterOuterAlt(_localctx, 1); - setState(1232); + setState(1264); match(CypherParser::INSTALL); - setState(1233); + setState(1265); match(CypherParser::SP); - setState(1234); + setState(1266); oC_Variable(); } @@ -7304,7 +7468,7 @@ size_t CypherParser::OC_QueryContext::getRuleIndex() const { CypherParser::OC_QueryContext* CypherParser::oC_Query() { OC_QueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 120, CypherParser::RuleOC_Query); + enterRule(_localctx, 122, CypherParser::RuleOC_Query); size_t _la = 0; #if __cplusplus > 201703L @@ -7316,19 +7480,19 @@ CypherParser::OC_QueryContext* CypherParser::oC_Query() { }); try { enterOuterAlt(_localctx, 1); - setState(1240); + setState(1272); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 151, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 154, _ctx)) { case 1: { - setState(1236); + setState(1268); kU_ProjectGraph(); - setState(1238); + setState(1270); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1237); + setState(1269); match(CypherParser::SP); } break; @@ -7337,7 +7501,7 @@ CypherParser::OC_QueryContext* CypherParser::oC_Query() { default: break; } - setState(1242); + setState(1274); oC_RegularQuery(); } @@ -7388,7 +7552,7 @@ size_t CypherParser::KU_ProjectGraphContext::getRuleIndex() const { CypherParser::KU_ProjectGraphContext* CypherParser::kU_ProjectGraph() { KU_ProjectGraphContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 122, CypherParser::RuleKU_ProjectGraph); + enterRule(_localctx, 124, CypherParser::RuleKU_ProjectGraph); size_t _la = 0; #if __cplusplus > 201703L @@ -7400,45 +7564,45 @@ CypherParser::KU_ProjectGraphContext* CypherParser::kU_ProjectGraph() { }); try { enterOuterAlt(_localctx, 1); - setState(1244); + setState(1276); match(CypherParser::PROJECT); - setState(1245); + setState(1277); match(CypherParser::SP); - setState(1246); + setState(1278); match(CypherParser::GRAPH); - setState(1247); + setState(1279); match(CypherParser::SP); - setState(1248); + setState(1280); oC_SchemaName(); - setState(1250); + setState(1282); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1249); + setState(1281); match(CypherParser::SP); } - setState(1252); + setState(1284); match(CypherParser::T__1); - setState(1254); + setState(1286); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1253); + setState(1285); match(CypherParser::SP); } - setState(1256); + setState(1288); kU_GraphProjectionTableItems(); - setState(1258); + setState(1290); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1257); + setState(1289); match(CypherParser::SP); } - setState(1260); + setState(1292); match(CypherParser::T__3); } @@ -7481,7 +7645,7 @@ size_t CypherParser::KU_GraphProjectionTableItemsContext::getRuleIndex() const { CypherParser::KU_GraphProjectionTableItemsContext* CypherParser::kU_GraphProjectionTableItems() { KU_GraphProjectionTableItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 124, CypherParser::RuleKU_GraphProjectionTableItems); + enterRule(_localctx, 126, CypherParser::RuleKU_GraphProjectionTableItems); size_t _la = 0; #if __cplusplus > 201703L @@ -7494,37 +7658,37 @@ CypherParser::KU_GraphProjectionTableItemsContext* CypherParser::kU_GraphProject try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1262); + setState(1294); kU_GraphProjectionTableItem(); - setState(1273); + setState(1305); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 157, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 160, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1264); + setState(1296); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1263); + setState(1295); match(CypherParser::SP); } - setState(1266); + setState(1298); match(CypherParser::T__2); - setState(1268); + setState(1300); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1267); + setState(1299); match(CypherParser::SP); } - setState(1270); + setState(1302); kU_GraphProjectionTableItem(); } - setState(1275); + setState(1307); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 157, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 160, _ctx); } } @@ -7579,7 +7743,7 @@ size_t CypherParser::OC_RegularQueryContext::getRuleIndex() const { CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() { OC_RegularQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 126, CypherParser::RuleOC_RegularQuery); + enterRule(_localctx, 128, CypherParser::RuleOC_RegularQuery); size_t _la = 0; #if __cplusplus > 201703L @@ -7591,52 +7755,52 @@ CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() { }); try { size_t alt; - setState(1297); + setState(1329); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 162, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 165, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1276); + setState(1308); oC_SingleQuery(); - setState(1283); + setState(1315); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 159, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 162, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1278); + setState(1310); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1277); + setState(1309); match(CypherParser::SP); } - setState(1280); + setState(1312); oC_Union(); } - setState(1285); + setState(1317); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 159, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 162, _ctx); } break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1290); + setState(1322); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(1286); + setState(1318); oC_Return(); - setState(1288); + setState(1320); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1287); + setState(1319); match(CypherParser::SP); } break; @@ -7645,11 +7809,11 @@ CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() { default: throw NoViableAltException(this); } - setState(1292); + setState(1324); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 161, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 164, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); - setState(1294); + setState(1326); oC_SingleQuery(); notifyReturnNotAtEnd(_localctx->start); break; @@ -7703,7 +7867,7 @@ size_t CypherParser::OC_UnionContext::getRuleIndex() const { CypherParser::OC_UnionContext* CypherParser::oC_Union() { OC_UnionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 128, CypherParser::RuleOC_Union); + enterRule(_localctx, 130, CypherParser::RuleOC_Union); size_t _la = 0; #if __cplusplus > 201703L @@ -7714,43 +7878,43 @@ CypherParser::OC_UnionContext* CypherParser::oC_Union() { exitRule(); }); try { - setState(1311); + setState(1343); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 165, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 168, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1299); + setState(1331); match(CypherParser::UNION); - setState(1300); + setState(1332); match(CypherParser::SP); - setState(1301); + setState(1333); match(CypherParser::ALL); - setState(1303); + setState(1335); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1302); + setState(1334); match(CypherParser::SP); } - setState(1305); + setState(1337); oC_SingleQuery(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1306); + setState(1338); match(CypherParser::UNION); - setState(1308); + setState(1340); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1307); + setState(1339); match(CypherParser::SP); } - setState(1310); + setState(1342); oC_SingleQuery(); break; } @@ -7791,7 +7955,7 @@ size_t CypherParser::OC_SingleQueryContext::getRuleIndex() const { CypherParser::OC_SingleQueryContext* CypherParser::oC_SingleQuery() { OC_SingleQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 130, CypherParser::RuleOC_SingleQuery); + enterRule(_localctx, 132, CypherParser::RuleOC_SingleQuery); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7801,19 +7965,19 @@ CypherParser::OC_SingleQueryContext* CypherParser::oC_SingleQuery() { exitRule(); }); try { - setState(1315); + setState(1347); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 166, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 169, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1313); + setState(1345); oC_SinglePartQuery(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1314); + setState(1346); oC_MultiPartQuery(); break; } @@ -7874,7 +8038,7 @@ size_t CypherParser::OC_SinglePartQueryContext::getRuleIndex() const { CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { OC_SinglePartQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 132, CypherParser::RuleOC_SinglePartQuery); + enterRule(_localctx, 134, CypherParser::RuleOC_SinglePartQuery); size_t _la = 0; #if __cplusplus > 201703L @@ -7886,92 +8050,92 @@ CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { }); try { size_t alt; - setState(1362); + setState(1394); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 177, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 180, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1323); + setState(1355); _errHandler->sync(this); _la = _input->LA(1); - while (_la == CypherParser::CALL || ((((_la - 102) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 102)) & 549756354565) != 0)) { - setState(1317); + while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 103)) & 549756354565) != 0)) { + setState(1349); oC_ReadingClause(); - setState(1319); + setState(1351); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1318); + setState(1350); match(CypherParser::SP); } - setState(1325); + setState(1357); _errHandler->sync(this); _la = _input->LA(1); } - setState(1326); + setState(1358); oC_Return(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1333); + setState(1365); _errHandler->sync(this); _la = _input->LA(1); - while (_la == CypherParser::CALL || ((((_la - 102) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 102)) & 549756354565) != 0)) { - setState(1327); + while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 103)) & 549756354565) != 0)) { + setState(1359); oC_ReadingClause(); - setState(1329); + setState(1361); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1328); + setState(1360); match(CypherParser::SP); } - setState(1335); + setState(1367); _errHandler->sync(this); _la = _input->LA(1); } - setState(1336); + setState(1368); oC_UpdatingClause(); - setState(1343); + setState(1375); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 172, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 175, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1338); + setState(1370); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1337); + setState(1369); match(CypherParser::SP); } - setState(1340); + setState(1372); oC_UpdatingClause(); } - setState(1345); + setState(1377); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 172, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 175, _ctx); } - setState(1350); + setState(1382); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 174, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 177, _ctx)) { case 1: { - setState(1347); + setState(1379); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1346); + setState(1378); match(CypherParser::SP); } - setState(1349); + setState(1381); oC_Return(); break; } @@ -7984,18 +8148,18 @@ CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { case 3: { enterOuterAlt(_localctx, 3); - setState(1356); + setState(1388); _errHandler->sync(this); _la = _input->LA(1); do { - setState(1352); + setState(1384); oC_ReadingClause(); - setState(1354); + setState(1386); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 175, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 178, _ctx)) { case 1: { - setState(1353); + setState(1385); match(CypherParser::SP); break; } @@ -8003,11 +8167,11 @@ CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { default: break; } - setState(1358); + setState(1390); _errHandler->sync(this); _la = _input->LA(1); - } while (_la == CypherParser::CALL || ((((_la - 102) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 102)) & 549756354565) != 0)); + } while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 103)) & 549756354565) != 0)); notifyQueryNotConcludeWithReturn(_localctx->start); break; } @@ -8060,7 +8224,7 @@ size_t CypherParser::OC_MultiPartQueryContext::getRuleIndex() const { CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() { OC_MultiPartQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 134, CypherParser::RuleOC_MultiPartQuery); + enterRule(_localctx, 136, CypherParser::RuleOC_MultiPartQuery); size_t _la = 0; #if __cplusplus > 201703L @@ -8073,20 +8237,20 @@ CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1368); + setState(1400); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(1364); + setState(1396); kU_QueryPart(); - setState(1366); + setState(1398); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1365); + setState(1397); match(CypherParser::SP); } break; @@ -8095,11 +8259,11 @@ CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() { default: throw NoViableAltException(this); } - setState(1370); + setState(1402); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 179, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 182, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); - setState(1372); + setState(1404); oC_SinglePartQuery(); } @@ -8154,7 +8318,7 @@ size_t CypherParser::KU_QueryPartContext::getRuleIndex() const { CypherParser::KU_QueryPartContext* CypherParser::kU_QueryPart() { KU_QueryPartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 136, CypherParser::RuleKU_QueryPart); + enterRule(_localctx, 138, CypherParser::RuleKU_QueryPart); size_t _la = 0; #if __cplusplus > 201703L @@ -8166,45 +8330,45 @@ CypherParser::KU_QueryPartContext* CypherParser::kU_QueryPart() { }); try { enterOuterAlt(_localctx, 1); - setState(1380); + setState(1412); _errHandler->sync(this); _la = _input->LA(1); - while (_la == CypherParser::CALL || ((((_la - 102) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 102)) & 549756354565) != 0)) { - setState(1374); + while (_la == CypherParser::CALL || ((((_la - 103) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 103)) & 549756354565) != 0)) { + setState(1406); oC_ReadingClause(); - setState(1376); + setState(1408); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1375); + setState(1407); match(CypherParser::SP); } - setState(1382); + setState(1414); _errHandler->sync(this); _la = _input->LA(1); } - setState(1389); + setState(1421); _errHandler->sync(this); _la = _input->LA(1); while (((((_la - 68) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 68)) & 4611686293305295137) != 0)) { - setState(1383); + ((1ULL << (_la - 68)) & -9223371487098961631) != 0)) { + setState(1415); oC_UpdatingClause(); - setState(1385); + setState(1417); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1384); + setState(1416); match(CypherParser::SP); } - setState(1391); + setState(1423); _errHandler->sync(this); _la = _input->LA(1); } - setState(1392); + setState(1424); oC_With(); } @@ -8247,7 +8411,7 @@ size_t CypherParser::OC_UpdatingClauseContext::getRuleIndex() const { CypherParser::OC_UpdatingClauseContext* CypherParser::oC_UpdatingClause() { OC_UpdatingClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 138, CypherParser::RuleOC_UpdatingClause); + enterRule(_localctx, 140, CypherParser::RuleOC_UpdatingClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -8257,26 +8421,26 @@ CypherParser::OC_UpdatingClauseContext* CypherParser::oC_UpdatingClause() { exitRule(); }); try { - setState(1398); + setState(1430); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::CREATE: { enterOuterAlt(_localctx, 1); - setState(1394); + setState(1426); oC_Create(); break; } case CypherParser::MERGE: { enterOuterAlt(_localctx, 2); - setState(1395); + setState(1427); oC_Merge(); break; } case CypherParser::SET: { enterOuterAlt(_localctx, 3); - setState(1396); + setState(1428); oC_Set(); break; } @@ -8284,7 +8448,7 @@ CypherParser::OC_UpdatingClauseContext* CypherParser::oC_UpdatingClause() { case CypherParser::DELETE: case CypherParser::DETACH: { enterOuterAlt(_localctx, 4); - setState(1397); + setState(1429); oC_Delete(); break; } @@ -8333,7 +8497,7 @@ size_t CypherParser::OC_ReadingClauseContext::getRuleIndex() const { CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() { OC_ReadingClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 140, CypherParser::RuleOC_ReadingClause); + enterRule(_localctx, 142, CypherParser::RuleOC_ReadingClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -8343,20 +8507,20 @@ CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() { exitRule(); }); try { - setState(1404); + setState(1436); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::MATCH: case CypherParser::OPTIONAL: { enterOuterAlt(_localctx, 1); - setState(1400); + setState(1432); oC_Match(); break; } case CypherParser::UNWIND: { enterOuterAlt(_localctx, 2); - setState(1401); + setState(1433); oC_Unwind(); break; } @@ -8364,14 +8528,14 @@ CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() { case CypherParser::CALL: case CypherParser::PROJECT: { enterOuterAlt(_localctx, 3); - setState(1402); + setState(1434); kU_InQueryCall(); break; } case CypherParser::LOAD: { enterOuterAlt(_localctx, 4); - setState(1403); + setState(1435); kU_LoadFrom(); break; } @@ -8444,7 +8608,7 @@ size_t CypherParser::KU_LoadFromContext::getRuleIndex() const { CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { KU_LoadFromContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 142, CypherParser::RuleKU_LoadFrom); + enterRule(_localctx, 144, CypherParser::RuleKU_LoadFrom); size_t _la = 0; #if __cplusplus > 201703L @@ -8456,50 +8620,50 @@ CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { }); try { enterOuterAlt(_localctx, 1); - setState(1406); + setState(1438); match(CypherParser::LOAD); - setState(1424); + setState(1456); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 189, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 192, _ctx)) { case 1: { - setState(1407); + setState(1439); match(CypherParser::SP); - setState(1408); + setState(1440); match(CypherParser::WITH); - setState(1409); + setState(1441); match(CypherParser::SP); - setState(1410); + setState(1442); match(CypherParser::HEADERS); - setState(1412); + setState(1444); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1411); + setState(1443); match(CypherParser::SP); } - setState(1414); + setState(1446); match(CypherParser::T__1); - setState(1416); + setState(1448); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1415); + setState(1447); match(CypherParser::SP); } - setState(1418); + setState(1450); kU_ColumnDefinitions(); - setState(1420); + setState(1452); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1419); + setState(1451); match(CypherParser::SP); } - setState(1422); + setState(1454); match(CypherParser::T__3); break; } @@ -8507,28 +8671,28 @@ CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { default: break; } - setState(1426); + setState(1458); match(CypherParser::SP); - setState(1427); + setState(1459); match(CypherParser::FROM); - setState(1428); + setState(1460); match(CypherParser::SP); - setState(1429); + setState(1461); kU_ScanSource(); - setState(1434); + setState(1466); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 191, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 194, _ctx)) { case 1: { - setState(1431); + setState(1463); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1430); + setState(1462); match(CypherParser::SP); } - setState(1433); + setState(1465); kU_ParsingOptions(); break; } @@ -8536,20 +8700,20 @@ CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { default: break; } - setState(1440); + setState(1472); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 193, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 196, _ctx)) { case 1: { - setState(1437); + setState(1469); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1436); + setState(1468); match(CypherParser::SP); } - setState(1439); + setState(1471); oC_Where(); break; } @@ -8606,7 +8770,7 @@ size_t CypherParser::KU_InQueryCallContext::getRuleIndex() const { CypherParser::KU_InQueryCallContext* CypherParser::kU_InQueryCall() { KU_InQueryCallContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 144, CypherParser::RuleKU_InQueryCall); + enterRule(_localctx, 146, CypherParser::RuleKU_InQueryCall); size_t _la = 0; #if __cplusplus > 201703L @@ -8618,42 +8782,42 @@ CypherParser::KU_InQueryCallContext* CypherParser::kU_InQueryCall() { }); try { enterOuterAlt(_localctx, 1); - setState(1446); + setState(1478); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::PROJECT) { - setState(1442); + setState(1474); kU_ProjectGraph(); - setState(1444); + setState(1476); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1443); + setState(1475); match(CypherParser::SP); } } - setState(1448); + setState(1480); match(CypherParser::CALL); - setState(1449); + setState(1481); match(CypherParser::SP); - setState(1450); + setState(1482); oC_FunctionInvocation(); - setState(1455); + setState(1487); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 197, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 200, _ctx)) { case 1: { - setState(1452); + setState(1484); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1451); + setState(1483); match(CypherParser::SP); } - setState(1454); + setState(1486); oC_Where(); break; } @@ -8702,7 +8866,7 @@ size_t CypherParser::KU_GraphProjectionTableItemContext::getRuleIndex() const { CypherParser::KU_GraphProjectionTableItemContext* CypherParser::kU_GraphProjectionTableItem() { KU_GraphProjectionTableItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 146, CypherParser::RuleKU_GraphProjectionTableItem); + enterRule(_localctx, 148, CypherParser::RuleKU_GraphProjectionTableItem); size_t _la = 0; #if __cplusplus > 201703L @@ -8714,42 +8878,42 @@ CypherParser::KU_GraphProjectionTableItemContext* CypherParser::kU_GraphProjecti }); try { enterOuterAlt(_localctx, 1); - setState(1457); + setState(1489); oC_SchemaName(); - setState(1471); + setState(1503); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 201, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 204, _ctx)) { case 1: { - setState(1459); + setState(1491); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1458); + setState(1490); match(CypherParser::SP); } - setState(1461); + setState(1493); match(CypherParser::T__8); - setState(1463); + setState(1495); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1462); + setState(1494); match(CypherParser::SP); } - setState(1465); + setState(1497); kU_GraphProjectionColumnItems(); - setState(1467); + setState(1499); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1466); + setState(1498); match(CypherParser::SP); } - setState(1469); + setState(1501); match(CypherParser::T__9); break; } @@ -8798,7 +8962,7 @@ size_t CypherParser::KU_GraphProjectionColumnItemsContext::getRuleIndex() const CypherParser::KU_GraphProjectionColumnItemsContext* CypherParser::kU_GraphProjectionColumnItems() { KU_GraphProjectionColumnItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 148, CypherParser::RuleKU_GraphProjectionColumnItems); + enterRule(_localctx, 150, CypherParser::RuleKU_GraphProjectionColumnItems); size_t _la = 0; #if __cplusplus > 201703L @@ -8811,37 +8975,37 @@ CypherParser::KU_GraphProjectionColumnItemsContext* CypherParser::kU_GraphProjec try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1473); + setState(1505); kU_GraphProjectionColumnItem(); - setState(1484); + setState(1516); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 204, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 207, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1475); + setState(1507); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1474); + setState(1506); match(CypherParser::SP); } - setState(1477); + setState(1509); match(CypherParser::T__2); - setState(1479); + setState(1511); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1478); + setState(1510); match(CypherParser::SP); } - setState(1481); + setState(1513); kU_GraphProjectionColumnItem(); } - setState(1486); + setState(1518); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 204, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 207, _ctx); } } @@ -8888,7 +9052,7 @@ size_t CypherParser::KU_GraphProjectionColumnItemContext::getRuleIndex() const { CypherParser::KU_GraphProjectionColumnItemContext* CypherParser::kU_GraphProjectionColumnItem() { KU_GraphProjectionColumnItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 150, CypherParser::RuleKU_GraphProjectionColumnItem); + enterRule(_localctx, 152, CypherParser::RuleKU_GraphProjectionColumnItem); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -8899,16 +9063,16 @@ CypherParser::KU_GraphProjectionColumnItemContext* CypherParser::kU_GraphProject }); try { enterOuterAlt(_localctx, 1); - setState(1487); + setState(1519); oC_PropertyKeyName(); - setState(1490); + setState(1522); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 205, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 208, _ctx)) { case 1: { - setState(1488); + setState(1520); match(CypherParser::SP); - setState(1489); + setState(1521); kU_Default(); break; } @@ -8916,14 +9080,14 @@ CypherParser::KU_GraphProjectionColumnItemContext* CypherParser::kU_GraphProject default: break; } - setState(1494); + setState(1526); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 206, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 209, _ctx)) { case 1: { - setState(1492); + setState(1524); match(CypherParser::SP); - setState(1493); + setState(1525); oC_Where(); break; } @@ -8984,7 +9148,7 @@ size_t CypherParser::OC_MatchContext::getRuleIndex() const { CypherParser::OC_MatchContext* CypherParser::oC_Match() { OC_MatchContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 152, CypherParser::RuleOC_Match); + enterRule(_localctx, 154, CypherParser::RuleOC_Match); size_t _la = 0; #if __cplusplus > 201703L @@ -8996,36 +9160,36 @@ CypherParser::OC_MatchContext* CypherParser::oC_Match() { }); try { enterOuterAlt(_localctx, 1); - setState(1498); + setState(1530); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::OPTIONAL) { - setState(1496); + setState(1528); match(CypherParser::OPTIONAL); - setState(1497); + setState(1529); match(CypherParser::SP); } - setState(1500); + setState(1532); match(CypherParser::MATCH); - setState(1502); + setState(1534); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1501); + setState(1533); match(CypherParser::SP); } - setState(1504); + setState(1536); oC_Pattern(); - setState(1507); + setState(1539); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 209, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 212, _ctx)) { case 1: { - setState(1505); + setState(1537); match(CypherParser::SP); - setState(1506); + setState(1538); oC_Where(); break; } @@ -9033,14 +9197,14 @@ CypherParser::OC_MatchContext* CypherParser::oC_Match() { default: break; } - setState(1511); + setState(1543); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 210, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 213, _ctx)) { case 1: { - setState(1509); + setState(1541); match(CypherParser::SP); - setState(1510); + setState(1542); kU_Hint(); break; } @@ -9085,7 +9249,7 @@ size_t CypherParser::KU_HintContext::getRuleIndex() const { CypherParser::KU_HintContext* CypherParser::kU_Hint() { KU_HintContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 154, CypherParser::RuleKU_Hint); + enterRule(_localctx, 156, CypherParser::RuleKU_Hint); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9096,11 +9260,11 @@ CypherParser::KU_HintContext* CypherParser::kU_Hint() { }); try { enterOuterAlt(_localctx, 1); - setState(1513); + setState(1545); match(CypherParser::HINT); - setState(1514); + setState(1546); match(CypherParser::SP); - setState(1515); + setState(1547); kU_JoinNode(0); } @@ -9172,8 +9336,8 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { CypherParser::KU_JoinNodeContext *_localctx = _tracker.createInstance(_ctx, parentState); CypherParser::KU_JoinNodeContext *previousContext = _localctx; (void)previousContext; // Silence compiler, in case the context is not used by generated code. - size_t startState = 156; - enterRecursionRule(_localctx, 156, CypherParser::RuleKU_JoinNode, precedence); + size_t startState = 158; + enterRecursionRule(_localctx, 158, CypherParser::RuleKU_JoinNode, precedence); size_t _la = 0; @@ -9187,31 +9351,31 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1529); + setState(1561); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::T__1: { - setState(1518); + setState(1550); match(CypherParser::T__1); - setState(1520); + setState(1552); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1519); + setState(1551); match(CypherParser::SP); } - setState(1522); + setState(1554); kU_JoinNode(0); - setState(1524); + setState(1556); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1523); + setState(1555); match(CypherParser::SP); } - setState(1526); + setState(1558); match(CypherParser::T__3); break; } @@ -9269,7 +9433,7 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(1528); + setState(1560); oC_SchemaName(); break; } @@ -9278,30 +9442,30 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { throw NoViableAltException(this); } _ctx->stop = _input->LT(-1); - setState(1547); + setState(1579); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 216, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 219, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) triggerExitRuleEvent(); previousContext = _localctx; - setState(1545); + setState(1577); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 215, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 218, _ctx)) { case 1: { _localctx = _tracker.createInstance(parentContext, parentState); pushNewRecursionContext(_localctx, startState, RuleKU_JoinNode); - setState(1531); + setState(1563); if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(1532); + setState(1564); match(CypherParser::SP); - setState(1533); + setState(1565); match(CypherParser::JOIN); - setState(1534); + setState(1566); match(CypherParser::SP); - setState(1535); + setState(1567); kU_JoinNode(5); break; } @@ -9309,22 +9473,22 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { case 2: { _localctx = _tracker.createInstance(parentContext, parentState); pushNewRecursionContext(_localctx, startState, RuleKU_JoinNode); - setState(1536); + setState(1568); if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)"); - setState(1541); + setState(1573); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(1537); + setState(1569); match(CypherParser::SP); - setState(1538); + setState(1570); match(CypherParser::MULTI_JOIN); - setState(1539); + setState(1571); match(CypherParser::SP); - setState(1540); + setState(1572); oC_SchemaName(); break; } @@ -9332,9 +9496,9 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { default: throw NoViableAltException(this); } - setState(1543); + setState(1575); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 214, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 217, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } @@ -9343,9 +9507,9 @@ CypherParser::KU_JoinNodeContext* CypherParser::kU_JoinNode(int precedence) { break; } } - setState(1549); + setState(1581); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 216, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 219, _ctx); } } catch (RecognitionException &e) { @@ -9394,7 +9558,7 @@ size_t CypherParser::OC_UnwindContext::getRuleIndex() const { CypherParser::OC_UnwindContext* CypherParser::oC_Unwind() { OC_UnwindContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 158, CypherParser::RuleOC_Unwind); + enterRule(_localctx, 160, CypherParser::RuleOC_Unwind); size_t _la = 0; #if __cplusplus > 201703L @@ -9406,25 +9570,25 @@ CypherParser::OC_UnwindContext* CypherParser::oC_Unwind() { }); try { enterOuterAlt(_localctx, 1); - setState(1550); + setState(1582); match(CypherParser::UNWIND); - setState(1552); + setState(1584); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1551); + setState(1583); match(CypherParser::SP); } - setState(1554); + setState(1586); oC_Expression(); - setState(1555); + setState(1587); match(CypherParser::SP); - setState(1556); + setState(1588); match(CypherParser::AS); - setState(1557); + setState(1589); match(CypherParser::SP); - setState(1558); + setState(1590); oC_Variable(); } @@ -9463,7 +9627,7 @@ size_t CypherParser::OC_CreateContext::getRuleIndex() const { CypherParser::OC_CreateContext* CypherParser::oC_Create() { OC_CreateContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 160, CypherParser::RuleOC_Create); + enterRule(_localctx, 162, CypherParser::RuleOC_Create); size_t _la = 0; #if __cplusplus > 201703L @@ -9475,17 +9639,17 @@ CypherParser::OC_CreateContext* CypherParser::oC_Create() { }); try { enterOuterAlt(_localctx, 1); - setState(1560); + setState(1592); match(CypherParser::CREATE); - setState(1562); + setState(1594); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1561); + setState(1593); match(CypherParser::SP); } - setState(1564); + setState(1596); oC_Pattern(); } @@ -9536,7 +9700,7 @@ size_t CypherParser::OC_MergeContext::getRuleIndex() const { CypherParser::OC_MergeContext* CypherParser::oC_Merge() { OC_MergeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 162, CypherParser::RuleOC_Merge); + enterRule(_localctx, 164, CypherParser::RuleOC_Merge); size_t _la = 0; #if __cplusplus > 201703L @@ -9549,31 +9713,31 @@ CypherParser::OC_MergeContext* CypherParser::oC_Merge() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1566); + setState(1598); match(CypherParser::MERGE); - setState(1568); + setState(1600); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1567); + setState(1599); match(CypherParser::SP); } - setState(1570); + setState(1602); oC_Pattern(); - setState(1575); + setState(1607); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 220, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 223, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1571); + setState(1603); match(CypherParser::SP); - setState(1572); + setState(1604); oC_MergeAction(); } - setState(1577); + setState(1609); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 220, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 223, _ctx); } } @@ -9624,7 +9788,7 @@ size_t CypherParser::OC_MergeActionContext::getRuleIndex() const { CypherParser::OC_MergeActionContext* CypherParser::oC_MergeAction() { OC_MergeActionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 164, CypherParser::RuleOC_MergeAction); + enterRule(_localctx, 166, CypherParser::RuleOC_MergeAction); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9634,35 +9798,35 @@ CypherParser::OC_MergeActionContext* CypherParser::oC_MergeAction() { exitRule(); }); try { - setState(1588); + setState(1620); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 221, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 224, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1578); + setState(1610); match(CypherParser::ON); - setState(1579); + setState(1611); match(CypherParser::SP); - setState(1580); + setState(1612); match(CypherParser::MATCH); - setState(1581); + setState(1613); match(CypherParser::SP); - setState(1582); + setState(1614); oC_Set(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1583); + setState(1615); match(CypherParser::ON); - setState(1584); + setState(1616); match(CypherParser::SP); - setState(1585); + setState(1617); match(CypherParser::CREATE); - setState(1586); + setState(1618); match(CypherParser::SP); - setState(1587); + setState(1619); oC_Set(); break; } @@ -9715,7 +9879,7 @@ size_t CypherParser::OC_SetContext::getRuleIndex() const { CypherParser::OC_SetContext* CypherParser::oC_Set() { OC_SetContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 166, CypherParser::RuleOC_Set); + enterRule(_localctx, 168, CypherParser::RuleOC_Set); size_t _la = 0; #if __cplusplus > 201703L @@ -9728,47 +9892,47 @@ CypherParser::OC_SetContext* CypherParser::oC_Set() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1590); + setState(1622); match(CypherParser::SET); - setState(1592); + setState(1624); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1591); + setState(1623); match(CypherParser::SP); } - setState(1594); + setState(1626); oC_SetItem(); - setState(1605); + setState(1637); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 225, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 228, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1596); + setState(1628); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1595); + setState(1627); match(CypherParser::SP); } - setState(1598); + setState(1630); match(CypherParser::T__2); - setState(1600); + setState(1632); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1599); + setState(1631); match(CypherParser::SP); } - setState(1602); + setState(1634); oC_SetItem(); } - setState(1607); + setState(1639); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 225, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 228, _ctx); } } @@ -9811,7 +9975,7 @@ size_t CypherParser::OC_SetItemContext::getRuleIndex() const { CypherParser::OC_SetItemContext* CypherParser::oC_SetItem() { OC_SetItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 168, CypherParser::RuleOC_SetItem); + enterRule(_localctx, 170, CypherParser::RuleOC_SetItem); size_t _la = 0; #if __cplusplus > 201703L @@ -9823,27 +9987,27 @@ CypherParser::OC_SetItemContext* CypherParser::oC_SetItem() { }); try { enterOuterAlt(_localctx, 1); - setState(1608); + setState(1640); oC_PropertyExpression(); - setState(1610); + setState(1642); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1609); + setState(1641); match(CypherParser::SP); } - setState(1612); + setState(1644); match(CypherParser::T__5); - setState(1614); + setState(1646); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1613); + setState(1645); match(CypherParser::SP); } - setState(1616); + setState(1648); oC_Expression(); } @@ -9894,7 +10058,7 @@ size_t CypherParser::OC_DeleteContext::getRuleIndex() const { CypherParser::OC_DeleteContext* CypherParser::oC_Delete() { OC_DeleteContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 170, CypherParser::RuleOC_Delete); + enterRule(_localctx, 172, CypherParser::RuleOC_Delete); size_t _la = 0; #if __cplusplus > 201703L @@ -9907,57 +10071,57 @@ CypherParser::OC_DeleteContext* CypherParser::oC_Delete() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1620); + setState(1652); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DETACH) { - setState(1618); + setState(1650); match(CypherParser::DETACH); - setState(1619); + setState(1651); match(CypherParser::SP); } - setState(1622); + setState(1654); match(CypherParser::DELETE); - setState(1624); + setState(1656); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1623); + setState(1655); match(CypherParser::SP); } - setState(1626); + setState(1658); oC_Expression(); - setState(1637); + setState(1669); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 232, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 235, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1628); + setState(1660); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1627); + setState(1659); match(CypherParser::SP); } - setState(1630); + setState(1662); match(CypherParser::T__2); - setState(1632); + setState(1664); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1631); + setState(1663); match(CypherParser::SP); } - setState(1634); + setState(1666); oC_Expression(); } - setState(1639); + setState(1671); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 232, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 235, _ctx); } } @@ -10000,7 +10164,7 @@ size_t CypherParser::OC_WithContext::getRuleIndex() const { CypherParser::OC_WithContext* CypherParser::oC_With() { OC_WithContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 172, CypherParser::RuleOC_With); + enterRule(_localctx, 174, CypherParser::RuleOC_With); size_t _la = 0; #if __cplusplus > 201703L @@ -10012,24 +10176,24 @@ CypherParser::OC_WithContext* CypherParser::oC_With() { }); try { enterOuterAlt(_localctx, 1); - setState(1640); + setState(1672); match(CypherParser::WITH); - setState(1641); + setState(1673); oC_ProjectionBody(); - setState(1646); + setState(1678); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 234, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 237, _ctx)) { case 1: { - setState(1643); + setState(1675); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1642); + setState(1674); match(CypherParser::SP); } - setState(1645); + setState(1677); oC_Where(); break; } @@ -10070,7 +10234,7 @@ size_t CypherParser::OC_ReturnContext::getRuleIndex() const { CypherParser::OC_ReturnContext* CypherParser::oC_Return() { OC_ReturnContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 174, CypherParser::RuleOC_Return); + enterRule(_localctx, 176, CypherParser::RuleOC_Return); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10081,9 +10245,9 @@ CypherParser::OC_ReturnContext* CypherParser::oC_Return() { }); try { enterOuterAlt(_localctx, 1); - setState(1648); + setState(1680); match(CypherParser::RETURN); - setState(1649); + setState(1681); oC_ProjectionBody(); } @@ -10138,7 +10302,7 @@ size_t CypherParser::OC_ProjectionBodyContext::getRuleIndex() const { CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { OC_ProjectionBodyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 176, CypherParser::RuleOC_ProjectionBody); + enterRule(_localctx, 178, CypherParser::RuleOC_ProjectionBody); size_t _la = 0; #if __cplusplus > 201703L @@ -10150,20 +10314,20 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { }); try { enterOuterAlt(_localctx, 1); - setState(1655); + setState(1687); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 236, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 239, _ctx)) { case 1: { - setState(1652); + setState(1684); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1651); + setState(1683); match(CypherParser::SP); } - setState(1654); + setState(1686); match(CypherParser::DISTINCT); break; } @@ -10171,18 +10335,18 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { default: break; } - setState(1657); + setState(1689); match(CypherParser::SP); - setState(1658); + setState(1690); oC_ProjectionItems(); - setState(1661); + setState(1693); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 237, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 240, _ctx)) { case 1: { - setState(1659); + setState(1691); match(CypherParser::SP); - setState(1660); + setState(1692); oC_Order(); break; } @@ -10190,14 +10354,14 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { default: break; } - setState(1665); + setState(1697); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 238, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 241, _ctx)) { case 1: { - setState(1663); + setState(1695); match(CypherParser::SP); - setState(1664); + setState(1696); oC_Skip(); break; } @@ -10205,14 +10369,14 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { default: break; } - setState(1669); + setState(1701); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 239, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 242, _ctx)) { case 1: { - setState(1667); + setState(1699); match(CypherParser::SP); - setState(1668); + setState(1700); oC_Limit(); break; } @@ -10265,7 +10429,7 @@ size_t CypherParser::OC_ProjectionItemsContext::getRuleIndex() const { CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() { OC_ProjectionItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 178, CypherParser::RuleOC_ProjectionItems); + enterRule(_localctx, 180, CypherParser::RuleOC_ProjectionItems); size_t _la = 0; #if __cplusplus > 201703L @@ -10277,42 +10441,42 @@ CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() { }); try { size_t alt; - setState(1699); + setState(1731); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::STAR: { enterOuterAlt(_localctx, 1); - setState(1671); + setState(1703); match(CypherParser::STAR); - setState(1682); + setState(1714); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 242, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 245, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1673); + setState(1705); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1672); + setState(1704); match(CypherParser::SP); } - setState(1675); + setState(1707); match(CypherParser::T__2); - setState(1677); + setState(1709); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1676); + setState(1708); match(CypherParser::SP); } - setState(1679); + setState(1711); oC_ProjectionItem(); } - setState(1684); + setState(1716); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 242, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 245, _ctx); } break; } @@ -10390,37 +10554,37 @@ CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() { case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 2); - setState(1685); + setState(1717); oC_ProjectionItem(); - setState(1696); + setState(1728); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 245, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 248, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1687); + setState(1719); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1686); + setState(1718); match(CypherParser::SP); } - setState(1689); + setState(1721); match(CypherParser::T__2); - setState(1691); + setState(1723); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1690); + setState(1722); match(CypherParser::SP); } - setState(1693); + setState(1725); oC_ProjectionItem(); } - setState(1698); + setState(1730); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 245, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 248, _ctx); } break; } @@ -10473,7 +10637,7 @@ size_t CypherParser::OC_ProjectionItemContext::getRuleIndex() const { CypherParser::OC_ProjectionItemContext* CypherParser::oC_ProjectionItem() { OC_ProjectionItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 180, CypherParser::RuleOC_ProjectionItem); + enterRule(_localctx, 182, CypherParser::RuleOC_ProjectionItem); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10483,27 +10647,27 @@ CypherParser::OC_ProjectionItemContext* CypherParser::oC_ProjectionItem() { exitRule(); }); try { - setState(1708); + setState(1740); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 247, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 250, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1701); + setState(1733); oC_Expression(); - setState(1702); + setState(1734); match(CypherParser::SP); - setState(1703); + setState(1735); match(CypherParser::AS); - setState(1704); + setState(1736); match(CypherParser::SP); - setState(1705); + setState(1737); oC_Variable(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1707); + setState(1739); oC_Expression(); break; } @@ -10560,7 +10724,7 @@ size_t CypherParser::OC_OrderContext::getRuleIndex() const { CypherParser::OC_OrderContext* CypherParser::oC_Order() { OC_OrderContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 182, CypherParser::RuleOC_Order); + enterRule(_localctx, 184, CypherParser::RuleOC_Order); size_t _la = 0; #if __cplusplus > 201703L @@ -10572,33 +10736,33 @@ CypherParser::OC_OrderContext* CypherParser::oC_Order() { }); try { enterOuterAlt(_localctx, 1); - setState(1710); + setState(1742); match(CypherParser::ORDER); - setState(1711); + setState(1743); match(CypherParser::SP); - setState(1712); + setState(1744); match(CypherParser::BY); - setState(1713); + setState(1745); match(CypherParser::SP); - setState(1714); + setState(1746); oC_SortItem(); - setState(1722); + setState(1754); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2) { - setState(1715); + setState(1747); match(CypherParser::T__2); - setState(1717); + setState(1749); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1716); + setState(1748); match(CypherParser::SP); } - setState(1719); + setState(1751); oC_SortItem(); - setState(1724); + setState(1756); _errHandler->sync(this); _la = _input->LA(1); } @@ -10639,7 +10803,7 @@ size_t CypherParser::OC_SkipContext::getRuleIndex() const { CypherParser::OC_SkipContext* CypherParser::oC_Skip() { OC_SkipContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 184, CypherParser::RuleOC_Skip); + enterRule(_localctx, 186, CypherParser::RuleOC_Skip); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10650,11 +10814,11 @@ CypherParser::OC_SkipContext* CypherParser::oC_Skip() { }); try { enterOuterAlt(_localctx, 1); - setState(1725); + setState(1757); match(CypherParser::L_SKIP); - setState(1726); + setState(1758); match(CypherParser::SP); - setState(1727); + setState(1759); oC_Expression(); } @@ -10693,7 +10857,7 @@ size_t CypherParser::OC_LimitContext::getRuleIndex() const { CypherParser::OC_LimitContext* CypherParser::oC_Limit() { OC_LimitContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 186, CypherParser::RuleOC_Limit); + enterRule(_localctx, 188, CypherParser::RuleOC_Limit); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10704,11 +10868,11 @@ CypherParser::OC_LimitContext* CypherParser::oC_Limit() { }); try { enterOuterAlt(_localctx, 1); - setState(1729); + setState(1761); match(CypherParser::LIMIT); - setState(1730); + setState(1762); match(CypherParser::SP); - setState(1731); + setState(1763); oC_Expression(); } @@ -10759,7 +10923,7 @@ size_t CypherParser::OC_SortItemContext::getRuleIndex() const { CypherParser::OC_SortItemContext* CypherParser::oC_SortItem() { OC_SortItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 188, CypherParser::RuleOC_SortItem); + enterRule(_localctx, 190, CypherParser::RuleOC_SortItem); size_t _la = 0; #if __cplusplus > 201703L @@ -10771,22 +10935,22 @@ CypherParser::OC_SortItemContext* CypherParser::oC_SortItem() { }); try { enterOuterAlt(_localctx, 1); - setState(1733); + setState(1765); oC_Expression(); - setState(1738); + setState(1770); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 251, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 254, _ctx)) { case 1: { - setState(1735); + setState(1767); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1734); + setState(1766); match(CypherParser::SP); } - setState(1737); + setState(1769); _la = _input->LA(1); if (!(((((_la - 52) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 52)) & 12582915) != 0))) { @@ -10839,7 +11003,7 @@ size_t CypherParser::OC_WhereContext::getRuleIndex() const { CypherParser::OC_WhereContext* CypherParser::oC_Where() { OC_WhereContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 190, CypherParser::RuleOC_Where); + enterRule(_localctx, 192, CypherParser::RuleOC_Where); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10850,11 +11014,11 @@ CypherParser::OC_WhereContext* CypherParser::oC_Where() { }); try { enterOuterAlt(_localctx, 1); - setState(1740); + setState(1772); match(CypherParser::WHERE); - setState(1741); + setState(1773); match(CypherParser::SP); - setState(1742); + setState(1774); oC_Expression(); } @@ -10897,7 +11061,7 @@ size_t CypherParser::OC_PatternContext::getRuleIndex() const { CypherParser::OC_PatternContext* CypherParser::oC_Pattern() { OC_PatternContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 192, CypherParser::RuleOC_Pattern); + enterRule(_localctx, 194, CypherParser::RuleOC_Pattern); size_t _la = 0; #if __cplusplus > 201703L @@ -10910,37 +11074,37 @@ CypherParser::OC_PatternContext* CypherParser::oC_Pattern() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1744); + setState(1776); oC_PatternPart(); - setState(1755); + setState(1787); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 254, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 257, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1746); + setState(1778); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1745); + setState(1777); match(CypherParser::SP); } - setState(1748); + setState(1780); match(CypherParser::T__2); - setState(1750); + setState(1782); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1749); + setState(1781); match(CypherParser::SP); } - setState(1752); + setState(1784); oC_PatternPart(); } - setState(1757); + setState(1789); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 254, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 257, _ctx); } } @@ -10983,7 +11147,7 @@ size_t CypherParser::OC_PatternPartContext::getRuleIndex() const { CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() { OC_PatternPartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 194, CypherParser::RuleOC_PatternPart); + enterRule(_localctx, 196, CypherParser::RuleOC_PatternPart); size_t _la = 0; #if __cplusplus > 201703L @@ -10994,7 +11158,7 @@ CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() { exitRule(); }); try { - setState(1769); + setState(1801); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::ADD: @@ -11051,34 +11215,34 @@ CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() { case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 1); - setState(1758); + setState(1790); oC_Variable(); - setState(1760); + setState(1792); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1759); + setState(1791); match(CypherParser::SP); } - setState(1762); + setState(1794); match(CypherParser::T__5); - setState(1764); + setState(1796); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1763); + setState(1795); match(CypherParser::SP); } - setState(1766); + setState(1798); oC_AnonymousPatternPart(); break; } case CypherParser::T__1: { enterOuterAlt(_localctx, 2); - setState(1768); + setState(1800); oC_AnonymousPatternPart(); break; } @@ -11115,7 +11279,7 @@ size_t CypherParser::OC_AnonymousPatternPartContext::getRuleIndex() const { CypherParser::OC_AnonymousPatternPartContext* CypherParser::oC_AnonymousPatternPart() { OC_AnonymousPatternPartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 196, CypherParser::RuleOC_AnonymousPatternPart); + enterRule(_localctx, 198, CypherParser::RuleOC_AnonymousPatternPart); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -11126,7 +11290,7 @@ CypherParser::OC_AnonymousPatternPartContext* CypherParser::oC_AnonymousPatternP }); try { enterOuterAlt(_localctx, 1); - setState(1771); + setState(1803); oC_PatternElement(); } @@ -11177,7 +11341,7 @@ size_t CypherParser::OC_PatternElementContext::getRuleIndex() const { CypherParser::OC_PatternElementContext* CypherParser::oC_PatternElement() { OC_PatternElementContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 198, CypherParser::RuleOC_PatternElement); + enterRule(_localctx, 200, CypherParser::RuleOC_PatternElement); size_t _la = 0; #if __cplusplus > 201703L @@ -11189,43 +11353,43 @@ CypherParser::OC_PatternElementContext* CypherParser::oC_PatternElement() { }); try { size_t alt; - setState(1787); + setState(1819); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 260, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 263, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1773); + setState(1805); oC_NodePattern(); - setState(1780); + setState(1812); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 259, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 262, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1775); + setState(1807); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1774); + setState(1806); match(CypherParser::SP); } - setState(1777); + setState(1809); oC_PatternElementChain(); } - setState(1782); + setState(1814); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 259, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 262, _ctx); } break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1783); + setState(1815); match(CypherParser::T__1); - setState(1784); + setState(1816); oC_PatternElement(); - setState(1785); + setState(1817); match(CypherParser::T__3); break; } @@ -11278,7 +11442,7 @@ size_t CypherParser::OC_NodePatternContext::getRuleIndex() const { CypherParser::OC_NodePatternContext* CypherParser::oC_NodePattern() { OC_NodePatternContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 200, CypherParser::RuleOC_NodePattern); + enterRule(_localctx, 202, CypherParser::RuleOC_NodePattern); size_t _la = 0; #if __cplusplus > 201703L @@ -11290,67 +11454,67 @@ CypherParser::OC_NodePatternContext* CypherParser::oC_NodePattern() { }); try { enterOuterAlt(_localctx, 1); - setState(1789); + setState(1821); match(CypherParser::T__1); - setState(1791); + setState(1823); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1790); + setState(1822); match(CypherParser::SP); } - setState(1797); + setState(1829); _errHandler->sync(this); _la = _input->LA(1); if (((((_la - 47) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 47)) & -2383877064657885291) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 121)) & 316935604865917) != 0)) { - setState(1793); + ((1ULL << (_la - 47)) & -4767754613118097515) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 111)) & 649084118765398017) != 0)) { + setState(1825); oC_Variable(); - setState(1795); + setState(1827); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1794); + setState(1826); match(CypherParser::SP); } } - setState(1803); + setState(1835); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COLON) { - setState(1799); + setState(1831); oC_NodeLabels(); - setState(1801); + setState(1833); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1800); + setState(1832); match(CypherParser::SP); } } - setState(1809); + setState(1841); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__8) { - setState(1805); + setState(1837); kU_Properties(); - setState(1807); + setState(1839); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1806); + setState(1838); match(CypherParser::SP); } } - setState(1811); + setState(1843); match(CypherParser::T__3); } @@ -11389,7 +11553,7 @@ size_t CypherParser::OC_PatternElementChainContext::getRuleIndex() const { CypherParser::OC_PatternElementChainContext* CypherParser::oC_PatternElementChain() { OC_PatternElementChainContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 202, CypherParser::RuleOC_PatternElementChain); + enterRule(_localctx, 204, CypherParser::RuleOC_PatternElementChain); size_t _la = 0; #if __cplusplus > 201703L @@ -11401,17 +11565,17 @@ CypherParser::OC_PatternElementChainContext* CypherParser::oC_PatternElementChai }); try { enterOuterAlt(_localctx, 1); - setState(1813); + setState(1845); oC_RelationshipPattern(); - setState(1815); + setState(1847); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1814); + setState(1846); match(CypherParser::SP); } - setState(1817); + setState(1849); oC_NodePattern(); } @@ -11466,7 +11630,7 @@ size_t CypherParser::OC_RelationshipPatternContext::getRuleIndex() const { CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPattern() { OC_RelationshipPatternContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 204, CypherParser::RuleOC_RelationshipPattern); + enterRule(_localctx, 206, CypherParser::RuleOC_RelationshipPattern); size_t _la = 0; #if __cplusplus > 201703L @@ -11477,29 +11641,29 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter exitRule(); }); try { - setState(1863); + setState(1895); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 280, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 283, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1819); + setState(1851); oC_LeftArrowHead(); - setState(1821); + setState(1853); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1820); + setState(1852); match(CypherParser::SP); } - setState(1823); + setState(1855); oC_Dash(); - setState(1825); + setState(1857); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 270, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 273, _ctx)) { case 1: { - setState(1824); + setState(1856); match(CypherParser::SP); break; } @@ -11507,37 +11671,37 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter default: break; } - setState(1828); + setState(1860); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__6) { - setState(1827); + setState(1859); oC_RelationshipDetail(); } - setState(1831); + setState(1863); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1830); + setState(1862); match(CypherParser::SP); } - setState(1833); + setState(1865); oC_Dash(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1835); + setState(1867); oC_Dash(); - setState(1837); + setState(1869); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 273, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 276, _ctx)) { case 1: { - setState(1836); + setState(1868); match(CypherParser::SP); break; } @@ -11545,47 +11709,47 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter default: break; } - setState(1840); + setState(1872); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__6) { - setState(1839); + setState(1871); oC_RelationshipDetail(); } - setState(1843); + setState(1875); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1842); + setState(1874); match(CypherParser::SP); } - setState(1845); + setState(1877); oC_Dash(); - setState(1847); + setState(1879); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1846); + setState(1878); match(CypherParser::SP); } - setState(1849); + setState(1881); oC_RightArrowHead(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(1851); + setState(1883); oC_Dash(); - setState(1853); + setState(1885); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 277, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 280, _ctx)) { case 1: { - setState(1852); + setState(1884); match(CypherParser::SP); break; } @@ -11593,23 +11757,23 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter default: break; } - setState(1856); + setState(1888); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__6) { - setState(1855); + setState(1887); oC_RelationshipDetail(); } - setState(1859); + setState(1891); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1858); + setState(1890); match(CypherParser::SP); } - setState(1861); + setState(1893); oC_Dash(); break; } @@ -11666,7 +11830,7 @@ size_t CypherParser::OC_RelationshipDetailContext::getRuleIndex() const { CypherParser::OC_RelationshipDetailContext* CypherParser::oC_RelationshipDetail() { OC_RelationshipDetailContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 206, CypherParser::RuleOC_RelationshipDetail); + enterRule(_localctx, 208, CypherParser::RuleOC_RelationshipDetail); size_t _la = 0; #if __cplusplus > 201703L @@ -11678,83 +11842,83 @@ CypherParser::OC_RelationshipDetailContext* CypherParser::oC_RelationshipDetail( }); try { enterOuterAlt(_localctx, 1); - setState(1865); + setState(1897); match(CypherParser::T__6); - setState(1867); + setState(1899); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1866); + setState(1898); match(CypherParser::SP); } - setState(1873); + setState(1905); _errHandler->sync(this); _la = _input->LA(1); if (((((_la - 47) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 47)) & -2383877064657885291) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 121)) & 316935604865917) != 0)) { - setState(1869); + ((1ULL << (_la - 47)) & -4767754613118097515) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 111)) & 649084118765398017) != 0)) { + setState(1901); oC_Variable(); - setState(1871); + setState(1903); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1870); + setState(1902); match(CypherParser::SP); } } - setState(1879); + setState(1911); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COLON) { - setState(1875); + setState(1907); oC_RelationshipTypes(); - setState(1877); + setState(1909); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1876); + setState(1908); match(CypherParser::SP); } } - setState(1885); + setState(1917); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::STAR) { - setState(1881); + setState(1913); oC_RangeLiteral(); - setState(1883); + setState(1915); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1882); + setState(1914); match(CypherParser::SP); } } - setState(1891); + setState(1923); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__8) { - setState(1887); + setState(1919); kU_Properties(); - setState(1889); + setState(1921); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1888); + setState(1920); match(CypherParser::SP); } } - setState(1893); + setState(1925); match(CypherParser::T__7); } @@ -11813,7 +11977,7 @@ size_t CypherParser::KU_PropertiesContext::getRuleIndex() const { CypherParser::KU_PropertiesContext* CypherParser::kU_Properties() { KU_PropertiesContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 208, CypherParser::RuleKU_Properties); + enterRule(_localctx, 210, CypherParser::RuleKU_Properties); size_t _la = 0; #if __cplusplus > 201703L @@ -11825,103 +11989,103 @@ CypherParser::KU_PropertiesContext* CypherParser::kU_Properties() { }); try { enterOuterAlt(_localctx, 1); - setState(1895); + setState(1927); match(CypherParser::T__8); - setState(1897); + setState(1929); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1896); + setState(1928); match(CypherParser::SP); } - setState(1932); + setState(1964); _errHandler->sync(this); _la = _input->LA(1); if (((((_la - 47) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 47)) & -2383877064657885291) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 121)) & 316935604865917) != 0)) { - setState(1899); + ((1ULL << (_la - 47)) & -4767754613118097515) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 111)) & 649084118765398017) != 0)) { + setState(1931); oC_PropertyKeyName(); - setState(1901); + setState(1933); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1900); + setState(1932); match(CypherParser::SP); } - setState(1903); + setState(1935); match(CypherParser::COLON); - setState(1905); + setState(1937); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1904); + setState(1936); match(CypherParser::SP); } - setState(1907); + setState(1939); oC_Expression(); - setState(1909); + setState(1941); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1908); + setState(1940); match(CypherParser::SP); } - setState(1929); + setState(1961); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2) { - setState(1911); + setState(1943); match(CypherParser::T__2); - setState(1913); + setState(1945); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1912); + setState(1944); match(CypherParser::SP); } - setState(1915); + setState(1947); oC_PropertyKeyName(); - setState(1917); + setState(1949); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1916); + setState(1948); match(CypherParser::SP); } - setState(1919); + setState(1951); match(CypherParser::COLON); - setState(1921); + setState(1953); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1920); + setState(1952); match(CypherParser::SP); } - setState(1923); + setState(1955); oC_Expression(); - setState(1925); + setState(1957); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1924); + setState(1956); match(CypherParser::SP); } - setState(1931); + setState(1963); _errHandler->sync(this); _la = _input->LA(1); } } - setState(1934); + setState(1966); match(CypherParser::T__9); } @@ -11972,7 +12136,7 @@ size_t CypherParser::OC_RelationshipTypesContext::getRuleIndex() const { CypherParser::OC_RelationshipTypesContext* CypherParser::oC_RelationshipTypes() { OC_RelationshipTypesContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 210, CypherParser::RuleOC_RelationshipTypes); + enterRule(_localctx, 212, CypherParser::RuleOC_RelationshipTypes); size_t _la = 0; #if __cplusplus > 201703L @@ -11985,55 +12149,55 @@ CypherParser::OC_RelationshipTypesContext* CypherParser::oC_RelationshipTypes() try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1936); + setState(1968); match(CypherParser::COLON); - setState(1938); + setState(1970); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1937); + setState(1969); match(CypherParser::SP); } - setState(1940); + setState(1972); oC_RelTypeName(); - setState(1954); + setState(1986); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 304, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 307, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1942); + setState(1974); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1941); + setState(1973); match(CypherParser::SP); } - setState(1944); + setState(1976); match(CypherParser::T__10); - setState(1946); + setState(1978); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COLON) { - setState(1945); + setState(1977); match(CypherParser::COLON); } - setState(1949); + setState(1981); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1948); + setState(1980); match(CypherParser::SP); } - setState(1951); + setState(1983); oC_RelTypeName(); } - setState(1956); + setState(1988); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 304, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 307, _ctx); } } @@ -12076,7 +12240,7 @@ size_t CypherParser::OC_NodeLabelsContext::getRuleIndex() const { CypherParser::OC_NodeLabelsContext* CypherParser::oC_NodeLabels() { OC_NodeLabelsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 212, CypherParser::RuleOC_NodeLabels); + enterRule(_localctx, 214, CypherParser::RuleOC_NodeLabels); size_t _la = 0; #if __cplusplus > 201703L @@ -12089,27 +12253,27 @@ CypherParser::OC_NodeLabelsContext* CypherParser::oC_NodeLabels() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1957); + setState(1989); oC_NodeLabel(); - setState(1964); + setState(1996); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 306, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 309, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1959); + setState(1991); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1958); + setState(1990); match(CypherParser::SP); } - setState(1961); + setState(1993); oC_NodeLabel(); } - setState(1966); + setState(1998); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 306, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 309, _ctx); } } @@ -12148,7 +12312,7 @@ size_t CypherParser::OC_NodeLabelContext::getRuleIndex() const { CypherParser::OC_NodeLabelContext* CypherParser::oC_NodeLabel() { OC_NodeLabelContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 214, CypherParser::RuleOC_NodeLabel); + enterRule(_localctx, 216, CypherParser::RuleOC_NodeLabel); size_t _la = 0; #if __cplusplus > 201703L @@ -12160,17 +12324,17 @@ CypherParser::OC_NodeLabelContext* CypherParser::oC_NodeLabel() { }); try { enterOuterAlt(_localctx, 1); - setState(1967); + setState(1999); match(CypherParser::COLON); - setState(1969); + setState(2001); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1968); + setState(2000); match(CypherParser::SP); } - setState(1971); + setState(2003); oC_LabelName(); } @@ -12233,7 +12397,7 @@ size_t CypherParser::OC_RangeLiteralContext::getRuleIndex() const { CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { OC_RangeLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 216, CypherParser::RuleOC_RangeLiteral); + enterRule(_localctx, 218, CypherParser::RuleOC_RangeLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -12245,14 +12409,14 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(1973); + setState(2005); match(CypherParser::STAR); - setState(1975); + setState(2007); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 308, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 311, _ctx)) { case 1: { - setState(1974); + setState(2006); match(CypherParser::SP); break; } @@ -12260,21 +12424,21 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1981); + setState(2013); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::SHORTEST: { - setState(1977); + setState(2009); match(CypherParser::SHORTEST); break; } case CypherParser::ALL: { - setState(1978); + setState(2010); match(CypherParser::ALL); - setState(1979); + setState(2011); match(CypherParser::SP); - setState(1980); + setState(2012); match(CypherParser::SHORTEST); break; } @@ -12291,12 +12455,12 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1984); + setState(2016); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 310, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 313, _ctx)) { case 1: { - setState(1983); + setState(2015); match(CypherParser::SP); break; } @@ -12304,35 +12468,35 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(2000); + setState(2032); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 315, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 318, _ctx)) { case 1: { - setState(1987); + setState(2019); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DecimalInteger) { - setState(1986); + setState(2018); oC_LowerBound(); } - setState(1990); + setState(2022); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1989); + setState(2021); match(CypherParser::SP); } - setState(1992); + setState(2024); match(CypherParser::T__11); - setState(1994); + setState(2026); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 313, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 316, _ctx)) { case 1: { - setState(1993); + setState(2025); match(CypherParser::SP); break; } @@ -12340,19 +12504,19 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1997); + setState(2029); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DecimalInteger) { - setState(1996); + setState(2028); oC_UpperBound(); } break; } case 2: { - setState(1999); + setState(2031); oC_IntegerLiteral(); break; } @@ -12360,20 +12524,20 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(2006); + setState(2038); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 317, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 320, _ctx)) { case 1: { - setState(2003); + setState(2035); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2002); + setState(2034); match(CypherParser::SP); } - setState(2005); + setState(2037); kU_RecursiveRelationshipComprehension(); break; } @@ -12434,7 +12598,7 @@ size_t CypherParser::KU_RecursiveRelationshipComprehensionContext::getRuleIndex( CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_RecursiveRelationshipComprehension() { KU_RecursiveRelationshipComprehensionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 218, CypherParser::RuleKU_RecursiveRelationshipComprehension); + enterRule(_localctx, 220, CypherParser::RuleKU_RecursiveRelationshipComprehension); size_t _la = 0; #if __cplusplus > 201703L @@ -12446,69 +12610,69 @@ CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_Rec }); try { enterOuterAlt(_localctx, 1); - setState(2008); + setState(2040); match(CypherParser::T__1); - setState(2010); + setState(2042); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2009); + setState(2041); match(CypherParser::SP); } - setState(2012); + setState(2044); oC_Variable(); - setState(2014); + setState(2046); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2013); + setState(2045); match(CypherParser::SP); } - setState(2016); + setState(2048); match(CypherParser::T__2); - setState(2018); + setState(2050); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2017); + setState(2049); match(CypherParser::SP); } - setState(2020); + setState(2052); oC_Variable(); - setState(2032); + setState(2064); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 324, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 327, _ctx)) { case 1: { - setState(2022); + setState(2054); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2021); + setState(2053); match(CypherParser::SP); } - setState(2024); + setState(2056); match(CypherParser::T__10); - setState(2026); + setState(2058); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2025); + setState(2057); match(CypherParser::SP); } - setState(2028); + setState(2060); oC_Where(); - setState(2030); + setState(2062); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 323, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 326, _ctx)) { case 1: { - setState(2029); + setState(2061); match(CypherParser::SP); break; } @@ -12522,61 +12686,61 @@ CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_Rec default: break; } - setState(2053); + setState(2085); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__10 || _la == CypherParser::SP) { - setState(2035); + setState(2067); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2034); + setState(2066); match(CypherParser::SP); } - setState(2037); + setState(2069); match(CypherParser::T__10); - setState(2039); + setState(2071); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2038); + setState(2070); match(CypherParser::SP); } - setState(2041); + setState(2073); kU_IntermediateRelProjectionItems(); - setState(2043); + setState(2075); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2042); + setState(2074); match(CypherParser::SP); } - setState(2045); + setState(2077); match(CypherParser::T__2); - setState(2047); + setState(2079); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2046); + setState(2078); match(CypherParser::SP); } - setState(2049); + setState(2081); kU_IntermediateNodeProjectionItems(); - setState(2051); + setState(2083); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2050); + setState(2082); match(CypherParser::SP); } } - setState(2055); + setState(2087); match(CypherParser::T__3); } @@ -12615,7 +12779,7 @@ size_t CypherParser::KU_IntermediateNodeProjectionItemsContext::getRuleIndex() c CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_IntermediateNodeProjectionItems() { KU_IntermediateNodeProjectionItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 220, CypherParser::RuleKU_IntermediateNodeProjectionItems); + enterRule(_localctx, 222, CypherParser::RuleKU_IntermediateNodeProjectionItems); size_t _la = 0; #if __cplusplus > 201703L @@ -12627,14 +12791,14 @@ CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_Interm }); try { enterOuterAlt(_localctx, 1); - setState(2057); + setState(2089); match(CypherParser::T__8); - setState(2059); + setState(2091); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 331, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 334, _ctx)) { case 1: { - setState(2058); + setState(2090); match(CypherParser::SP); break; } @@ -12642,26 +12806,26 @@ CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_Interm default: break; } - setState(2062); + setState(2094); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307439671051) != 0)) { - setState(2061); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307439671051) != 0)) { + setState(2093); oC_ProjectionItems(); } - setState(2065); + setState(2097); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2064); + setState(2096); match(CypherParser::SP); } - setState(2067); + setState(2099); match(CypherParser::T__9); } @@ -12700,7 +12864,7 @@ size_t CypherParser::KU_IntermediateRelProjectionItemsContext::getRuleIndex() co CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_IntermediateRelProjectionItems() { KU_IntermediateRelProjectionItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 222, CypherParser::RuleKU_IntermediateRelProjectionItems); + enterRule(_localctx, 224, CypherParser::RuleKU_IntermediateRelProjectionItems); size_t _la = 0; #if __cplusplus > 201703L @@ -12712,14 +12876,14 @@ CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_Interme }); try { enterOuterAlt(_localctx, 1); - setState(2069); + setState(2101); match(CypherParser::T__8); - setState(2071); + setState(2103); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 334, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 337, _ctx)) { case 1: { - setState(2070); + setState(2102); match(CypherParser::SP); break; } @@ -12727,26 +12891,26 @@ CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_Interme default: break; } - setState(2074); + setState(2106); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307439671051) != 0)) { - setState(2073); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307439671051) != 0)) { + setState(2105); oC_ProjectionItems(); } - setState(2077); + setState(2109); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2076); + setState(2108); match(CypherParser::SP); } - setState(2079); + setState(2111); match(CypherParser::T__9); } @@ -12777,7 +12941,7 @@ size_t CypherParser::OC_LowerBoundContext::getRuleIndex() const { CypherParser::OC_LowerBoundContext* CypherParser::oC_LowerBound() { OC_LowerBoundContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 224, CypherParser::RuleOC_LowerBound); + enterRule(_localctx, 226, CypherParser::RuleOC_LowerBound); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12788,7 +12952,7 @@ CypherParser::OC_LowerBoundContext* CypherParser::oC_LowerBound() { }); try { enterOuterAlt(_localctx, 1); - setState(2081); + setState(2113); match(CypherParser::DecimalInteger); } @@ -12819,7 +12983,7 @@ size_t CypherParser::OC_UpperBoundContext::getRuleIndex() const { CypherParser::OC_UpperBoundContext* CypherParser::oC_UpperBound() { OC_UpperBoundContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 226, CypherParser::RuleOC_UpperBound); + enterRule(_localctx, 228, CypherParser::RuleOC_UpperBound); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12830,7 +12994,7 @@ CypherParser::OC_UpperBoundContext* CypherParser::oC_UpperBound() { }); try { enterOuterAlt(_localctx, 1); - setState(2083); + setState(2115); match(CypherParser::DecimalInteger); } @@ -12861,7 +13025,7 @@ size_t CypherParser::OC_LabelNameContext::getRuleIndex() const { CypherParser::OC_LabelNameContext* CypherParser::oC_LabelName() { OC_LabelNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 228, CypherParser::RuleOC_LabelName); + enterRule(_localctx, 230, CypherParser::RuleOC_LabelName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12872,7 +13036,7 @@ CypherParser::OC_LabelNameContext* CypherParser::oC_LabelName() { }); try { enterOuterAlt(_localctx, 1); - setState(2085); + setState(2117); oC_SchemaName(); } @@ -12903,7 +13067,7 @@ size_t CypherParser::OC_RelTypeNameContext::getRuleIndex() const { CypherParser::OC_RelTypeNameContext* CypherParser::oC_RelTypeName() { OC_RelTypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 230, CypherParser::RuleOC_RelTypeName); + enterRule(_localctx, 232, CypherParser::RuleOC_RelTypeName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12914,7 +13078,7 @@ CypherParser::OC_RelTypeNameContext* CypherParser::oC_RelTypeName() { }); try { enterOuterAlt(_localctx, 1); - setState(2087); + setState(2119); oC_SchemaName(); } @@ -12945,7 +13109,7 @@ size_t CypherParser::OC_ExpressionContext::getRuleIndex() const { CypherParser::OC_ExpressionContext* CypherParser::oC_Expression() { OC_ExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 232, CypherParser::RuleOC_Expression); + enterRule(_localctx, 234, CypherParser::RuleOC_Expression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12956,7 +13120,7 @@ CypherParser::OC_ExpressionContext* CypherParser::oC_Expression() { }); try { enterOuterAlt(_localctx, 1); - setState(2089); + setState(2121); oC_OrExpression(); } @@ -13007,7 +13171,7 @@ size_t CypherParser::OC_OrExpressionContext::getRuleIndex() const { CypherParser::OC_OrExpressionContext* CypherParser::oC_OrExpression() { OC_OrExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 234, CypherParser::RuleOC_OrExpression); + enterRule(_localctx, 236, CypherParser::RuleOC_OrExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13019,25 +13183,25 @@ CypherParser::OC_OrExpressionContext* CypherParser::oC_OrExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2091); + setState(2123); oC_XorExpression(); - setState(2098); + setState(2130); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 337, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 340, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2092); + setState(2124); match(CypherParser::SP); - setState(2093); + setState(2125); match(CypherParser::OR); - setState(2094); + setState(2126); match(CypherParser::SP); - setState(2095); + setState(2127); oC_XorExpression(); } - setState(2100); + setState(2132); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 337, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 340, _ctx); } } @@ -13088,7 +13252,7 @@ size_t CypherParser::OC_XorExpressionContext::getRuleIndex() const { CypherParser::OC_XorExpressionContext* CypherParser::oC_XorExpression() { OC_XorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 236, CypherParser::RuleOC_XorExpression); + enterRule(_localctx, 238, CypherParser::RuleOC_XorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13100,25 +13264,25 @@ CypherParser::OC_XorExpressionContext* CypherParser::oC_XorExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2101); + setState(2133); oC_AndExpression(); - setState(2108); + setState(2140); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 338, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 341, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2102); + setState(2134); match(CypherParser::SP); - setState(2103); + setState(2135); match(CypherParser::XOR); - setState(2104); + setState(2136); match(CypherParser::SP); - setState(2105); + setState(2137); oC_AndExpression(); } - setState(2110); + setState(2142); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 338, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 341, _ctx); } } @@ -13169,7 +13333,7 @@ size_t CypherParser::OC_AndExpressionContext::getRuleIndex() const { CypherParser::OC_AndExpressionContext* CypherParser::oC_AndExpression() { OC_AndExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 238, CypherParser::RuleOC_AndExpression); + enterRule(_localctx, 240, CypherParser::RuleOC_AndExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13181,25 +13345,25 @@ CypherParser::OC_AndExpressionContext* CypherParser::oC_AndExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2111); + setState(2143); oC_NotExpression(); - setState(2118); + setState(2150); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 339, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 342, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2112); + setState(2144); match(CypherParser::SP); - setState(2113); + setState(2145); match(CypherParser::AND); - setState(2114); + setState(2146); match(CypherParser::SP); - setState(2115); + setState(2147); oC_NotExpression(); } - setState(2120); + setState(2152); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 339, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 342, _ctx); } } @@ -13246,7 +13410,7 @@ size_t CypherParser::OC_NotExpressionContext::getRuleIndex() const { CypherParser::OC_NotExpressionContext* CypherParser::oC_NotExpression() { OC_NotExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 240, CypherParser::RuleOC_NotExpression); + enterRule(_localctx, 242, CypherParser::RuleOC_NotExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13258,25 +13422,25 @@ CypherParser::OC_NotExpressionContext* CypherParser::oC_NotExpression() { }); try { enterOuterAlt(_localctx, 1); - setState(2127); + setState(2159); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::NOT) { - setState(2121); + setState(2153); match(CypherParser::NOT); - setState(2123); + setState(2155); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2122); + setState(2154); match(CypherParser::SP); } - setState(2129); + setState(2161); _errHandler->sync(this); _la = _input->LA(1); } - setState(2130); + setState(2162); oC_ComparisonExpression(); } @@ -13331,7 +13495,7 @@ size_t CypherParser::OC_ComparisonExpressionContext::getRuleIndex() const { CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpression() { OC_ComparisonExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 242, CypherParser::RuleOC_ComparisonExpression); + enterRule(_localctx, 244, CypherParser::RuleOC_ComparisonExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13343,37 +13507,37 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress }); try { size_t alt; - setState(2180); + setState(2212); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 352, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 355, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(2132); + setState(2164); kU_BitwiseOrOperatorExpression(); - setState(2142); + setState(2174); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 344, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 347, _ctx)) { case 1: { - setState(2134); + setState(2166); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2133); + setState(2165); match(CypherParser::SP); } - setState(2136); + setState(2168); kU_ComparisonOperator(); - setState(2138); + setState(2170); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2137); + setState(2169); match(CypherParser::SP); } - setState(2140); + setState(2172); kU_BitwiseOrOperatorExpression(); break; } @@ -13386,28 +13550,28 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress case 2: { enterOuterAlt(_localctx, 2); - setState(2144); + setState(2176); kU_BitwiseOrOperatorExpression(); - setState(2146); + setState(2178); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2145); + setState(2177); match(CypherParser::SP); } - setState(2148); + setState(2180); antlrcpp::downCast(_localctx)->invalid_not_equalToken = match(CypherParser::INVALID_NOT_EQUAL); - setState(2150); + setState(2182); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2149); + setState(2181); match(CypherParser::SP); } - setState(2152); + setState(2184); kU_BitwiseOrOperatorExpression(); notifyInvalidNotEqualOperator(antlrcpp::downCast(_localctx)->invalid_not_equalToken); break; @@ -13415,53 +13579,53 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress case 3: { enterOuterAlt(_localctx, 3); - setState(2156); + setState(2188); kU_BitwiseOrOperatorExpression(); - setState(2158); + setState(2190); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2157); + setState(2189); match(CypherParser::SP); } - setState(2160); + setState(2192); kU_ComparisonOperator(); - setState(2162); + setState(2194); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2161); + setState(2193); match(CypherParser::SP); } - setState(2164); + setState(2196); kU_BitwiseOrOperatorExpression(); - setState(2174); + setState(2206); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2166); + setState(2198); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2165); + setState(2197); match(CypherParser::SP); } - setState(2168); + setState(2200); kU_ComparisonOperator(); - setState(2170); + setState(2202); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2169); + setState(2201); match(CypherParser::SP); } - setState(2172); + setState(2204); kU_BitwiseOrOperatorExpression(); break; } @@ -13469,9 +13633,9 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress default: throw NoViableAltException(this); } - setState(2176); + setState(2208); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 351, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 354, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); notifyNonBinaryComparison(_localctx->start); break; @@ -13505,7 +13669,7 @@ size_t CypherParser::KU_ComparisonOperatorContext::getRuleIndex() const { CypherParser::KU_ComparisonOperatorContext* CypherParser::kU_ComparisonOperator() { KU_ComparisonOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 244, CypherParser::RuleKU_ComparisonOperator); + enterRule(_localctx, 246, CypherParser::RuleKU_ComparisonOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -13517,7 +13681,7 @@ CypherParser::KU_ComparisonOperatorContext* CypherParser::kU_ComparisonOperator( }); try { enterOuterAlt(_localctx, 1); - setState(2182); + setState(2214); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 254016) != 0))) { @@ -13568,7 +13732,7 @@ size_t CypherParser::KU_BitwiseOrOperatorExpressionContext::getRuleIndex() const CypherParser::KU_BitwiseOrOperatorExpressionContext* CypherParser::kU_BitwiseOrOperatorExpression() { KU_BitwiseOrOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 246, CypherParser::RuleKU_BitwiseOrOperatorExpression); + enterRule(_localctx, 248, CypherParser::RuleKU_BitwiseOrOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13581,37 +13745,37 @@ CypherParser::KU_BitwiseOrOperatorExpressionContext* CypherParser::kU_BitwiseOrO try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2184); + setState(2216); kU_BitwiseAndOperatorExpression(); - setState(2195); + setState(2227); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 355, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 358, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2186); + setState(2218); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2185); + setState(2217); match(CypherParser::SP); } - setState(2188); + setState(2220); match(CypherParser::T__10); - setState(2190); + setState(2222); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2189); + setState(2221); match(CypherParser::SP); } - setState(2192); + setState(2224); kU_BitwiseAndOperatorExpression(); } - setState(2197); + setState(2229); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 355, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 358, _ctx); } } @@ -13654,7 +13818,7 @@ size_t CypherParser::KU_BitwiseAndOperatorExpressionContext::getRuleIndex() cons CypherParser::KU_BitwiseAndOperatorExpressionContext* CypherParser::kU_BitwiseAndOperatorExpression() { KU_BitwiseAndOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 248, CypherParser::RuleKU_BitwiseAndOperatorExpression); + enterRule(_localctx, 250, CypherParser::RuleKU_BitwiseAndOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13667,37 +13831,37 @@ CypherParser::KU_BitwiseAndOperatorExpressionContext* CypherParser::kU_BitwiseAn try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2198); + setState(2230); kU_BitShiftOperatorExpression(); - setState(2209); + setState(2241); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 358, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 361, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2200); + setState(2232); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2199); + setState(2231); match(CypherParser::SP); } - setState(2202); + setState(2234); match(CypherParser::T__17); - setState(2204); + setState(2236); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2203); + setState(2235); match(CypherParser::SP); } - setState(2206); + setState(2238); kU_BitShiftOperatorExpression(); } - setState(2211); + setState(2243); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 358, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 361, _ctx); } } @@ -13748,7 +13912,7 @@ size_t CypherParser::KU_BitShiftOperatorExpressionContext::getRuleIndex() const CypherParser::KU_BitShiftOperatorExpressionContext* CypherParser::kU_BitShiftOperatorExpression() { KU_BitShiftOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 250, CypherParser::RuleKU_BitShiftOperatorExpression); + enterRule(_localctx, 252, CypherParser::RuleKU_BitShiftOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13761,37 +13925,37 @@ CypherParser::KU_BitShiftOperatorExpressionContext* CypherParser::kU_BitShiftOpe try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2212); + setState(2244); oC_AddOrSubtractExpression(); - setState(2224); + setState(2256); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 361, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 364, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2214); + setState(2246); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2213); + setState(2245); match(CypherParser::SP); } - setState(2216); + setState(2248); kU_BitShiftOperator(); - setState(2218); + setState(2250); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2217); + setState(2249); match(CypherParser::SP); } - setState(2220); + setState(2252); oC_AddOrSubtractExpression(); } - setState(2226); + setState(2258); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 361, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 364, _ctx); } } @@ -13818,7 +13982,7 @@ size_t CypherParser::KU_BitShiftOperatorContext::getRuleIndex() const { CypherParser::KU_BitShiftOperatorContext* CypherParser::kU_BitShiftOperator() { KU_BitShiftOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 252, CypherParser::RuleKU_BitShiftOperator); + enterRule(_localctx, 254, CypherParser::RuleKU_BitShiftOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -13830,7 +13994,7 @@ CypherParser::KU_BitShiftOperatorContext* CypherParser::kU_BitShiftOperator() { }); try { enterOuterAlt(_localctx, 1); - setState(2227); + setState(2259); _la = _input->LA(1); if (!(_la == CypherParser::T__18 @@ -13890,7 +14054,7 @@ size_t CypherParser::OC_AddOrSubtractExpressionContext::getRuleIndex() const { CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::oC_AddOrSubtractExpression() { OC_AddOrSubtractExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 254, CypherParser::RuleOC_AddOrSubtractExpression); + enterRule(_localctx, 256, CypherParser::RuleOC_AddOrSubtractExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13903,37 +14067,37 @@ CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::oC_AddOrSubtractE try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2229); + setState(2261); oC_MultiplyDivideModuloExpression(); - setState(2241); + setState(2273); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 364, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 367, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2231); + setState(2263); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2230); + setState(2262); match(CypherParser::SP); } - setState(2233); + setState(2265); kU_AddOrSubtractOperator(); - setState(2235); + setState(2267); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2234); + setState(2266); match(CypherParser::SP); } - setState(2237); + setState(2269); oC_MultiplyDivideModuloExpression(); } - setState(2243); + setState(2275); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 364, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 367, _ctx); } } @@ -13964,7 +14128,7 @@ size_t CypherParser::KU_AddOrSubtractOperatorContext::getRuleIndex() const { CypherParser::KU_AddOrSubtractOperatorContext* CypherParser::kU_AddOrSubtractOperator() { KU_AddOrSubtractOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 256, CypherParser::RuleKU_AddOrSubtractOperator); + enterRule(_localctx, 258, CypherParser::RuleKU_AddOrSubtractOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -13976,7 +14140,7 @@ CypherParser::KU_AddOrSubtractOperatorContext* CypherParser::kU_AddOrSubtractOpe }); try { enterOuterAlt(_localctx, 1); - setState(2244); + setState(2276); _la = _input->LA(1); if (!(_la == CypherParser::T__20 || _la == CypherParser::MINUS)) { _errHandler->recoverInline(this); @@ -14034,7 +14198,7 @@ size_t CypherParser::OC_MultiplyDivideModuloExpressionContext::getRuleIndex() co CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::oC_MultiplyDivideModuloExpression() { OC_MultiplyDivideModuloExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 258, CypherParser::RuleOC_MultiplyDivideModuloExpression); + enterRule(_localctx, 260, CypherParser::RuleOC_MultiplyDivideModuloExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14047,37 +14211,37 @@ CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::oC_Multipl try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2246); + setState(2278); oC_PowerOfExpression(); - setState(2258); + setState(2290); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 367, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 370, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2248); + setState(2280); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2247); + setState(2279); match(CypherParser::SP); } - setState(2250); + setState(2282); kU_MultiplyDivideModuloOperator(); - setState(2252); + setState(2284); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2251); + setState(2283); match(CypherParser::SP); } - setState(2254); + setState(2286); oC_PowerOfExpression(); } - setState(2260); + setState(2292); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 367, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 370, _ctx); } } @@ -14108,7 +14272,7 @@ size_t CypherParser::KU_MultiplyDivideModuloOperatorContext::getRuleIndex() cons CypherParser::KU_MultiplyDivideModuloOperatorContext* CypherParser::kU_MultiplyDivideModuloOperator() { KU_MultiplyDivideModuloOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 260, CypherParser::RuleKU_MultiplyDivideModuloOperator); + enterRule(_localctx, 262, CypherParser::RuleKU_MultiplyDivideModuloOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -14120,7 +14284,7 @@ CypherParser::KU_MultiplyDivideModuloOperatorContext* CypherParser::kU_MultiplyD }); try { enterOuterAlt(_localctx, 1); - setState(2261); + setState(2293); _la = _input->LA(1); if (!(_la == CypherParser::T__21 @@ -14172,7 +14336,7 @@ size_t CypherParser::OC_PowerOfExpressionContext::getRuleIndex() const { CypherParser::OC_PowerOfExpressionContext* CypherParser::oC_PowerOfExpression() { OC_PowerOfExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 262, CypherParser::RuleOC_PowerOfExpression); + enterRule(_localctx, 264, CypherParser::RuleOC_PowerOfExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14185,37 +14349,37 @@ CypherParser::OC_PowerOfExpressionContext* CypherParser::oC_PowerOfExpression() try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2263); + setState(2295); oC_UnaryAddSubtractOrFactorialExpression(); - setState(2274); + setState(2306); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 370, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 373, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2265); + setState(2297); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2264); + setState(2296); match(CypherParser::SP); } - setState(2267); + setState(2299); match(CypherParser::T__23); - setState(2269); + setState(2301); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2268); + setState(2300); match(CypherParser::SP); } - setState(2271); + setState(2303); oC_UnaryAddSubtractOrFactorialExpression(); } - setState(2276); + setState(2308); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 370, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 373, _ctx); } } @@ -14266,7 +14430,7 @@ size_t CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::getRuleInd CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::oC_UnaryAddSubtractOrFactorialExpression() { OC_UnaryAddSubtractOrFactorialExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 264, CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression); + enterRule(_localctx, 266, CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14278,40 +14442,40 @@ CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::oC_ }); try { enterOuterAlt(_localctx, 1); - setState(2283); + setState(2315); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::MINUS) { - setState(2277); + setState(2309); match(CypherParser::MINUS); - setState(2279); + setState(2311); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2278); + setState(2310); match(CypherParser::SP); } - setState(2285); + setState(2317); _errHandler->sync(this); _la = _input->LA(1); } - setState(2286); + setState(2318); oC_StringListNullOperatorExpression(); - setState(2291); + setState(2323); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 374, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 377, _ctx)) { case 1: { - setState(2288); + setState(2320); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2287); + setState(2319); match(CypherParser::SP); } - setState(2290); + setState(2322); match(CypherParser::FACTORIAL); break; } @@ -14364,7 +14528,7 @@ size_t CypherParser::OC_StringListNullOperatorExpressionContext::getRuleIndex() CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_StringListNullOperatorExpression() { OC_StringListNullOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 266, CypherParser::RuleOC_StringListNullOperatorExpression); + enterRule(_localctx, 268, CypherParser::RuleOC_StringListNullOperatorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -14376,26 +14540,26 @@ CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_Strin try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2293); + setState(2325); oC_PropertyOrLabelsExpression(); - setState(2301); + setState(2333); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 376, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 379, _ctx)) { case 1: { - setState(2294); + setState(2326); oC_StringOperatorExpression(); break; } case 2: { - setState(2296); + setState(2328); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2295); + setState(2327); oC_ListOperatorExpression(); break; } @@ -14403,15 +14567,15 @@ CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_Strin default: throw NoViableAltException(this); } - setState(2298); + setState(2330); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 375, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 378, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } case 3: { - setState(2300); + setState(2332); oC_NullOperatorExpression(); break; } @@ -14472,7 +14636,7 @@ size_t CypherParser::OC_ListOperatorExpressionContext::getRuleIndex() const { CypherParser::OC_ListOperatorExpressionContext* CypherParser::oC_ListOperatorExpression() { OC_ListOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 268, CypherParser::RuleOC_ListOperatorExpression); + enterRule(_localctx, 270, CypherParser::RuleOC_ListOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14483,68 +14647,68 @@ CypherParser::OC_ListOperatorExpressionContext* CypherParser::oC_ListOperatorExp exitRule(); }); try { - setState(2322); + setState(2354); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 380, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 383, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(2303); + setState(2335); match(CypherParser::SP); - setState(2304); + setState(2336); match(CypherParser::IN); - setState(2306); + setState(2338); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2305); + setState(2337); match(CypherParser::SP); } - setState(2308); + setState(2340); oC_PropertyOrLabelsExpression(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(2309); + setState(2341); match(CypherParser::T__6); - setState(2310); + setState(2342); oC_Expression(); - setState(2311); + setState(2343); match(CypherParser::T__7); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(2313); + setState(2345); match(CypherParser::T__6); - setState(2315); + setState(2347); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307437573899) != 0)) { - setState(2314); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307437573899) != 0)) { + setState(2346); oC_Expression(); } - setState(2317); + setState(2349); match(CypherParser::COLON); - setState(2319); + setState(2351); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307437573899) != 0)) { - setState(2318); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307437573899) != 0)) { + setState(2350); oC_Expression(); } - setState(2321); + setState(2353); match(CypherParser::T__7); break; } @@ -14609,7 +14773,7 @@ size_t CypherParser::OC_StringOperatorExpressionContext::getRuleIndex() const { CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperatorExpression() { OC_StringOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 270, CypherParser::RuleOC_StringOperatorExpression); + enterRule(_localctx, 272, CypherParser::RuleOC_StringOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14621,43 +14785,43 @@ CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperato }); try { enterOuterAlt(_localctx, 1); - setState(2335); + setState(2367); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 381, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 384, _ctx)) { case 1: { - setState(2324); + setState(2356); oC_RegularExpression(); break; } case 2: { - setState(2325); + setState(2357); match(CypherParser::SP); - setState(2326); + setState(2358); match(CypherParser::STARTS); - setState(2327); + setState(2359); match(CypherParser::SP); - setState(2328); + setState(2360); match(CypherParser::WITH); break; } case 3: { - setState(2329); + setState(2361); match(CypherParser::SP); - setState(2330); + setState(2362); match(CypherParser::ENDS); - setState(2331); + setState(2363); match(CypherParser::SP); - setState(2332); + setState(2364); match(CypherParser::WITH); break; } case 4: { - setState(2333); + setState(2365); match(CypherParser::SP); - setState(2334); + setState(2366); match(CypherParser::CONTAINS); break; } @@ -14665,15 +14829,15 @@ CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperato default: break; } - setState(2338); + setState(2370); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2337); + setState(2369); match(CypherParser::SP); } - setState(2340); + setState(2372); oC_PropertyOrLabelsExpression(); } @@ -14704,7 +14868,7 @@ size_t CypherParser::OC_RegularExpressionContext::getRuleIndex() const { CypherParser::OC_RegularExpressionContext* CypherParser::oC_RegularExpression() { OC_RegularExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 272, CypherParser::RuleOC_RegularExpression); + enterRule(_localctx, 274, CypherParser::RuleOC_RegularExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14716,15 +14880,15 @@ CypherParser::OC_RegularExpressionContext* CypherParser::oC_RegularExpression() }); try { enterOuterAlt(_localctx, 1); - setState(2343); + setState(2375); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2342); + setState(2374); match(CypherParser::SP); } - setState(2345); + setState(2377); match(CypherParser::T__24); } @@ -14771,7 +14935,7 @@ size_t CypherParser::OC_NullOperatorExpressionContext::getRuleIndex() const { CypherParser::OC_NullOperatorExpressionContext* CypherParser::oC_NullOperatorExpression() { OC_NullOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 274, CypherParser::RuleOC_NullOperatorExpression); + enterRule(_localctx, 276, CypherParser::RuleOC_NullOperatorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -14781,35 +14945,35 @@ CypherParser::OC_NullOperatorExpressionContext* CypherParser::oC_NullOperatorExp exitRule(); }); try { - setState(2357); + setState(2389); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 384, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 387, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(2347); + setState(2379); match(CypherParser::SP); - setState(2348); + setState(2380); match(CypherParser::IS); - setState(2349); + setState(2381); match(CypherParser::SP); - setState(2350); + setState(2382); match(CypherParser::NULL_); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(2351); + setState(2383); match(CypherParser::SP); - setState(2352); + setState(2384); match(CypherParser::IS); - setState(2353); + setState(2385); match(CypherParser::SP); - setState(2354); + setState(2386); match(CypherParser::NOT); - setState(2355); + setState(2387); match(CypherParser::SP); - setState(2356); + setState(2388); match(CypherParser::NULL_); break; } @@ -14862,7 +15026,7 @@ size_t CypherParser::OC_PropertyOrLabelsExpressionContext::getRuleIndex() const CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::oC_PropertyOrLabelsExpression() { OC_PropertyOrLabelsExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 276, CypherParser::RuleOC_PropertyOrLabelsExpression); + enterRule(_localctx, 278, CypherParser::RuleOC_PropertyOrLabelsExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -14875,27 +15039,27 @@ CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::oC_PropertyOrL try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2359); + setState(2391); oC_Atom(); - setState(2366); + setState(2398); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 386, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 389, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(2361); + setState(2393); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2360); + setState(2392); match(CypherParser::SP); } - setState(2363); + setState(2395); oC_PropertyLookup(); } - setState(2368); + setState(2400); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 386, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 389, _ctx); } } @@ -14962,7 +15126,7 @@ size_t CypherParser::OC_AtomContext::getRuleIndex() const { CypherParser::OC_AtomContext* CypherParser::oC_Atom() { OC_AtomContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 278, CypherParser::RuleOC_Atom); + enterRule(_localctx, 280, CypherParser::RuleOC_Atom); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -14972,75 +15136,75 @@ CypherParser::OC_AtomContext* CypherParser::oC_Atom() { exitRule(); }); try { - setState(2379); + setState(2411); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 387, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 390, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(2369); + setState(2401); oC_Literal(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(2370); + setState(2402); oC_Parameter(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(2371); + setState(2403); oC_CaseExpression(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(2372); + setState(2404); oC_ParenthesizedExpression(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(2373); + setState(2405); oC_FunctionInvocation(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(2374); + setState(2406); oC_PathPatterns(); break; } case 7: { enterOuterAlt(_localctx, 7); - setState(2375); + setState(2407); oC_ExistSubquery(); break; } case 8: { enterOuterAlt(_localctx, 8); - setState(2376); + setState(2408); kU_CountSubquery(); break; } case 9: { enterOuterAlt(_localctx, 9); - setState(2377); + setState(2409); oC_Variable(); break; } case 10: { enterOuterAlt(_localctx, 10); - setState(2378); + setState(2410); oC_Quantifier(); break; } @@ -15101,7 +15265,7 @@ size_t CypherParser::OC_QuantifierContext::getRuleIndex() const { CypherParser::OC_QuantifierContext* CypherParser::oC_Quantifier() { OC_QuantifierContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 280, CypherParser::RuleOC_Quantifier); + enterRule(_localctx, 282, CypherParser::RuleOC_Quantifier); size_t _la = 0; #if __cplusplus > 201703L @@ -15112,153 +15276,153 @@ CypherParser::OC_QuantifierContext* CypherParser::oC_Quantifier() { exitRule(); }); try { - setState(2437); + setState(2469); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::ALL: { enterOuterAlt(_localctx, 1); - setState(2381); + setState(2413); match(CypherParser::ALL); - setState(2383); + setState(2415); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2382); + setState(2414); match(CypherParser::SP); } - setState(2385); + setState(2417); match(CypherParser::T__1); - setState(2387); + setState(2419); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2386); + setState(2418); match(CypherParser::SP); } - setState(2389); + setState(2421); oC_FilterExpression(); - setState(2391); + setState(2423); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2390); + setState(2422); match(CypherParser::SP); } - setState(2393); + setState(2425); match(CypherParser::T__3); break; } case CypherParser::ANY: { enterOuterAlt(_localctx, 2); - setState(2395); + setState(2427); match(CypherParser::ANY); - setState(2397); + setState(2429); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2396); + setState(2428); match(CypherParser::SP); } - setState(2399); + setState(2431); match(CypherParser::T__1); - setState(2401); + setState(2433); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2400); + setState(2432); match(CypherParser::SP); } - setState(2403); + setState(2435); oC_FilterExpression(); - setState(2405); + setState(2437); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2404); + setState(2436); match(CypherParser::SP); } - setState(2407); + setState(2439); match(CypherParser::T__3); break; } case CypherParser::NONE: { enterOuterAlt(_localctx, 3); - setState(2409); + setState(2441); match(CypherParser::NONE); - setState(2411); + setState(2443); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2410); + setState(2442); match(CypherParser::SP); } - setState(2413); + setState(2445); match(CypherParser::T__1); - setState(2415); + setState(2447); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2414); + setState(2446); match(CypherParser::SP); } - setState(2417); + setState(2449); oC_FilterExpression(); - setState(2419); + setState(2451); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2418); + setState(2450); match(CypherParser::SP); } - setState(2421); + setState(2453); match(CypherParser::T__3); break; } case CypherParser::SINGLE: { enterOuterAlt(_localctx, 4); - setState(2423); + setState(2455); match(CypherParser::SINGLE); - setState(2425); + setState(2457); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2424); + setState(2456); match(CypherParser::SP); } - setState(2427); + setState(2459); match(CypherParser::T__1); - setState(2429); + setState(2461); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2428); + setState(2460); match(CypherParser::SP); } - setState(2431); + setState(2463); oC_FilterExpression(); - setState(2433); + setState(2465); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2432); + setState(2464); match(CypherParser::SP); } - setState(2435); + setState(2467); match(CypherParser::T__3); break; } @@ -15303,7 +15467,7 @@ size_t CypherParser::OC_FilterExpressionContext::getRuleIndex() const { CypherParser::OC_FilterExpressionContext* CypherParser::oC_FilterExpression() { OC_FilterExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 282, CypherParser::RuleOC_FilterExpression); + enterRule(_localctx, 284, CypherParser::RuleOC_FilterExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -15315,22 +15479,22 @@ CypherParser::OC_FilterExpressionContext* CypherParser::oC_FilterExpression() { }); try { enterOuterAlt(_localctx, 1); - setState(2439); + setState(2471); oC_IdInColl(); - setState(2444); + setState(2476); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 402, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 405, _ctx)) { case 1: { - setState(2441); + setState(2473); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2440); + setState(2472); match(CypherParser::SP); } - setState(2443); + setState(2475); oC_Where(); break; } @@ -15383,7 +15547,7 @@ size_t CypherParser::OC_IdInCollContext::getRuleIndex() const { CypherParser::OC_IdInCollContext* CypherParser::oC_IdInColl() { OC_IdInCollContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 284, CypherParser::RuleOC_IdInColl); + enterRule(_localctx, 286, CypherParser::RuleOC_IdInColl); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -15394,15 +15558,15 @@ CypherParser::OC_IdInCollContext* CypherParser::oC_IdInColl() { }); try { enterOuterAlt(_localctx, 1); - setState(2446); + setState(2478); oC_Variable(); - setState(2447); + setState(2479); match(CypherParser::SP); - setState(2448); + setState(2480); match(CypherParser::IN); - setState(2449); + setState(2481); match(CypherParser::SP); - setState(2450); + setState(2482); oC_Expression(); } @@ -15453,7 +15617,7 @@ size_t CypherParser::OC_LiteralContext::getRuleIndex() const { CypherParser::OC_LiteralContext* CypherParser::oC_Literal() { OC_LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 286, CypherParser::RuleOC_Literal); + enterRule(_localctx, 288, CypherParser::RuleOC_Literal); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -15463,20 +15627,20 @@ CypherParser::OC_LiteralContext* CypherParser::oC_Literal() { exitRule(); }); try { - setState(2458); + setState(2490); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::DecimalInteger: case CypherParser::RegularDecimalReal: { enterOuterAlt(_localctx, 1); - setState(2452); + setState(2484); oC_NumberLiteral(); break; } case CypherParser::StringLiteral: { enterOuterAlt(_localctx, 2); - setState(2453); + setState(2485); match(CypherParser::StringLiteral); break; } @@ -15484,28 +15648,28 @@ CypherParser::OC_LiteralContext* CypherParser::oC_Literal() { case CypherParser::FALSE: case CypherParser::TRUE: { enterOuterAlt(_localctx, 3); - setState(2454); + setState(2486); oC_BooleanLiteral(); break; } case CypherParser::NULL_: { enterOuterAlt(_localctx, 4); - setState(2455); + setState(2487); match(CypherParser::NULL_); break; } case CypherParser::T__6: { enterOuterAlt(_localctx, 5); - setState(2456); + setState(2488); oC_ListLiteral(); break; } case CypherParser::T__8: { enterOuterAlt(_localctx, 6); - setState(2457); + setState(2489); kU_StructLiteral(); break; } @@ -15546,7 +15710,7 @@ size_t CypherParser::OC_BooleanLiteralContext::getRuleIndex() const { CypherParser::OC_BooleanLiteralContext* CypherParser::oC_BooleanLiteral() { OC_BooleanLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 288, CypherParser::RuleOC_BooleanLiteral); + enterRule(_localctx, 290, CypherParser::RuleOC_BooleanLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -15558,7 +15722,7 @@ CypherParser::OC_BooleanLiteralContext* CypherParser::oC_BooleanLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2460); + setState(2492); _la = _input->LA(1); if (!(_la == CypherParser::FALSE @@ -15614,7 +15778,7 @@ size_t CypherParser::OC_ListLiteralContext::getRuleIndex() const { CypherParser::OC_ListLiteralContext* CypherParser::oC_ListLiteral() { OC_ListLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 290, CypherParser::RuleOC_ListLiteral); + enterRule(_localctx, 292, CypherParser::RuleOC_ListLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -15626,54 +15790,54 @@ CypherParser::OC_ListLiteralContext* CypherParser::oC_ListLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2462); + setState(2494); match(CypherParser::T__6); - setState(2464); + setState(2496); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2463); + setState(2495); match(CypherParser::SP); } - setState(2479); + setState(2511); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307437573899) != 0)) { - setState(2466); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307437573899) != 0)) { + setState(2498); oC_Expression(); - setState(2468); + setState(2500); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2467); + setState(2499); match(CypherParser::SP); } - setState(2476); + setState(2508); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2) { - setState(2470); + setState(2502); kU_ListEntry(); - setState(2472); + setState(2504); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2471); + setState(2503); match(CypherParser::SP); } - setState(2478); + setState(2510); _errHandler->sync(this); _la = _input->LA(1); } } - setState(2481); + setState(2513); match(CypherParser::T__7); } @@ -15708,7 +15872,7 @@ size_t CypherParser::KU_ListEntryContext::getRuleIndex() const { CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() { KU_ListEntryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 292, CypherParser::RuleKU_ListEntry); + enterRule(_localctx, 294, CypherParser::RuleKU_ListEntry); size_t _la = 0; #if __cplusplus > 201703L @@ -15720,14 +15884,14 @@ CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() { }); try { enterOuterAlt(_localctx, 1); - setState(2483); + setState(2515); match(CypherParser::T__2); - setState(2485); + setState(2517); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 409, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 412, _ctx)) { case 1: { - setState(2484); + setState(2516); match(CypherParser::SP); break; } @@ -15735,15 +15899,15 @@ CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() { default: break; } - setState(2488); + setState(2520); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307437573899) != 0)) { - setState(2487); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307437573899) != 0)) { + setState(2519); oC_Expression(); } @@ -15787,7 +15951,7 @@ size_t CypherParser::KU_StructLiteralContext::getRuleIndex() const { CypherParser::KU_StructLiteralContext* CypherParser::kU_StructLiteral() { KU_StructLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 294, CypherParser::RuleKU_StructLiteral); + enterRule(_localctx, 296, CypherParser::RuleKU_StructLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -15799,55 +15963,55 @@ CypherParser::KU_StructLiteralContext* CypherParser::kU_StructLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2490); + setState(2522); match(CypherParser::T__8); - setState(2492); + setState(2524); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2491); + setState(2523); match(CypherParser::SP); } - setState(2494); + setState(2526); kU_StructField(); - setState(2496); + setState(2528); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2495); + setState(2527); match(CypherParser::SP); } - setState(2508); + setState(2540); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2) { - setState(2498); + setState(2530); match(CypherParser::T__2); - setState(2500); + setState(2532); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2499); + setState(2531); match(CypherParser::SP); } - setState(2502); + setState(2534); kU_StructField(); - setState(2504); + setState(2536); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2503); + setState(2535); match(CypherParser::SP); } - setState(2510); + setState(2542); _errHandler->sync(this); _la = _input->LA(1); } - setState(2511); + setState(2543); match(CypherParser::T__9); } @@ -15898,7 +16062,7 @@ size_t CypherParser::KU_StructFieldContext::getRuleIndex() const { CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { KU_StructFieldContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 296, CypherParser::RuleKU_StructField); + enterRule(_localctx, 298, CypherParser::RuleKU_StructField); size_t _la = 0; #if __cplusplus > 201703L @@ -15910,7 +16074,7 @@ CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { }); try { enterOuterAlt(_localctx, 1); - setState(2515); + setState(2547); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::ADD: @@ -15966,13 +16130,13 @@ CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(2513); + setState(2545); oC_SymbolicName(); break; } case CypherParser::StringLiteral: { - setState(2514); + setState(2546); match(CypherParser::StringLiteral); break; } @@ -15980,25 +16144,25 @@ CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { default: throw NoViableAltException(this); } - setState(2518); + setState(2550); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2517); + setState(2549); match(CypherParser::SP); } - setState(2520); + setState(2552); match(CypherParser::COLON); - setState(2522); + setState(2554); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2521); + setState(2553); match(CypherParser::SP); } - setState(2524); + setState(2556); oC_Expression(); } @@ -16037,7 +16201,7 @@ size_t CypherParser::OC_ParenthesizedExpressionContext::getRuleIndex() const { CypherParser::OC_ParenthesizedExpressionContext* CypherParser::oC_ParenthesizedExpression() { OC_ParenthesizedExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 298, CypherParser::RuleOC_ParenthesizedExpression); + enterRule(_localctx, 300, CypherParser::RuleOC_ParenthesizedExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -16049,27 +16213,27 @@ CypherParser::OC_ParenthesizedExpressionContext* CypherParser::oC_ParenthesizedE }); try { enterOuterAlt(_localctx, 1); - setState(2526); + setState(2558); match(CypherParser::T__1); - setState(2528); + setState(2560); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2527); + setState(2559); match(CypherParser::SP); } - setState(2530); + setState(2562); oC_Expression(); - setState(2532); + setState(2564); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2531); + setState(2563); match(CypherParser::SP); } - setState(2534); + setState(2566); match(CypherParser::T__3); } @@ -16140,7 +16304,7 @@ size_t CypherParser::OC_FunctionInvocationContext::getRuleIndex() const { CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation() { OC_FunctionInvocationContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 300, CypherParser::RuleOC_FunctionInvocation); + enterRule(_localctx, 302, CypherParser::RuleOC_FunctionInvocation); size_t _la = 0; #if __cplusplus > 201703L @@ -16151,109 +16315,109 @@ CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation( exitRule(); }); try { - setState(2613); + setState(2645); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 440, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 443, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(2536); + setState(2568); match(CypherParser::COUNT); - setState(2538); + setState(2570); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2537); + setState(2569); match(CypherParser::SP); } - setState(2540); + setState(2572); match(CypherParser::T__1); - setState(2542); + setState(2574); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2541); + setState(2573); match(CypherParser::SP); } - setState(2544); + setState(2576); match(CypherParser::STAR); - setState(2546); + setState(2578); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2545); + setState(2577); match(CypherParser::SP); } - setState(2548); + setState(2580); match(CypherParser::T__3); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(2549); + setState(2581); match(CypherParser::CAST); - setState(2551); + setState(2583); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2550); + setState(2582); match(CypherParser::SP); } - setState(2553); + setState(2585); match(CypherParser::T__1); - setState(2555); + setState(2587); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2554); + setState(2586); match(CypherParser::SP); } - setState(2557); + setState(2589); kU_FunctionParameter(); - setState(2559); + setState(2591); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2558); + setState(2590); match(CypherParser::SP); } - setState(2571); + setState(2603); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::AS: { - setState(2561); + setState(2593); match(CypherParser::AS); - setState(2563); + setState(2595); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2562); + setState(2594); match(CypherParser::SP); } - setState(2565); + setState(2597); kU_DataType(0); break; } case CypherParser::T__2: { - setState(2566); + setState(2598); match(CypherParser::T__2); - setState(2568); + setState(2600); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2567); + setState(2599); match(CypherParser::SP); } - setState(2570); + setState(2602); kU_FunctionParameter(); break; } @@ -16261,105 +16425,105 @@ CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation( default: throw NoViableAltException(this); } - setState(2574); + setState(2606); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2573); + setState(2605); match(CypherParser::SP); } - setState(2576); + setState(2608); match(CypherParser::T__3); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(2578); + setState(2610); oC_FunctionName(); - setState(2580); + setState(2612); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2579); + setState(2611); match(CypherParser::SP); } - setState(2582); + setState(2614); match(CypherParser::T__1); - setState(2584); + setState(2616); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2583); + setState(2615); match(CypherParser::SP); } - setState(2590); + setState(2622); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DISTINCT) { - setState(2586); + setState(2618); match(CypherParser::DISTINCT); - setState(2588); + setState(2620); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2587); + setState(2619); match(CypherParser::SP); } } - setState(2609); + setState(2641); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & -2320550076679716220) != 0) || ((((_la - 65) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 65)) & 9007753110927321399) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 129)) & 1307437573899) != 0)) { - setState(2592); + ((1ULL << (_la - 65)) & -431237851856885449) != 0) || ((((_la - 130) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 130)) & 1307437573899) != 0)) { + setState(2624); kU_FunctionParameter(); - setState(2594); + setState(2626); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2593); + setState(2625); match(CypherParser::SP); } - setState(2606); + setState(2638); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2) { - setState(2596); + setState(2628); match(CypherParser::T__2); - setState(2598); + setState(2630); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2597); + setState(2629); match(CypherParser::SP); } - setState(2600); + setState(2632); kU_FunctionParameter(); - setState(2602); + setState(2634); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2601); + setState(2633); match(CypherParser::SP); } - setState(2608); + setState(2640); _errHandler->sync(this); _la = _input->LA(1); } } - setState(2611); + setState(2643); match(CypherParser::T__3); break; } @@ -16396,7 +16560,7 @@ size_t CypherParser::OC_FunctionNameContext::getRuleIndex() const { CypherParser::OC_FunctionNameContext* CypherParser::oC_FunctionName() { OC_FunctionNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 302, CypherParser::RuleOC_FunctionName); + enterRule(_localctx, 304, CypherParser::RuleOC_FunctionName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -16407,7 +16571,7 @@ CypherParser::OC_FunctionNameContext* CypherParser::oC_FunctionName() { }); try { enterOuterAlt(_localctx, 1); - setState(2615); + setState(2647); oC_SymbolicName(); } @@ -16458,7 +16622,7 @@ size_t CypherParser::KU_FunctionParameterContext::getRuleIndex() const { CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() { KU_FunctionParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 304, CypherParser::RuleKU_FunctionParameter); + enterRule(_localctx, 306, CypherParser::RuleKU_FunctionParameter); size_t _la = 0; #if __cplusplus > 201703L @@ -16469,36 +16633,36 @@ CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() exitRule(); }); try { - setState(2630); + setState(2662); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 444, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 447, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(2626); + setState(2658); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 443, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 446, _ctx)) { case 1: { - setState(2617); + setState(2649); oC_SymbolicName(); - setState(2619); + setState(2651); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2618); + setState(2650); match(CypherParser::SP); } - setState(2621); + setState(2653); match(CypherParser::COLON); - setState(2622); + setState(2654); match(CypherParser::T__5); - setState(2624); + setState(2656); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2623); + setState(2655); match(CypherParser::SP); } break; @@ -16507,14 +16671,14 @@ CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() default: break; } - setState(2628); + setState(2660); oC_Expression(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(2629); + setState(2661); kU_LambdaParameter(); break; } @@ -16567,7 +16731,7 @@ size_t CypherParser::KU_LambdaParameterContext::getRuleIndex() const { CypherParser::KU_LambdaParameterContext* CypherParser::kU_LambdaParameter() { KU_LambdaParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 306, CypherParser::RuleKU_LambdaParameter); + enterRule(_localctx, 308, CypherParser::RuleKU_LambdaParameter); size_t _la = 0; #if __cplusplus > 201703L @@ -16579,36 +16743,36 @@ CypherParser::KU_LambdaParameterContext* CypherParser::kU_LambdaParameter() { }); try { enterOuterAlt(_localctx, 1); - setState(2632); + setState(2664); kU_LambdaVars(); - setState(2634); + setState(2666); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2633); + setState(2665); match(CypherParser::SP); } - setState(2636); + setState(2668); match(CypherParser::MINUS); - setState(2637); + setState(2669); match(CypherParser::T__15); - setState(2639); + setState(2671); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2638); + setState(2670); match(CypherParser::SP); } - setState(2641); + setState(2673); oC_Expression(); - setState(2643); + setState(2675); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 447, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 450, _ctx)) { case 1: { - setState(2642); + setState(2674); match(CypherParser::SP); break; } @@ -16657,7 +16821,7 @@ size_t CypherParser::KU_LambdaVarsContext::getRuleIndex() const { CypherParser::KU_LambdaVarsContext* CypherParser::kU_LambdaVars() { KU_LambdaVarsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 308, CypherParser::RuleKU_LambdaVars); + enterRule(_localctx, 310, CypherParser::RuleKU_LambdaVars); size_t _la = 0; #if __cplusplus > 201703L @@ -16668,7 +16832,7 @@ CypherParser::KU_LambdaVarsContext* CypherParser::kU_LambdaVars() { exitRule(); }); try { - setState(2669); + setState(2701); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::ADD: @@ -16725,62 +16889,62 @@ CypherParser::KU_LambdaVarsContext* CypherParser::kU_LambdaVars() { case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 1); - setState(2645); + setState(2677); oC_SymbolicName(); break; } case CypherParser::T__1: { enterOuterAlt(_localctx, 2); - setState(2646); + setState(2678); match(CypherParser::T__1); - setState(2648); + setState(2680); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2647); + setState(2679); match(CypherParser::SP); } - setState(2650); + setState(2682); oC_SymbolicName(); - setState(2652); + setState(2684); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2651); + setState(2683); match(CypherParser::SP); } - setState(2664); + setState(2696); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__2) { - setState(2654); + setState(2686); match(CypherParser::T__2); - setState(2656); + setState(2688); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2655); + setState(2687); match(CypherParser::SP); } - setState(2658); + setState(2690); oC_SymbolicName(); - setState(2660); + setState(2692); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2659); + setState(2691); match(CypherParser::SP); } - setState(2666); + setState(2698); _errHandler->sync(this); _la = _input->LA(1); } - setState(2667); + setState(2699); match(CypherParser::T__3); break; } @@ -16833,7 +16997,7 @@ size_t CypherParser::OC_PathPatternsContext::getRuleIndex() const { CypherParser::OC_PathPatternsContext* CypherParser::oC_PathPatterns() { OC_PathPatternsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 310, CypherParser::RuleOC_PathPatterns); + enterRule(_localctx, 312, CypherParser::RuleOC_PathPatterns); size_t _la = 0; #if __cplusplus > 201703L @@ -16846,23 +17010,23 @@ CypherParser::OC_PathPatternsContext* CypherParser::oC_PathPatterns() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2671); + setState(2703); oC_NodePattern(); - setState(2676); + setState(2708); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2673); + setState(2705); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2672); + setState(2704); match(CypherParser::SP); } - setState(2675); + setState(2707); oC_PatternElementChain(); break; } @@ -16870,9 +17034,9 @@ CypherParser::OC_PathPatternsContext* CypherParser::oC_PathPatterns() { default: throw NoViableAltException(this); } - setState(2678); + setState(2710); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 455, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 458, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); } @@ -16923,7 +17087,7 @@ size_t CypherParser::OC_ExistSubqueryContext::getRuleIndex() const { CypherParser::OC_ExistSubqueryContext* CypherParser::oC_ExistSubquery() { OC_ExistSubqueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 312, CypherParser::RuleOC_ExistSubquery); + enterRule(_localctx, 314, CypherParser::RuleOC_ExistSubquery); size_t _la = 0; #if __cplusplus > 201703L @@ -16935,52 +17099,52 @@ CypherParser::OC_ExistSubqueryContext* CypherParser::oC_ExistSubquery() { }); try { enterOuterAlt(_localctx, 1); - setState(2680); + setState(2712); match(CypherParser::EXISTS); - setState(2682); + setState(2714); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2681); + setState(2713); match(CypherParser::SP); } - setState(2684); + setState(2716); match(CypherParser::T__8); - setState(2686); + setState(2718); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2685); + setState(2717); match(CypherParser::SP); } - setState(2688); + setState(2720); match(CypherParser::MATCH); - setState(2690); + setState(2722); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2689); + setState(2721); match(CypherParser::SP); } - setState(2692); + setState(2724); oC_Pattern(); - setState(2697); + setState(2729); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 460, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 463, _ctx)) { case 1: { - setState(2694); + setState(2726); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2693); + setState(2725); match(CypherParser::SP); } - setState(2696); + setState(2728); oC_Where(); break; } @@ -16988,15 +17152,15 @@ CypherParser::OC_ExistSubqueryContext* CypherParser::oC_ExistSubquery() { default: break; } - setState(2700); + setState(2732); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2699); + setState(2731); match(CypherParser::SP); } - setState(2702); + setState(2734); match(CypherParser::T__9); } @@ -17047,7 +17211,7 @@ size_t CypherParser::KU_CountSubqueryContext::getRuleIndex() const { CypherParser::KU_CountSubqueryContext* CypherParser::kU_CountSubquery() { KU_CountSubqueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 314, CypherParser::RuleKU_CountSubquery); + enterRule(_localctx, 316, CypherParser::RuleKU_CountSubquery); size_t _la = 0; #if __cplusplus > 201703L @@ -17059,52 +17223,52 @@ CypherParser::KU_CountSubqueryContext* CypherParser::kU_CountSubquery() { }); try { enterOuterAlt(_localctx, 1); - setState(2704); + setState(2736); match(CypherParser::COUNT); - setState(2706); + setState(2738); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2705); + setState(2737); match(CypherParser::SP); } - setState(2708); + setState(2740); match(CypherParser::T__8); - setState(2710); + setState(2742); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2709); + setState(2741); match(CypherParser::SP); } - setState(2712); + setState(2744); match(CypherParser::MATCH); - setState(2714); + setState(2746); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2713); + setState(2745); match(CypherParser::SP); } - setState(2716); + setState(2748); oC_Pattern(); - setState(2721); + setState(2753); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 466, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 469, _ctx)) { case 1: { - setState(2718); + setState(2750); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2717); + setState(2749); match(CypherParser::SP); } - setState(2720); + setState(2752); oC_Where(); break; } @@ -17112,15 +17276,15 @@ CypherParser::KU_CountSubqueryContext* CypherParser::kU_CountSubquery() { default: break; } - setState(2724); + setState(2756); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2723); + setState(2755); match(CypherParser::SP); } - setState(2726); + setState(2758); match(CypherParser::T__9); } @@ -17159,7 +17323,7 @@ size_t CypherParser::OC_PropertyLookupContext::getRuleIndex() const { CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() { OC_PropertyLookupContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 316, CypherParser::RuleOC_PropertyLookup); + enterRule(_localctx, 318, CypherParser::RuleOC_PropertyLookup); size_t _la = 0; #if __cplusplus > 201703L @@ -17171,17 +17335,17 @@ CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() { }); try { enterOuterAlt(_localctx, 1); - setState(2728); + setState(2760); match(CypherParser::T__4); - setState(2730); + setState(2762); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2729); + setState(2761); match(CypherParser::SP); } - setState(2734); + setState(2766); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::ADD: @@ -17237,13 +17401,13 @@ CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() { case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(2732); + setState(2764); oC_PropertyKeyName(); break; } case CypherParser::STAR: { - setState(2733); + setState(2765); match(CypherParser::STAR); break; } @@ -17262,6 +17426,63 @@ CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() { return _localctx; } +//----------------- KU_TableLookupContext ------------------------------------------------------------------ + +CypherParser::KU_TableLookupContext::KU_TableLookupContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +CypherParser::OC_SchemaNameContext* CypherParser::KU_TableLookupContext::oC_SchemaName() { + return getRuleContext(0); +} + +tree::TerminalNode* CypherParser::KU_TableLookupContext::SP() { + return getToken(CypherParser::SP, 0); +} + + +size_t CypherParser::KU_TableLookupContext::getRuleIndex() const { + return CypherParser::RuleKU_TableLookup; +} + + +CypherParser::KU_TableLookupContext* CypherParser::kU_TableLookup() { + KU_TableLookupContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 320, CypherParser::RuleKU_TableLookup); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(2768); + match(CypherParser::T__4); + setState(2770); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(2769); + match(CypherParser::SP); + } + setState(2772); + oC_SchemaName(); + + } + 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) @@ -17312,7 +17533,7 @@ size_t CypherParser::OC_CaseExpressionContext::getRuleIndex() const { CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { OC_CaseExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 318, CypherParser::RuleOC_CaseExpression); + enterRule(_localctx, 322, CypherParser::RuleOC_CaseExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -17325,27 +17546,27 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2758); + setState(2796); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 475, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 479, _ctx)) { case 1: { - setState(2736); + setState(2774); match(CypherParser::CASE); - setState(2741); + setState(2779); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2738); + setState(2776); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2737); + setState(2775); match(CypherParser::SP); } - setState(2740); + setState(2778); oC_CaseAlternative(); break; } @@ -17353,41 +17574,41 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: throw NoViableAltException(this); } - setState(2743); + setState(2781); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 471, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 475, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } case 2: { - setState(2745); + setState(2783); match(CypherParser::CASE); - setState(2747); + setState(2785); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2746); + setState(2784); match(CypherParser::SP); } - setState(2749); + setState(2787); oC_Expression(); - setState(2754); + setState(2792); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2751); + setState(2789); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2750); + setState(2788); match(CypherParser::SP); } - setState(2753); + setState(2791); oC_CaseAlternative(); break; } @@ -17395,9 +17616,9 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: throw NoViableAltException(this); } - setState(2756); + setState(2794); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 474, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 478, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } @@ -17405,30 +17626,30 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: break; } - setState(2768); + setState(2806); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 478, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 482, _ctx)) { case 1: { - setState(2761); + setState(2799); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2760); + setState(2798); match(CypherParser::SP); } - setState(2763); + setState(2801); match(CypherParser::ELSE); - setState(2765); + setState(2803); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2764); + setState(2802); match(CypherParser::SP); } - setState(2767); + setState(2805); oC_Expression(); break; } @@ -17436,15 +17657,15 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: break; } - setState(2771); + setState(2809); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2770); + setState(2808); match(CypherParser::SP); } - setState(2773); + setState(2811); match(CypherParser::END); } @@ -17495,7 +17716,7 @@ size_t CypherParser::OC_CaseAlternativeContext::getRuleIndex() const { CypherParser::OC_CaseAlternativeContext* CypherParser::oC_CaseAlternative() { OC_CaseAlternativeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 320, CypherParser::RuleOC_CaseAlternative); + enterRule(_localctx, 324, CypherParser::RuleOC_CaseAlternative); size_t _la = 0; #if __cplusplus > 201703L @@ -17507,37 +17728,37 @@ CypherParser::OC_CaseAlternativeContext* CypherParser::oC_CaseAlternative() { }); try { enterOuterAlt(_localctx, 1); - setState(2775); + setState(2813); match(CypherParser::WHEN); - setState(2777); + setState(2815); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2776); + setState(2814); match(CypherParser::SP); } - setState(2779); + setState(2817); oC_Expression(); - setState(2781); + setState(2819); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2780); + setState(2818); match(CypherParser::SP); } - setState(2783); + setState(2821); match(CypherParser::THEN); - setState(2785); + setState(2823); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2784); + setState(2822); match(CypherParser::SP); } - setState(2787); + setState(2825); oC_Expression(); } @@ -17568,7 +17789,7 @@ size_t CypherParser::OC_VariableContext::getRuleIndex() const { CypherParser::OC_VariableContext* CypherParser::oC_Variable() { OC_VariableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 322, CypherParser::RuleOC_Variable); + enterRule(_localctx, 326, CypherParser::RuleOC_Variable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17579,7 +17800,7 @@ CypherParser::OC_VariableContext* CypherParser::oC_Variable() { }); try { enterOuterAlt(_localctx, 1); - setState(2789); + setState(2827); oC_SymbolicName(); } @@ -17614,7 +17835,7 @@ size_t CypherParser::OC_NumberLiteralContext::getRuleIndex() const { CypherParser::OC_NumberLiteralContext* CypherParser::oC_NumberLiteral() { OC_NumberLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 324, CypherParser::RuleOC_NumberLiteral); + enterRule(_localctx, 328, CypherParser::RuleOC_NumberLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17624,19 +17845,19 @@ CypherParser::OC_NumberLiteralContext* CypherParser::oC_NumberLiteral() { exitRule(); }); try { - setState(2793); + setState(2831); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::RegularDecimalReal: { enterOuterAlt(_localctx, 1); - setState(2791); + setState(2829); oC_DoubleLiteral(); break; } case CypherParser::DecimalInteger: { enterOuterAlt(_localctx, 2); - setState(2792); + setState(2830); oC_IntegerLiteral(); break; } @@ -17677,7 +17898,7 @@ size_t CypherParser::OC_ParameterContext::getRuleIndex() const { CypherParser::OC_ParameterContext* CypherParser::oC_Parameter() { OC_ParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 326, CypherParser::RuleOC_Parameter); + enterRule(_localctx, 330, CypherParser::RuleOC_Parameter); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17688,9 +17909,9 @@ CypherParser::OC_ParameterContext* CypherParser::oC_Parameter() { }); try { enterOuterAlt(_localctx, 1); - setState(2795); + setState(2833); match(CypherParser::T__25); - setState(2798); + setState(2836); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::ADD: @@ -17746,13 +17967,13 @@ CypherParser::OC_ParameterContext* CypherParser::oC_Parameter() { case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(2796); + setState(2834); oC_SymbolicName(); break; } case CypherParser::DecimalInteger: { - setState(2797); + setState(2835); match(CypherParser::DecimalInteger); break; } @@ -17797,7 +18018,7 @@ size_t CypherParser::OC_PropertyExpressionContext::getRuleIndex() const { CypherParser::OC_PropertyExpressionContext* CypherParser::oC_PropertyExpression() { OC_PropertyExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 328, CypherParser::RuleOC_PropertyExpression); + enterRule(_localctx, 332, CypherParser::RuleOC_PropertyExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -17809,17 +18030,17 @@ CypherParser::OC_PropertyExpressionContext* CypherParser::oC_PropertyExpression( }); try { enterOuterAlt(_localctx, 1); - setState(2800); + setState(2838); oC_Atom(); - setState(2802); + setState(2840); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2801); + setState(2839); match(CypherParser::SP); } - setState(2804); + setState(2842); oC_PropertyLookup(); } @@ -17850,7 +18071,7 @@ size_t CypherParser::OC_PropertyKeyNameContext::getRuleIndex() const { CypherParser::OC_PropertyKeyNameContext* CypherParser::oC_PropertyKeyName() { OC_PropertyKeyNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 330, CypherParser::RuleOC_PropertyKeyName); + enterRule(_localctx, 334, CypherParser::RuleOC_PropertyKeyName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17861,7 +18082,7 @@ CypherParser::OC_PropertyKeyNameContext* CypherParser::oC_PropertyKeyName() { }); try { enterOuterAlt(_localctx, 1); - setState(2806); + setState(2844); oC_SchemaName(); } @@ -17892,7 +18113,7 @@ size_t CypherParser::OC_IntegerLiteralContext::getRuleIndex() const { CypherParser::OC_IntegerLiteralContext* CypherParser::oC_IntegerLiteral() { OC_IntegerLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 332, CypherParser::RuleOC_IntegerLiteral); + enterRule(_localctx, 336, CypherParser::RuleOC_IntegerLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17903,7 +18124,7 @@ CypherParser::OC_IntegerLiteralContext* CypherParser::oC_IntegerLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2808); + setState(2846); match(CypherParser::DecimalInteger); } @@ -17934,7 +18155,7 @@ size_t CypherParser::OC_DoubleLiteralContext::getRuleIndex() const { CypherParser::OC_DoubleLiteralContext* CypherParser::oC_DoubleLiteral() { OC_DoubleLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 334, CypherParser::RuleOC_DoubleLiteral); + enterRule(_localctx, 338, CypherParser::RuleOC_DoubleLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17945,7 +18166,7 @@ CypherParser::OC_DoubleLiteralContext* CypherParser::oC_DoubleLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2810); + setState(2848); match(CypherParser::RegularDecimalReal); } @@ -17976,7 +18197,7 @@ size_t CypherParser::OC_SchemaNameContext::getRuleIndex() const { CypherParser::OC_SchemaNameContext* CypherParser::oC_SchemaName() { OC_SchemaNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 336, CypherParser::RuleOC_SchemaName); + enterRule(_localctx, 340, CypherParser::RuleOC_SchemaName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -17987,7 +18208,7 @@ CypherParser::OC_SchemaNameContext* CypherParser::oC_SchemaName() { }); try { enterOuterAlt(_localctx, 1); - setState(2812); + setState(2850); oC_SymbolicName(); } @@ -18030,7 +18251,7 @@ size_t CypherParser::OC_SymbolicNameContext::getRuleIndex() const { CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { OC_SymbolicNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 338, CypherParser::RuleOC_SymbolicName); + enterRule(_localctx, 342, CypherParser::RuleOC_SymbolicName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -18040,19 +18261,19 @@ CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { exitRule(); }); try { - setState(2819); + setState(2857); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::UnescapedSymbolicName: { enterOuterAlt(_localctx, 1); - setState(2814); + setState(2852); match(CypherParser::UnescapedSymbolicName); break; } case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 2); - setState(2815); + setState(2853); antlrcpp::downCast(_localctx)->escapedsymbolicnameToken = match(CypherParser::EscapedSymbolicName); if ((antlrcpp::downCast(_localctx)->escapedsymbolicnameToken != nullptr ? antlrcpp::downCast(_localctx)->escapedsymbolicnameToken->getText() : "") == "``") { notifyEmptyToken(antlrcpp::downCast(_localctx)->escapedsymbolicnameToken); } break; @@ -18060,7 +18281,7 @@ CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { case CypherParser::HexLetter: { enterOuterAlt(_localctx, 3); - setState(2817); + setState(2855); match(CypherParser::HexLetter); break; } @@ -18116,7 +18337,7 @@ CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { case CypherParser::DECIMAL: case CypherParser::L_SKIP: { enterOuterAlt(_localctx, 4); - setState(2818); + setState(2856); kU_NonReservedKeywords(); break; } @@ -18349,7 +18570,7 @@ size_t CypherParser::KU_NonReservedKeywordsContext::getRuleIndex() const { CypherParser::KU_NonReservedKeywordsContext* CypherParser::kU_NonReservedKeywords() { KU_NonReservedKeywordsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 340, CypherParser::RuleKU_NonReservedKeywords); + enterRule(_localctx, 344, CypherParser::RuleKU_NonReservedKeywords); size_t _la = 0; #if __cplusplus > 201703L @@ -18361,11 +18582,11 @@ CypherParser::KU_NonReservedKeywordsContext* CypherParser::kU_NonReservedKeyword }); try { enterOuterAlt(_localctx, 1); - setState(2821); + setState(2859); _la = _input->LA(1); if (!(((((_la - 47) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 47)) & -2383877064657885291) != 0) || ((((_la - 121) & ~ 0x3fULL) == 0) && - ((1ULL << (_la - 121)) & 1378159485) != 0))) { + ((1ULL << (_la - 47)) & -4767754613118097515) != 0) || ((((_la - 111) & ~ 0x3fULL) == 0) && + ((1ULL << (_la - 111)) & 2822470625281) != 0))) { _errHandler->recoverInline(this); } else { @@ -18397,7 +18618,7 @@ size_t CypherParser::OC_LeftArrowHeadContext::getRuleIndex() const { CypherParser::OC_LeftArrowHeadContext* CypherParser::oC_LeftArrowHead() { OC_LeftArrowHeadContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 342, CypherParser::RuleOC_LeftArrowHead); + enterRule(_localctx, 346, CypherParser::RuleOC_LeftArrowHead); size_t _la = 0; #if __cplusplus > 201703L @@ -18409,7 +18630,7 @@ CypherParser::OC_LeftArrowHeadContext* CypherParser::oC_LeftArrowHead() { }); try { enterOuterAlt(_localctx, 1); - setState(2823); + setState(2861); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 2013282304) != 0))) { @@ -18444,7 +18665,7 @@ size_t CypherParser::OC_RightArrowHeadContext::getRuleIndex() const { CypherParser::OC_RightArrowHeadContext* CypherParser::oC_RightArrowHead() { OC_RightArrowHeadContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 344, CypherParser::RuleOC_RightArrowHead); + enterRule(_localctx, 348, CypherParser::RuleOC_RightArrowHead); size_t _la = 0; #if __cplusplus > 201703L @@ -18456,7 +18677,7 @@ CypherParser::OC_RightArrowHeadContext* CypherParser::oC_RightArrowHead() { }); try { enterOuterAlt(_localctx, 1); - setState(2825); + setState(2863); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 32212320256) != 0))) { @@ -18495,7 +18716,7 @@ size_t CypherParser::OC_DashContext::getRuleIndex() const { CypherParser::OC_DashContext* CypherParser::oC_Dash() { OC_DashContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 346, CypherParser::RuleOC_Dash); + enterRule(_localctx, 350, CypherParser::RuleOC_Dash); size_t _la = 0; #if __cplusplus > 201703L @@ -18507,7 +18728,7 @@ CypherParser::OC_DashContext* CypherParser::oC_Dash() { }); try { enterOuterAlt(_localctx, 1); - setState(2827); + setState(2865); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 70334384439296) != 0) || _la == CypherParser::MINUS)) { @@ -18530,8 +18751,8 @@ CypherParser::OC_DashContext* CypherParser::oC_Dash() { bool CypherParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { switch (ruleIndex) { - case 50: return kU_DataTypeSempred(antlrcpp::downCast(context), predicateIndex); - case 78: return kU_JoinNodeSempred(antlrcpp::downCast(context), predicateIndex); + case 51: return kU_DataTypeSempred(antlrcpp::downCast(context), predicateIndex); + case 79: return kU_JoinNodeSempred(antlrcpp::downCast(context), predicateIndex); default: break; diff --git a/third_party/antlr4_cypher/include/cypher_lexer.h b/third_party/antlr4_cypher/include/cypher_lexer.h index 907393eb131..4c3277d1737 100644 --- a/third_party/antlr4_cypher/include/cypher_lexer.h +++ b/third_party/antlr4_cypher/include/cypher_lexer.h @@ -25,25 +25,25 @@ class CypherLexer : public antlr4::Lexer { COMMIT_SKIP_CHECKPOINT = 64, CONTAINS = 65, COPY = 66, COUNT = 67, CREATE = 68, CYCLE = 69, DATABASE = 70, DBTYPE = 71, DEFAULT = 72, DELETE = 73, DESC = 74, DESCENDING = 75, DETACH = 76, DISTINCT = 77, DROP = 78, ELSE = 79, END = 80, - ENDS = 81, EXISTS = 82, EXPLAIN = 83, EXPORT = 84, EXTENSION = 85, FALSE = 86, - FROM = 87, GLOB = 88, GRAPH = 89, GROUP = 90, HEADERS = 91, HINT = 92, - IMPORT = 93, IF = 94, IN = 95, INCREMENT = 96, INSTALL = 97, IS = 98, - JOIN = 99, KEY = 100, LIMIT = 101, LOAD = 102, MACRO = 103, MATCH = 104, - MAXVALUE = 105, MERGE = 106, MINVALUE = 107, MULTI_JOIN = 108, NO = 109, - NODE = 110, NOT = 111, NONE = 112, NULL_ = 113, ON = 114, ONLY = 115, - OPTIONAL = 116, OR = 117, ORDER = 118, PRIMARY = 119, PROFILE = 120, - PROJECT = 121, RDFGRAPH = 122, READ = 123, REL = 124, RENAME = 125, - RETURN = 126, ROLLBACK = 127, ROLLBACK_SKIP_CHECKPOINT = 128, SEQUENCE = 129, - SET = 130, SHORTEST = 131, START = 132, STARTS = 133, TABLE = 134, THEN = 135, - TO = 136, TRANSACTION = 137, TRUE = 138, TYPE = 139, UNION = 140, UNWIND = 141, - USE = 142, WHEN = 143, WHERE = 144, WITH = 145, WRITE = 146, XOR = 147, - SINGLE = 148, DECIMAL = 149, STAR = 150, L_SKIP = 151, INVALID_NOT_EQUAL = 152, - MINUS = 153, FACTORIAL = 154, COLON = 155, StringLiteral = 156, EscapedChar = 157, - DecimalInteger = 158, HexLetter = 159, HexDigit = 160, Digit = 161, - NonZeroDigit = 162, NonZeroOctDigit = 163, ZeroDigit = 164, RegularDecimalReal = 165, - UnescapedSymbolicName = 166, IdentifierStart = 167, IdentifierPart = 168, - EscapedSymbolicName = 169, SP = 170, WHITESPACE = 171, CypherComment = 172, - Unknown = 173 + ENDS = 81, EXISTS = 82, EXPLAIN = 83, EXPORT = 84, EXTENSION = 85, EXTERNAL = 86, + FALSE = 87, FROM = 88, GLOB = 89, GRAPH = 90, GROUP = 91, HEADERS = 92, + HINT = 93, IMPORT = 94, IF = 95, IN = 96, INCREMENT = 97, INSTALL = 98, + IS = 99, JOIN = 100, KEY = 101, LIMIT = 102, LOAD = 103, MACRO = 104, + MATCH = 105, MAXVALUE = 106, MERGE = 107, MINVALUE = 108, MULTI_JOIN = 109, + NO = 110, NODE = 111, NOT = 112, NONE = 113, NULL_ = 114, ON = 115, + ONLY = 116, OPTIONAL = 117, OR = 118, ORDER = 119, PRIMARY = 120, PROFILE = 121, + PROJECT = 122, RDFGRAPH = 123, READ = 124, REL = 125, RENAME = 126, + RETURN = 127, ROLLBACK = 128, ROLLBACK_SKIP_CHECKPOINT = 129, SEQUENCE = 130, + SET = 131, SHORTEST = 132, START = 133, STARTS = 134, TABLE = 135, THEN = 136, + TO = 137, TRANSACTION = 138, TRUE = 139, TYPE = 140, UNION = 141, UNWIND = 142, + USE = 143, WHEN = 144, WHERE = 145, WITH = 146, WRITE = 147, XOR = 148, + SINGLE = 149, DECIMAL = 150, STAR = 151, L_SKIP = 152, INVALID_NOT_EQUAL = 153, + MINUS = 154, FACTORIAL = 155, COLON = 156, StringLiteral = 157, EscapedChar = 158, + DecimalInteger = 159, HexLetter = 160, HexDigit = 161, Digit = 162, + NonZeroDigit = 163, NonZeroOctDigit = 164, ZeroDigit = 165, RegularDecimalReal = 166, + UnescapedSymbolicName = 167, IdentifierStart = 168, IdentifierPart = 169, + EscapedSymbolicName = 170, SP = 171, WHITESPACE = 172, CypherComment = 173, + Unknown = 174 }; explicit CypherLexer(antlr4::CharStream *input); diff --git a/third_party/antlr4_cypher/include/cypher_parser.h b/third_party/antlr4_cypher/include/cypher_parser.h index d64ea10d261..a2541af53d8 100644 --- a/third_party/antlr4_cypher/include/cypher_parser.h +++ b/third_party/antlr4_cypher/include/cypher_parser.h @@ -25,25 +25,25 @@ class CypherParser : public antlr4::Parser { COMMIT_SKIP_CHECKPOINT = 64, CONTAINS = 65, COPY = 66, COUNT = 67, CREATE = 68, CYCLE = 69, DATABASE = 70, DBTYPE = 71, DEFAULT = 72, DELETE = 73, DESC = 74, DESCENDING = 75, DETACH = 76, DISTINCT = 77, DROP = 78, ELSE = 79, END = 80, - ENDS = 81, EXISTS = 82, EXPLAIN = 83, EXPORT = 84, EXTENSION = 85, FALSE = 86, - FROM = 87, GLOB = 88, GRAPH = 89, GROUP = 90, HEADERS = 91, HINT = 92, - IMPORT = 93, IF = 94, IN = 95, INCREMENT = 96, INSTALL = 97, IS = 98, - JOIN = 99, KEY = 100, LIMIT = 101, LOAD = 102, MACRO = 103, MATCH = 104, - MAXVALUE = 105, MERGE = 106, MINVALUE = 107, MULTI_JOIN = 108, NO = 109, - NODE = 110, NOT = 111, NONE = 112, NULL_ = 113, ON = 114, ONLY = 115, - OPTIONAL = 116, OR = 117, ORDER = 118, PRIMARY = 119, PROFILE = 120, - PROJECT = 121, RDFGRAPH = 122, READ = 123, REL = 124, RENAME = 125, - RETURN = 126, ROLLBACK = 127, ROLLBACK_SKIP_CHECKPOINT = 128, SEQUENCE = 129, - SET = 130, SHORTEST = 131, START = 132, STARTS = 133, TABLE = 134, THEN = 135, - TO = 136, TRANSACTION = 137, TRUE = 138, TYPE = 139, UNION = 140, UNWIND = 141, - USE = 142, WHEN = 143, WHERE = 144, WITH = 145, WRITE = 146, XOR = 147, - SINGLE = 148, DECIMAL = 149, STAR = 150, L_SKIP = 151, INVALID_NOT_EQUAL = 152, - MINUS = 153, FACTORIAL = 154, COLON = 155, StringLiteral = 156, EscapedChar = 157, - DecimalInteger = 158, HexLetter = 159, HexDigit = 160, Digit = 161, - NonZeroDigit = 162, NonZeroOctDigit = 163, ZeroDigit = 164, RegularDecimalReal = 165, - UnescapedSymbolicName = 166, IdentifierStart = 167, IdentifierPart = 168, - EscapedSymbolicName = 169, SP = 170, WHITESPACE = 171, CypherComment = 172, - Unknown = 173 + ENDS = 81, EXISTS = 82, EXPLAIN = 83, EXPORT = 84, EXTENSION = 85, EXTERNAL = 86, + FALSE = 87, FROM = 88, GLOB = 89, GRAPH = 90, GROUP = 91, HEADERS = 92, + HINT = 93, IMPORT = 94, IF = 95, IN = 96, INCREMENT = 97, INSTALL = 98, + IS = 99, JOIN = 100, KEY = 101, LIMIT = 102, LOAD = 103, MACRO = 104, + MATCH = 105, MAXVALUE = 106, MERGE = 107, MINVALUE = 108, MULTI_JOIN = 109, + NO = 110, NODE = 111, NOT = 112, NONE = 113, NULL_ = 114, ON = 115, + ONLY = 116, OPTIONAL = 117, OR = 118, ORDER = 119, PRIMARY = 120, PROFILE = 121, + PROJECT = 122, RDFGRAPH = 123, READ = 124, REL = 125, RENAME = 126, + RETURN = 127, ROLLBACK = 128, ROLLBACK_SKIP_CHECKPOINT = 129, SEQUENCE = 130, + SET = 131, SHORTEST = 132, START = 133, STARTS = 134, TABLE = 135, THEN = 136, + TO = 137, TRANSACTION = 138, TRUE = 139, TYPE = 140, UNION = 141, UNWIND = 142, + USE = 143, WHEN = 144, WHERE = 145, WITH = 146, WRITE = 147, XOR = 148, + SINGLE = 149, DECIMAL = 150, STAR = 151, L_SKIP = 152, INVALID_NOT_EQUAL = 153, + MINUS = 154, FACTORIAL = 155, COLON = 156, StringLiteral = 157, EscapedChar = 158, + DecimalInteger = 159, HexLetter = 160, HexDigit = 161, Digit = 162, + NonZeroDigit = 163, NonZeroOctDigit = 164, ZeroDigit = 165, RegularDecimalReal = 166, + UnescapedSymbolicName = 167, IdentifierStart = 168, IdentifierPart = 169, + EscapedSymbolicName = 170, SP = 171, WHITESPACE = 172, CypherComment = 173, + Unknown = 174 }; enum { @@ -54,59 +54,60 @@ class CypherParser : public antlr4::Parser { RuleKU_DetachDatabase = 13, RuleKU_UseDatabase = 14, RuleKU_StandaloneCall = 15, RuleKU_CommentOn = 16, RuleKU_CreateMacro = 17, RuleKU_PositionalArgs = 18, RuleKU_DefaultArg = 19, RuleKU_FilePaths = 20, RuleKU_ParsingOptions = 21, - RuleKU_IfNotExists = 22, RuleKU_CreateNodeTable = 23, RuleKU_CreateRelTable = 24, - RuleKU_CreateRelTableGroup = 25, RuleKU_RelTableConnection = 26, RuleKU_CreateRdfGraph = 27, - RuleKU_CreateSequence = 28, RuleKU_CreateType = 29, RuleKU_SequenceOptions = 30, - RuleKU_IncrementBy = 31, RuleKU_MinValue = 32, RuleKU_MaxValue = 33, - RuleKU_StartWith = 34, RuleKU_Cycle = 35, RuleKU_IfExists = 36, RuleKU_Drop = 37, - RuleKU_AlterTable = 38, RuleKU_AlterOptions = 39, RuleKU_AddProperty = 40, - RuleKU_Default = 41, RuleKU_DropProperty = 42, RuleKU_RenameTable = 43, - RuleKU_RenameProperty = 44, RuleKU_ColumnDefinitions = 45, RuleKU_ColumnDefinition = 46, - RuleKU_PropertyDefinitions = 47, RuleKU_PropertyDefinition = 48, RuleKU_CreateNodeConstraint = 49, - RuleKU_DataType = 50, RuleKU_ListIdentifiers = 51, RuleKU_ListIdentifier = 52, - RuleOC_AnyCypherOption = 53, RuleOC_Explain = 54, RuleOC_Profile = 55, - RuleKU_Transaction = 56, RuleKU_Extension = 57, RuleKU_LoadExtension = 58, - RuleKU_InstallExtension = 59, RuleOC_Query = 60, RuleKU_ProjectGraph = 61, - RuleKU_GraphProjectionTableItems = 62, RuleOC_RegularQuery = 63, RuleOC_Union = 64, - RuleOC_SingleQuery = 65, RuleOC_SinglePartQuery = 66, RuleOC_MultiPartQuery = 67, - RuleKU_QueryPart = 68, RuleOC_UpdatingClause = 69, RuleOC_ReadingClause = 70, - RuleKU_LoadFrom = 71, RuleKU_InQueryCall = 72, RuleKU_GraphProjectionTableItem = 73, - RuleKU_GraphProjectionColumnItems = 74, RuleKU_GraphProjectionColumnItem = 75, - RuleOC_Match = 76, RuleKU_Hint = 77, RuleKU_JoinNode = 78, RuleOC_Unwind = 79, - RuleOC_Create = 80, RuleOC_Merge = 81, RuleOC_MergeAction = 82, RuleOC_Set = 83, - RuleOC_SetItem = 84, RuleOC_Delete = 85, RuleOC_With = 86, RuleOC_Return = 87, - RuleOC_ProjectionBody = 88, RuleOC_ProjectionItems = 89, RuleOC_ProjectionItem = 90, - RuleOC_Order = 91, RuleOC_Skip = 92, RuleOC_Limit = 93, RuleOC_SortItem = 94, - RuleOC_Where = 95, RuleOC_Pattern = 96, RuleOC_PatternPart = 97, RuleOC_AnonymousPatternPart = 98, - RuleOC_PatternElement = 99, RuleOC_NodePattern = 100, RuleOC_PatternElementChain = 101, - RuleOC_RelationshipPattern = 102, RuleOC_RelationshipDetail = 103, RuleKU_Properties = 104, - RuleOC_RelationshipTypes = 105, RuleOC_NodeLabels = 106, RuleOC_NodeLabel = 107, - RuleOC_RangeLiteral = 108, RuleKU_RecursiveRelationshipComprehension = 109, - RuleKU_IntermediateNodeProjectionItems = 110, RuleKU_IntermediateRelProjectionItems = 111, - RuleOC_LowerBound = 112, RuleOC_UpperBound = 113, RuleOC_LabelName = 114, - RuleOC_RelTypeName = 115, RuleOC_Expression = 116, RuleOC_OrExpression = 117, - RuleOC_XorExpression = 118, RuleOC_AndExpression = 119, RuleOC_NotExpression = 120, - RuleOC_ComparisonExpression = 121, RuleKU_ComparisonOperator = 122, - RuleKU_BitwiseOrOperatorExpression = 123, RuleKU_BitwiseAndOperatorExpression = 124, - RuleKU_BitShiftOperatorExpression = 125, RuleKU_BitShiftOperator = 126, - RuleOC_AddOrSubtractExpression = 127, RuleKU_AddOrSubtractOperator = 128, - RuleOC_MultiplyDivideModuloExpression = 129, RuleKU_MultiplyDivideModuloOperator = 130, - RuleOC_PowerOfExpression = 131, RuleOC_UnaryAddSubtractOrFactorialExpression = 132, - RuleOC_StringListNullOperatorExpression = 133, RuleOC_ListOperatorExpression = 134, - RuleOC_StringOperatorExpression = 135, RuleOC_RegularExpression = 136, - RuleOC_NullOperatorExpression = 137, RuleOC_PropertyOrLabelsExpression = 138, - RuleOC_Atom = 139, RuleOC_Quantifier = 140, RuleOC_FilterExpression = 141, - RuleOC_IdInColl = 142, RuleOC_Literal = 143, RuleOC_BooleanLiteral = 144, - RuleOC_ListLiteral = 145, RuleKU_ListEntry = 146, RuleKU_StructLiteral = 147, - RuleKU_StructField = 148, RuleOC_ParenthesizedExpression = 149, RuleOC_FunctionInvocation = 150, - RuleOC_FunctionName = 151, RuleKU_FunctionParameter = 152, RuleKU_LambdaParameter = 153, - RuleKU_LambdaVars = 154, RuleOC_PathPatterns = 155, RuleOC_ExistSubquery = 156, - RuleKU_CountSubquery = 157, RuleOC_PropertyLookup = 158, RuleOC_CaseExpression = 159, - RuleOC_CaseAlternative = 160, RuleOC_Variable = 161, RuleOC_NumberLiteral = 162, - RuleOC_Parameter = 163, RuleOC_PropertyExpression = 164, RuleOC_PropertyKeyName = 165, - RuleOC_IntegerLiteral = 166, RuleOC_DoubleLiteral = 167, RuleOC_SchemaName = 168, - RuleOC_SymbolicName = 169, RuleKU_NonReservedKeywords = 170, RuleOC_LeftArrowHead = 171, - RuleOC_RightArrowHead = 172, RuleOC_Dash = 173 + RuleKU_IfNotExists = 22, RuleKU_CreateNodeTable = 23, RuleKU_CreateExternalNodeTable = 24, + RuleKU_CreateRelTable = 25, RuleKU_CreateRelTableGroup = 26, RuleKU_RelTableConnection = 27, + RuleKU_CreateRdfGraph = 28, RuleKU_CreateSequence = 29, RuleKU_CreateType = 30, + RuleKU_SequenceOptions = 31, RuleKU_IncrementBy = 32, RuleKU_MinValue = 33, + RuleKU_MaxValue = 34, RuleKU_StartWith = 35, RuleKU_Cycle = 36, RuleKU_IfExists = 37, + RuleKU_Drop = 38, RuleKU_AlterTable = 39, RuleKU_AlterOptions = 40, + RuleKU_AddProperty = 41, RuleKU_Default = 42, RuleKU_DropProperty = 43, + RuleKU_RenameTable = 44, RuleKU_RenameProperty = 45, RuleKU_ColumnDefinitions = 46, + RuleKU_ColumnDefinition = 47, RuleKU_PropertyDefinitions = 48, RuleKU_PropertyDefinition = 49, + RuleKU_PrimaryKey = 50, RuleKU_DataType = 51, RuleKU_ListIdentifiers = 52, + RuleKU_ListIdentifier = 53, RuleOC_AnyCypherOption = 54, RuleOC_Explain = 55, + RuleOC_Profile = 56, RuleKU_Transaction = 57, RuleKU_Extension = 58, + RuleKU_LoadExtension = 59, RuleKU_InstallExtension = 60, RuleOC_Query = 61, + RuleKU_ProjectGraph = 62, RuleKU_GraphProjectionTableItems = 63, RuleOC_RegularQuery = 64, + RuleOC_Union = 65, RuleOC_SingleQuery = 66, RuleOC_SinglePartQuery = 67, + RuleOC_MultiPartQuery = 68, RuleKU_QueryPart = 69, RuleOC_UpdatingClause = 70, + RuleOC_ReadingClause = 71, RuleKU_LoadFrom = 72, RuleKU_InQueryCall = 73, + RuleKU_GraphProjectionTableItem = 74, RuleKU_GraphProjectionColumnItems = 75, + RuleKU_GraphProjectionColumnItem = 76, RuleOC_Match = 77, RuleKU_Hint = 78, + RuleKU_JoinNode = 79, RuleOC_Unwind = 80, RuleOC_Create = 81, RuleOC_Merge = 82, + RuleOC_MergeAction = 83, RuleOC_Set = 84, RuleOC_SetItem = 85, RuleOC_Delete = 86, + RuleOC_With = 87, RuleOC_Return = 88, RuleOC_ProjectionBody = 89, RuleOC_ProjectionItems = 90, + RuleOC_ProjectionItem = 91, RuleOC_Order = 92, RuleOC_Skip = 93, RuleOC_Limit = 94, + RuleOC_SortItem = 95, RuleOC_Where = 96, RuleOC_Pattern = 97, RuleOC_PatternPart = 98, + RuleOC_AnonymousPatternPart = 99, RuleOC_PatternElement = 100, RuleOC_NodePattern = 101, + RuleOC_PatternElementChain = 102, RuleOC_RelationshipPattern = 103, + RuleOC_RelationshipDetail = 104, RuleKU_Properties = 105, RuleOC_RelationshipTypes = 106, + RuleOC_NodeLabels = 107, RuleOC_NodeLabel = 108, RuleOC_RangeLiteral = 109, + RuleKU_RecursiveRelationshipComprehension = 110, RuleKU_IntermediateNodeProjectionItems = 111, + RuleKU_IntermediateRelProjectionItems = 112, RuleOC_LowerBound = 113, + RuleOC_UpperBound = 114, RuleOC_LabelName = 115, RuleOC_RelTypeName = 116, + RuleOC_Expression = 117, RuleOC_OrExpression = 118, RuleOC_XorExpression = 119, + RuleOC_AndExpression = 120, RuleOC_NotExpression = 121, RuleOC_ComparisonExpression = 122, + RuleKU_ComparisonOperator = 123, RuleKU_BitwiseOrOperatorExpression = 124, + RuleKU_BitwiseAndOperatorExpression = 125, RuleKU_BitShiftOperatorExpression = 126, + RuleKU_BitShiftOperator = 127, RuleOC_AddOrSubtractExpression = 128, + RuleKU_AddOrSubtractOperator = 129, RuleOC_MultiplyDivideModuloExpression = 130, + RuleKU_MultiplyDivideModuloOperator = 131, RuleOC_PowerOfExpression = 132, + RuleOC_UnaryAddSubtractOrFactorialExpression = 133, RuleOC_StringListNullOperatorExpression = 134, + RuleOC_ListOperatorExpression = 135, RuleOC_StringOperatorExpression = 136, + RuleOC_RegularExpression = 137, RuleOC_NullOperatorExpression = 138, + RuleOC_PropertyOrLabelsExpression = 139, RuleOC_Atom = 140, RuleOC_Quantifier = 141, + RuleOC_FilterExpression = 142, RuleOC_IdInColl = 143, RuleOC_Literal = 144, + RuleOC_BooleanLiteral = 145, RuleOC_ListLiteral = 146, RuleKU_ListEntry = 147, + RuleKU_StructLiteral = 148, RuleKU_StructField = 149, RuleOC_ParenthesizedExpression = 150, + RuleOC_FunctionInvocation = 151, RuleOC_FunctionName = 152, RuleKU_FunctionParameter = 153, + RuleKU_LambdaParameter = 154, RuleKU_LambdaVars = 155, RuleOC_PathPatterns = 156, + RuleOC_ExistSubquery = 157, RuleKU_CountSubquery = 158, RuleOC_PropertyLookup = 159, + RuleKU_TableLookup = 160, RuleOC_CaseExpression = 161, RuleOC_CaseAlternative = 162, + RuleOC_Variable = 163, RuleOC_NumberLiteral = 164, RuleOC_Parameter = 165, + RuleOC_PropertyExpression = 166, RuleOC_PropertyKeyName = 167, RuleOC_IntegerLiteral = 168, + RuleOC_DoubleLiteral = 169, RuleOC_SchemaName = 170, RuleOC_SymbolicName = 171, + RuleKU_NonReservedKeywords = 172, RuleOC_LeftArrowHead = 173, RuleOC_RightArrowHead = 174, + RuleOC_Dash = 175 }; explicit CypherParser(antlr4::TokenStream *input); @@ -150,6 +151,7 @@ class CypherParser : public antlr4::Parser { class KU_ParsingOptionsContext; class KU_IfNotExistsContext; class KU_CreateNodeTableContext; + class KU_CreateExternalNodeTableContext; class KU_CreateRelTableContext; class KU_CreateRelTableGroupContext; class KU_RelTableConnectionContext; @@ -175,7 +177,7 @@ class CypherParser : public antlr4::Parser { class KU_ColumnDefinitionContext; class KU_PropertyDefinitionsContext; class KU_PropertyDefinitionContext; - class KU_CreateNodeConstraintContext; + class KU_PrimaryKeyContext; class KU_DataTypeContext; class KU_ListIdentifiersContext; class KU_ListIdentifierContext; @@ -285,6 +287,7 @@ class CypherParser : public antlr4::Parser { class OC_ExistSubqueryContext; class KU_CountSubqueryContext; class OC_PropertyLookupContext; + class KU_TableLookupContext; class OC_CaseExpressionContext; class OC_CaseAlternativeContext; class OC_VariableContext; @@ -336,6 +339,7 @@ class CypherParser : public antlr4::Parser { virtual size_t getRuleIndex() const override; OC_QueryContext *oC_Query(); KU_CreateNodeTableContext *kU_CreateNodeTable(); + KU_CreateExternalNodeTableContext *kU_CreateExternalNodeTable(); KU_CreateRelTableContext *kU_CreateRelTable(); KU_CreateRelTableGroupContext *kU_CreateRelTableGroup(); KU_CreateRdfGraphContext *kU_CreateRdfGraph(); @@ -686,7 +690,7 @@ class CypherParser : public antlr4::Parser { antlr4::tree::TerminalNode *TABLE(); OC_SchemaNameContext *oC_SchemaName(); KU_PropertyDefinitionsContext *kU_PropertyDefinitions(); - KU_CreateNodeConstraintContext *kU_CreateNodeConstraint(); + KU_PrimaryKeyContext *kU_PrimaryKey(); KU_IfNotExistsContext *kU_IfNotExists(); @@ -694,6 +698,27 @@ class CypherParser : public antlr4::Parser { KU_CreateNodeTableContext* kU_CreateNodeTable(); + class KU_CreateExternalNodeTableContext : public antlr4::ParserRuleContext { + public: + KU_CreateExternalNodeTableContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + antlr4::tree::TerminalNode *CREATE(); + std::vector SP(); + antlr4::tree::TerminalNode* SP(size_t i); + antlr4::tree::TerminalNode *EXTERNAL(); + antlr4::tree::TerminalNode *NODE(); + antlr4::tree::TerminalNode *TABLE(); + std::vector oC_SchemaName(); + OC_SchemaNameContext* oC_SchemaName(size_t i); + antlr4::tree::TerminalNode *AS(); + KU_TableLookupContext *kU_TableLookup(); + KU_PrimaryKeyContext *kU_PrimaryKey(); + + + }; + + KU_CreateExternalNodeTableContext* kU_CreateExternalNodeTable(); + class KU_CreateRelTableContext : public antlr4::ParserRuleContext { public: KU_CreateRelTableContext(antlr4::ParserRuleContext *parent, size_t invokingState); @@ -1081,9 +1106,9 @@ class CypherParser : public antlr4::Parser { KU_PropertyDefinitionContext* kU_PropertyDefinition(); - class KU_CreateNodeConstraintContext : public antlr4::ParserRuleContext { + class KU_PrimaryKeyContext : public antlr4::ParserRuleContext { public: - KU_CreateNodeConstraintContext(antlr4::ParserRuleContext *parent, size_t invokingState); + KU_PrimaryKeyContext(antlr4::ParserRuleContext *parent, size_t invokingState); virtual size_t getRuleIndex() const override; antlr4::tree::TerminalNode *PRIMARY(); std::vector SP(); @@ -1094,7 +1119,7 @@ class CypherParser : public antlr4::Parser { }; - KU_CreateNodeConstraintContext* kU_CreateNodeConstraint(); + KU_PrimaryKeyContext* kU_PrimaryKey(); class KU_DataTypeContext : public antlr4::ParserRuleContext { public: @@ -2690,6 +2715,18 @@ class CypherParser : public antlr4::Parser { OC_PropertyLookupContext* oC_PropertyLookup(); + class KU_TableLookupContext : public antlr4::ParserRuleContext { + public: + KU_TableLookupContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + OC_SchemaNameContext *oC_SchemaName(); + antlr4::tree::TerminalNode *SP(); + + + }; + + KU_TableLookupContext* kU_TableLookup(); + class OC_CaseExpressionContext : public antlr4::ParserRuleContext { public: OC_CaseExpressionContext(antlr4::ParserRuleContext *parent, size_t invokingState); diff --git a/tools/shell/include/keywords.h b/tools/shell/include/keywords.h index 7b23a61cfd5..10ae45fbfda 100644 --- a/tools/shell/include/keywords.h +++ b/tools/shell/include/keywords.h @@ -1,6 +1,6 @@ #ifndef _keywordList // clang-format off -#define _keywordList {"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", "GLOB", "GRAPH", "GROUP", "HEADERS", "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN", "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", "MINVALUE", "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", "ONLY", "OPTIONAL", "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", "RDFGRAPH", "READ", "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", "SEQUENCE", "SET", "SHORTEST", "START", "STARTS", "TABLE", "THEN", "TO", "TRANSACTION", "TRUE", "TYPE", "UNION", "UNWIND", "USE", "WHEN", "WHERE", "WITH", "WRITE", "XOR", "SINGLE"} -#define _keywordListLength 103 +#define _keywordList {"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", "EXTERNAL", "FALSE", "FROM", "GLOB", "GRAPH", "GROUP", "HEADERS", "HINT", "IMPORT", "IF", "IN", "INCREMENT", "INSTALL", "IS", "JOIN", "KEY", "LIMIT", "LOAD", "MACRO", "MATCH", "MAXVALUE", "MERGE", "MINVALUE", "MULTI_JOIN", "NO", "NODE", "NOT", "NONE", "NULL", "ON", "ONLY", "OPTIONAL", "OR", "ORDER", "PRIMARY", "PROFILE", "PROJECT", "RDFGRAPH", "READ", "REL", "RENAME", "RETURN", "ROLLBACK", "ROLLBACK_SKIP_CHECKPOINT", "SEQUENCE", "SET", "SHORTEST", "START", "STARTS", "TABLE", "THEN", "TO", "TRANSACTION", "TRUE", "TYPE", "UNION", "UNWIND", "USE", "WHEN", "WHERE", "WITH", "WRITE", "XOR", "SINGLE"} +#define _keywordListLength 104 // clang-format on #endif