From 4fa1c3bc2ee49093092d85362476c8871dfdd9f7 Mon Sep 17 00:00:00 2001 From: xiyang Date: Mon, 13 Nov 2023 00:57:16 +0800 Subject: [PATCH] Add partial column copy --- src/antlr4/Cypher.g4 | 5 +- src/binder/bind/bind_copy.cpp | 159 +- src/binder/bind/bind_reading_clause.cpp | 8 +- src/binder/bind/copy/bind_copy_rdf_graph.cpp | 56 +- src/binder/binder.cpp | 2 +- src/catalog/table_schema.cpp | 22 + src/include/binder/binder.h | 30 +- src/include/binder/copy/bound_copy_from.h | 10 +- .../binder/copy/bound_file_scan_info.h | 21 +- .../binder/expression/variable_expression.h | 2 + src/include/catalog/property.h | 7 - src/include/catalog/rel_table_schema.h | 5 - src/include/catalog/table_schema.h | 21 +- src/include/common/constants.h | 4 + src/include/common/types/types.h | 2 + src/include/parser/copy.h | 24 +- src/include/parser/transformer.h | 1 + .../planner/operator/logical_partitioner.h | 11 +- src/include/processor/data_pos.h | 5 + src/include/processor/operator/partitioner.h | 17 +- .../processor/operator/persistent/copy_node.h | 1 + .../processor/operator/persistent/copy_rel.h | 14 +- src/include/processor/plan_mapper.h | 5 + src/parser/transform/transform_copy.cpp | 32 +- .../operator/scan/logical_scan_file.cpp | 4 +- src/planner/plan/plan_copy.cpp | 40 +- src/processor/map/CMakeLists.txt | 1 - src/processor/map/map_copy_from.cpp | 130 +- src/processor/map/map_partitioner.cpp | 30 - src/processor/map/map_scan_file.cpp | 4 +- src/processor/operator/partitioner.cpp | 27 +- .../operator/persistent/copy_node.cpp | 21 +- src/storage/store/string_column.cpp | 1 + src/storage/store/string_column_chunk.cpp | 2 + test/test_files/copy/copy_partial_column.test | 210 + third_party/antlr4_cypher/cypher_parser.cpp | 4942 +++++++++-------- .../antlr4_cypher/include/cypher_parser.h | 111 +- 37 files changed, 3230 insertions(+), 2757 deletions(-) delete mode 100644 src/processor/map/map_partitioner.cpp create mode 100644 test/test_files/copy/copy_partial_column.test diff --git a/src/antlr4/Cypher.g4 b/src/antlr4/Cypher.g4 index 5029c66134..a319515326 100644 --- a/src/antlr4/Cypher.g4 +++ b/src/antlr4/Cypher.g4 @@ -28,7 +28,10 @@ oC_Statement | kU_Transaction ; kU_CopyFrom - : COPY SP oC_SchemaName SP FROM SP kU_FilePaths ( SP? '(' SP? kU_ParsingOptions SP? ')' )? ; + : COPY SP oC_SchemaName ( ( SP? '(' SP? kU_ColumnNames SP? ')' SP? ) | SP ) FROM SP kU_FilePaths ( SP? '(' SP? kU_ParsingOptions SP? ')' )? ; + +kU_ColumnNames + : oC_SchemaName ( SP? ',' SP? oC_SchemaName )* ; kU_CopyFromByColumn : COPY SP oC_SchemaName SP FROM SP '(' SP? StringLiteral ( SP? ',' SP? StringLiteral )* ')' SP BY SP COLUMN ; diff --git a/src/binder/bind/bind_copy.cpp b/src/binder/bind/bind_copy.cpp index c02513bb6e..9f80076448 100644 --- a/src/binder/bind/bind_copy.cpp +++ b/src/binder/bind/bind_copy.cpp @@ -7,7 +7,6 @@ #include "common/exception/binder.h" #include "common/exception/message.h" #include "common/string_format.h" -#include "function/table_functions.h" #include "function/table_functions/bind_input.h" #include "parser/copy.h" @@ -19,8 +18,6 @@ using namespace kuzu::parser; namespace kuzu { namespace binder { -static constexpr uint64_t NUM_COLUMNS_TO_SKIP_IN_REL_FILE = 2; - std::unique_ptr Binder::bindCopyToClause(const Statement& statement) { auto& copyToStatement = reinterpret_cast(statement); auto boundFilePath = copyToStatement.getFilePath(); @@ -63,19 +60,8 @@ static void validateCopyNpyNotForRelTables(TableSchema* schema) { } } -static bool bindContainsSerial(TableSchema* tableSchema) { - bool containsSerial = false; - for (auto& property : tableSchema->properties) { - if (property->getDataType()->getLogicalTypeID() == LogicalTypeID::SERIAL) { - containsSerial = true; - break; - } - } - return containsSerial; -} - std::unique_ptr Binder::bindCopyFromClause(const Statement& statement) { - auto& copyStatement = (CopyFrom&)statement; + auto& copyStatement = reinterpret_cast(statement); auto catalogContent = catalog.getReadOnlyVersion(); auto tableName = copyStatement.getTableName(); validateTableExist(tableName); @@ -96,7 +82,6 @@ std::unique_ptr Binder::bindCopyFromClause(const Statement& stat auto fileType = bindFileType(filePaths); auto readerConfig = std::make_unique(fileType, std::move(filePaths), std::move(csvReaderConfig)); - auto scanFunction = getScanFunction(fileType, readerConfig->csvReaderConfig->parallel); validateByColumnKeyword(readerConfig->fileType, copyStatement.byColumn()); if (readerConfig->fileType == FileType::NPY) { validateCopyNpyNotForRelTables(tableSchema); @@ -104,15 +89,15 @@ std::unique_ptr Binder::bindCopyFromClause(const Statement& stat switch (tableSchema->tableType) { case TableType::NODE: if (readerConfig->fileType == FileType::TURTLE) { - return bindCopyRdfNodeFrom(scanFunction, std::move(readerConfig), tableSchema); + return bindCopyRdfNodeFrom(statement, std::move(readerConfig), tableSchema); } else { - return bindCopyNodeFrom(scanFunction, std::move(readerConfig), tableSchema); + return bindCopyNodeFrom(statement, std::move(readerConfig), tableSchema); } case TableType::REL: { if (readerConfig->fileType == FileType::TURTLE) { - return bindCopyRdfRelFrom(scanFunction, std::move(readerConfig), tableSchema); + return bindCopyRdfRelFrom(statement, std::move(readerConfig), tableSchema); } else { - return bindCopyRelFrom(scanFunction, std::move(readerConfig), tableSchema); + return bindCopyRelFrom(statement, std::move(readerConfig), tableSchema); } } // LCOV_EXCL_START @@ -123,50 +108,54 @@ std::unique_ptr Binder::bindCopyFromClause(const Statement& stat } } -std::unique_ptr Binder::bindCopyNodeFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, TableSchema* tableSchema) { +std::unique_ptr Binder::bindCopyNodeFrom(const Statement& statement, + std::unique_ptr config, TableSchema* tableSchema) { + auto& copyStatement = reinterpret_cast(statement); + auto func = getScanFunction(config->fileType, config->csvReaderConfig->parallel); // For table with SERIAL columns, we need to read in serial from files. - auto containsSerial = bindContainsSerial(tableSchema); + auto containsSerial = tableSchema->containsColumnType(LogicalType(LogicalTypeID::SERIAL)); std::vector expectedColumnNames; std::vector> expectedColumnTypes; - bindExpectedNodeColumns(tableSchema, expectedColumnNames, expectedColumnTypes); - auto bindInput = std::make_unique(memoryManager, - *readerConfig, std::move(expectedColumnNames), std::move(expectedColumnTypes)); - auto bindData = - copyFunc->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); + bindExpectedNodeColumns( + tableSchema, copyStatement.getColumnNames(), expectedColumnNames, expectedColumnTypes); + auto bindInput = std::make_unique( + memoryManager, *config, std::move(expectedColumnNames), std::move(expectedColumnTypes)); + auto bindData = func->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); expression_vector columns; for (auto i = 0u; i < bindData->columnTypes.size(); i++) { columns.push_back(createVariable(bindData->columnNames[i], *bindData->columnTypes[i])); } auto offset = expressionBinder.createVariableExpression( - LogicalType(LogicalTypeID::INT64), common::InternalKeyword::ANONYMOUS); - auto boundFileScanInfo = std::make_unique( - copyFunc, std::move(bindData), columns, std::move(offset), TableType::NODE); - auto boundCopyFromInfo = std::make_unique(tableSchema, - std::move(boundFileScanInfo), containsSerial, std::move(columns), nullptr /* extraInfo */); + LogicalType(LogicalTypeID::INT64), InternalKeyword::ANONYMOUS); + auto boundFileScanInfo = + std::make_unique(func, std::move(bindData), columns, std::move(offset)); + auto boundCopyFromInfo = std::make_unique( + tableSchema, std::move(boundFileScanInfo), containsSerial, nullptr /* extraInfo */); return std::make_unique(std::move(boundCopyFromInfo)); } -std::unique_ptr Binder::bindCopyRelFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, TableSchema* tableSchema) { +std::unique_ptr Binder::bindCopyRelFrom(const parser::Statement& statement, + std::unique_ptr config, TableSchema* tableSchema) { + auto& copyStatement = reinterpret_cast(statement); + auto func = getScanFunction(config->fileType, config->csvReaderConfig->parallel); // For table with SERIAL columns, we need to read in serial from files. - auto containsSerial = bindContainsSerial(tableSchema); + auto containsSerial = tableSchema->containsColumnType(LogicalType(LogicalTypeID::SERIAL)); KU_ASSERT(containsSerial == false); std::vector expectedColumnNames; std::vector> expectedColumnTypes; - bindExpectedRelColumns(tableSchema, expectedColumnNames, expectedColumnTypes); + bindExpectedRelColumns( + tableSchema, copyStatement.getColumnNames(), expectedColumnNames, expectedColumnTypes); auto bindInput = std::make_unique(memoryManager, - std::move(*readerConfig), std::move(expectedColumnNames), std::move(expectedColumnTypes)); - auto bindData = - copyFunc->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); + std::move(*config), std::move(expectedColumnNames), std::move(expectedColumnTypes)); + auto bindData = func->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); expression_vector columns; for (auto i = 0u; i < bindData->columnTypes.size(); i++) { columns.push_back(createVariable(bindData->columnNames[i], *bindData->columnTypes[i])); } auto offset = expressionBinder.createVariableExpression( - LogicalType(LogicalTypeID::INT64), common::InternalKeyword::ANONYMOUS); - auto boundFileScanInfo = std::make_unique( - copyFunc, std::move(bindData), columns, offset, TableType::REL); + LogicalType(LogicalTypeID::INT64), std::string(InternalKeyword::ROW_OFFSET)); + auto boundFileScanInfo = + std::make_unique(func, std::move(bindData), columns, offset); auto relTableSchema = reinterpret_cast(tableSchema); auto srcTableSchema = catalog.getReadOnlyVersion()->getTableSchema(relTableSchema->getSrcTableID()); @@ -174,20 +163,12 @@ std::unique_ptr Binder::bindCopyRelFrom(function::TableFunction* catalog.getReadOnlyVersion()->getTableSchema(relTableSchema->getDstTableID()); auto srcKey = columns[0]; auto dstKey = columns[1]; - auto srcNodeID = - createVariable(std::string(Property::REL_BOUND_OFFSET_NAME), LogicalTypeID::INT64); - auto dstNodeID = - createVariable(std::string(Property::REL_NBR_OFFSET_NAME), LogicalTypeID::INT64); + auto srcNodeID = createVariable(std::string(InternalKeyword::SRC_OFFSET), LogicalTypeID::INT64); + auto dstNodeID = createVariable(std::string(InternalKeyword::DST_OFFSET), LogicalTypeID::INT64); auto extraCopyRelInfo = std::make_unique( srcTableSchema, dstTableSchema, srcNodeID, dstNodeID, srcKey, dstKey); - // Skip the first two columns. - expression_vector columnsToCopy{std::move(srcNodeID), std::move(dstNodeID), std::move(offset)}; - for (auto i = NUM_COLUMNS_TO_SKIP_IN_REL_FILE; i < columns.size(); i++) { - columnsToCopy.push_back(columns[i]); - } - auto boundCopyFromInfo = - std::make_unique(tableSchema, std::move(boundFileScanInfo), - containsSerial, std::move(columnsToCopy), std::move(extraCopyRelInfo)); + auto boundCopyFromInfo = std::make_unique( + tableSchema, std::move(boundFileScanInfo), containsSerial, std::move(extraCopyRelInfo)); return std::make_unique(std::move(boundCopyFromInfo)); } @@ -196,30 +177,62 @@ static bool skipPropertyInFile(const Property& property) { TableSchema::isReservedPropertyName(property.getName()); } -void Binder::bindExpectedNodeColumns(catalog::TableSchema* tableSchema, - std::vector& columnNames, - std::vector>& columnTypes) { - for (auto& property : tableSchema->properties) { - if (skipPropertyInFile(*property)) { - continue; +static void bindExpectedColumns(TableSchema* tableSchema, + const std::vector& inputColumnNames, std::vector& columnNames, + logical_types_t& columnTypes) { + if (!inputColumnNames.empty()) { + std::unordered_set inputColumnNamesSet; + for (auto& columName : inputColumnNames) { + if (inputColumnNamesSet.contains(columName)) { + throw BinderException( + stringFormat("Detect duplicate column name {} during COPY.", columName)); + } + inputColumnNamesSet.insert(columName); + } + // Search column data type for each input column. + for (auto& columnName : inputColumnNames) { + if (!tableSchema->containProperty(columnName)) { + throw BinderException(stringFormat( + "Table {} does not contain column {}.", tableSchema->tableName, columnName)); + } + auto propertyID = tableSchema->getPropertyID(columnName); + auto property = tableSchema->getProperty(propertyID); + if (skipPropertyInFile(*property)) { + continue; + } + columnNames.push_back(columnName); + columnTypes.push_back(property->getDataType()->copy()); + } + } else { + // No column specified. Fall back to schema columns. + for (auto& property : tableSchema->properties) { + if (skipPropertyInFile(*property)) { + continue; + } + columnNames.push_back(property->getName()); + columnTypes.push_back(property->getDataType()->copy()); } - columnNames.push_back(property->getName()); - columnTypes.push_back(property->getDataType()->copy()); } } -void Binder::bindExpectedRelColumns(catalog::TableSchema* tableSchema, - std::vector& columnNames, +void Binder::bindExpectedNodeColumns(catalog::TableSchema* tableSchema, + const std::vector& inputColumnNames, std::vector& columnNames, + std::vector>& columnTypes) { + KU_ASSERT(columnNames.empty() && columnTypes.empty()); + bindExpectedColumns(tableSchema, inputColumnNames, columnNames, columnTypes); +} + +void Binder::bindExpectedRelColumns(TableSchema* tableSchema, + const std::vector& inputColumnNames, std::vector& columnNames, std::vector>& columnTypes) { + KU_ASSERT(columnNames.empty() && columnTypes.empty()); auto relTableSchema = reinterpret_cast(tableSchema); auto srcTable = reinterpret_cast( catalog.getReadOnlyVersion()->getTableSchema(relTableSchema->getSrcTableID())); auto dstTable = reinterpret_cast( catalog.getReadOnlyVersion()->getTableSchema(relTableSchema->getDstTableID())); - auto srcColumnName = std::string(Property::REL_FROM_PROPERTY_NAME); - auto dstColumnName = std::string(Property::REL_TO_PROPERTY_NAME); - columnNames.push_back(srcColumnName); - columnNames.push_back(dstColumnName); + columnNames.push_back("from"); + columnNames.push_back("to"); auto srcPKColumnType = srcTable->getPrimaryKey()->getDataType()->copy(); if (srcPKColumnType->getLogicalTypeID() == LogicalTypeID::SERIAL) { srcPKColumnType = LogicalType::INT64(); @@ -230,13 +243,7 @@ void Binder::bindExpectedRelColumns(catalog::TableSchema* tableSchema, } columnTypes.push_back(std::move(srcPKColumnType)); columnTypes.push_back(std::move(dstPKColumnType)); - for (auto& property : tableSchema->properties) { - if (skipPropertyInFile(*property)) { - continue; - } - columnNames.push_back(property->getName()); - columnTypes.push_back(property->getDataType()->copy()); - } + bindExpectedColumns(tableSchema, inputColumnNames, columnNames, columnTypes); } } // namespace binder diff --git a/src/binder/bind/bind_reading_clause.cpp b/src/binder/bind/bind_reading_clause.cpp index 4fb960306a..0f111394d0 100644 --- a/src/binder/bind/bind_reading_clause.cpp +++ b/src/binder/bind/bind_reading_clause.cpp @@ -134,7 +134,7 @@ std::unique_ptr Binder::bindInQueryCall(const ReadingClause& columns.push_back(createVariable(bindData->columnNames[i], *bindData->columnTypes[i])); } auto offset = expressionBinder.createVariableExpression( - LogicalType(LogicalTypeID::INT64), common::InternalKeyword::ANONYMOUS); + *LogicalType::INT64(), std::string(InternalKeyword::ROW_OFFSET)); auto boundInQueryCall = std::make_unique( std::move(tableFunction), std::move(bindData), std::move(columns), offset); if (call.hasWherePredicate()) { @@ -182,9 +182,9 @@ std::unique_ptr Binder::bindLoadFrom( columns.push_back(createVariable(bindData->columnNames[i], *bindData->columnTypes[i])); } auto offset = expressionBinder.createVariableExpression( - LogicalType(LogicalTypeID::INT64), common::InternalKeyword::ANONYMOUS); - auto info = std::make_unique(scanFunction, std::move(bindData), - std::move(columns), std::move(offset), TableType::UNKNOWN); + LogicalType(LogicalTypeID::INT64), std::string(InternalKeyword::ROW_OFFSET)); + auto info = std::make_unique( + scanFunction, std::move(bindData), std::move(columns), std::move(offset)); auto boundLoadFrom = std::make_unique(std::move(info)); if (loadFrom.hasWherePredicate()) { auto wherePredicate = expressionBinder.bindExpression(*loadFrom.getWherePredicate()); diff --git a/src/binder/bind/copy/bind_copy_rdf_graph.cpp b/src/binder/bind/copy/bind_copy_rdf_graph.cpp index 42c6b7e4a4..2227785b8f 100644 --- a/src/binder/bind/copy/bind_copy_rdf_graph.cpp +++ b/src/binder/bind/copy/bind_copy_rdf_graph.cpp @@ -14,79 +14,79 @@ using namespace kuzu::parser; namespace kuzu { namespace binder { -std::unique_ptr Binder::bindCopyRdfNodeFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, TableSchema* tableSchema) { +std::unique_ptr Binder::bindCopyRdfNodeFrom(const Statement& /*statement*/, + std::unique_ptr config, TableSchema* tableSchema) { + auto func = getScanFunction(config->fileType, config->csvReaderConfig->parallel); bool containsSerial; auto stringType = LogicalType{LogicalTypeID::STRING}; std::vector columnNames; std::vector> columnTypes; - columnNames.push_back(std::string(InternalKeyword::ANONYMOUS)); + columnNames.emplace_back(rdf::IRI); if (tableSchema->tableName.ends_with(rdf::RESOURCE_TABLE_SUFFIX)) { containsSerial = false; columnTypes.push_back(stringType.copy()); - readerConfig->rdfReaderConfig = + config->rdfReaderConfig = std::make_unique(RdfReaderMode::RESOURCE, nullptr /* index */); } else { KU_ASSERT(tableSchema->tableName.ends_with(rdf::LITERAL_TABLE_SUFFIX)); containsSerial = true; columnTypes.push_back(RdfVariantType::getType()); - readerConfig->rdfReaderConfig = + config->rdfReaderConfig = std::make_unique(RdfReaderMode::LITERAL, nullptr /* index */); } auto bindInput = std::make_unique( - memoryManager, *readerConfig, columnNames, std::move(columnTypes)); - auto bindData = - copyFunc->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); + memoryManager, *config, columnNames, std::move(columnTypes)); + auto bindData = func->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); expression_vector columns; for (auto i = 0u; i < bindData->columnTypes.size(); i++) { columns.push_back(createVariable(bindData->columnNames[i], *bindData->columnTypes[i])); } auto offset = expressionBinder.createVariableExpression( - LogicalType(LogicalTypeID::INT64), common::InternalKeyword::ANONYMOUS); - auto boundFileScanInfo = std::make_unique( - copyFunc, std::move(bindData), columns, std::move(offset), TableType::NODE); - auto boundCopyFromInfo = std::make_unique(tableSchema, - std::move(boundFileScanInfo), containsSerial, std::move(columns), nullptr /* extraInfo */); + LogicalType(LogicalTypeID::INT64), InternalKeyword::ROW_OFFSET); + auto boundFileScanInfo = + std::make_unique(func, std::move(bindData), columns, std::move(offset)); + auto boundCopyFromInfo = std::make_unique( + tableSchema, std::move(boundFileScanInfo), containsSerial, nullptr /* extraInfo */); return std::make_unique(std::move(boundCopyFromInfo)); } -std::unique_ptr Binder::bindCopyRdfRelFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, TableSchema* tableSchema) { +std::unique_ptr Binder::bindCopyRdfRelFrom(const Statement& /*statement*/, + std::unique_ptr config, TableSchema* tableSchema) { + auto func = getScanFunction(config->fileType, config->csvReaderConfig->parallel); auto containsSerial = false; std::vector columnNames; + columnNames.emplace_back(InternalKeyword::SRC_OFFSET); + columnNames.emplace_back(rdf::PID); + columnNames.emplace_back(InternalKeyword::DST_OFFSET); std::vector> columnTypes; for (auto i = 0u; i < 3; ++i) { - auto columnName = std::string(InternalKeyword::ANONYMOUS) + std::to_string(i); - columnNames.push_back(columnName); columnTypes.push_back(LogicalType::INT64()); } auto relTableSchema = reinterpret_cast(tableSchema); auto resourceTableID = relTableSchema->getSrcTableID(); auto index = storageManager->getPKIndex(resourceTableID); if (tableSchema->tableName.ends_with(rdf::RESOURCE_TRIPLE_TABLE_SUFFIX)) { - readerConfig->rdfReaderConfig = + config->rdfReaderConfig = std::make_unique(RdfReaderMode::RESOURCE_TRIPLE, index); } else { - readerConfig->rdfReaderConfig = + config->rdfReaderConfig = std::make_unique(RdfReaderMode::LITERAL_TRIPLE, index); } auto bindInput = std::make_unique( - memoryManager, *readerConfig, columnNames, std::move(columnTypes)); - auto bindData = - copyFunc->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); + memoryManager, *config, columnNames, std::move(columnTypes)); + auto bindData = func->bindFunc(clientContext, bindInput.get(), catalog.getReadOnlyVersion()); expression_vector columns; for (auto i = 0u; i < bindData->columnTypes.size(); i++) { columns.push_back(createVariable(bindData->columnNames[i], *bindData->columnTypes[i])); } auto offset = expressionBinder.createVariableExpression( - LogicalType(LogicalTypeID::INT64), common::InternalKeyword::ANONYMOUS); - auto boundFileScanInfo = std::make_unique( - copyFunc, std::move(bindData), columns, offset, TableType::REL); + LogicalType(LogicalTypeID::INT64), InternalKeyword::ROW_OFFSET); + auto boundFileScanInfo = + std::make_unique(func, std::move(bindData), columns, offset); auto extraInfo = std::make_unique(columns[0], columns[2]); expression_vector columnsToCopy = {columns[0], columns[2], offset, columns[1]}; - auto boundCopyFromInfo = - std::make_unique(tableSchema, std::move(boundFileScanInfo), - containsSerial, std::move(columnsToCopy), std::move(extraInfo)); + auto boundCopyFromInfo = std::make_unique( + tableSchema, std::move(boundFileScanInfo), containsSerial, std::move(extraInfo)); return std::make_unique(std::move(boundCopyFromInfo)); } diff --git a/src/binder/binder.cpp b/src/binder/binder.cpp index ed53c2be89..03d8ffaeaf 100644 --- a/src/binder/binder.cpp +++ b/src/binder/binder.cpp @@ -3,6 +3,7 @@ #include "binder/bound_statement_rewriter.h" #include "common/exception/binder.h" #include "common/string_format.h" +#include "function/table_functions.h" using namespace kuzu::common; using namespace kuzu::parser; @@ -218,7 +219,6 @@ function::TableFunction* Binder::getScanFunction(common::FileType fileType, bool func = catalog.getBuiltInFunctions()->matchScalarFunction(READ_PARQUET_FUNC_NAME, inputTypes); } break; - case common::FileType::NPY: { func = catalog.getBuiltInFunctions()->matchScalarFunction( READ_NPY_FUNC_NAME, std::move(inputTypes)); diff --git a/src/catalog/table_schema.cpp b/src/catalog/table_schema.cpp index 578d74dbce..47d1e81c75 100644 --- a/src/catalog/table_schema.cpp +++ b/src/catalog/table_schema.cpp @@ -30,6 +30,28 @@ std::vector TableSchema::getProperties() const { return propertiesToReturn; } +bool TableSchema::containProperty(const std::string& propertyName) const { + return std::any_of(properties.begin(), properties.end(), + [&propertyName](const std::unique_ptr& property) { + return property->getName() == propertyName; + }); +} + +bool TableSchema::containsColumnType(const common::LogicalType& logicalType) const { + return std::any_of(properties.begin(), properties.end(), + [&logicalType](const std::unique_ptr& property) { + return *property->getDataType() == logicalType; + }); +} + +void TableSchema::dropProperty(common::property_id_t propertyID) { + properties.erase(std::remove_if(properties.begin(), properties.end(), + [propertyID](const std::unique_ptr& property) { + return property->getPropertyID() == propertyID; + }), + properties.end()); +} + property_id_t TableSchema::getPropertyID(const std::string& propertyName) const { for (auto& property : properties) { if (property->getName() == propertyName) { diff --git a/src/include/binder/binder.h b/src/include/binder/binder.h index 7851c0f5c5..f89a4e9e80 100644 --- a/src/include/binder/binder.h +++ b/src/include/binder/binder.h @@ -5,7 +5,6 @@ #include "catalog/catalog.h" #include "common/copier_config/copier_config.h" #include "expression_binder.h" -#include "function/table_functions.h" #include "parser/query/graph_pattern/pattern_element.h" #include "parser/query/regular_query.h" #include "storage/storage_manager.h" @@ -19,6 +18,10 @@ namespace main { class ClientContext; } +namespace function { +class TableFunction; +} + namespace binder { class BoundInsertInfo; @@ -120,20 +123,20 @@ class Binder { /*** bind copy ***/ std::unique_ptr bindCopyFromClause(const parser::Statement& statement); - std::unique_ptr bindCopyNodeFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, catalog::TableSchema* tableSchema); - std::unique_ptr bindCopyRdfNodeFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, catalog::TableSchema* tableSchema); - std::unique_ptr bindCopyRelFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, catalog::TableSchema* tableSchema); - std::unique_ptr bindCopyRdfRelFrom(function::TableFunction* copyFunc, - std::unique_ptr readerConfig, catalog::TableSchema* tableSchema); + std::unique_ptr bindCopyNodeFrom(const parser::Statement& statement, + std::unique_ptr config, catalog::TableSchema* tableSchema); + std::unique_ptr bindCopyRdfNodeFrom(const parser::Statement& statement, + std::unique_ptr config, catalog::TableSchema* tableSchema); + std::unique_ptr bindCopyRelFrom(const parser::Statement& statement, + std::unique_ptr config, catalog::TableSchema* tableSchema); + std::unique_ptr bindCopyRdfRelFrom(const parser::Statement& statement, + std::unique_ptr config, catalog::TableSchema* tableSchema); void bindExpectedNodeColumns(catalog::TableSchema* tableSchema, - std::vector& columnNames, - std::vector>& columnTypes); + const std::vector& inputColumnNames, std::vector& columnNames, + common::logical_types_t& columnTypes); void bindExpectedRelColumns(catalog::TableSchema* tableSchema, - std::vector& columnNames, - std::vector>& columnTypes); + const std::vector& inputColumnNames, std::vector& columnNames, + common::logical_types_t& columnTypes); std::unique_ptr bindCopyToClause(const parser::Statement& statement); @@ -174,7 +177,6 @@ class Binder { std::unique_ptr bindLoadFrom(const parser::ReadingClause& readingClause); /*** bind updating clause ***/ - // TODO(Guodong/Xiyang): Is update clause an accurate name? How about (data)modificationClause? std::unique_ptr bindUpdatingClause( const parser::UpdatingClause& updatingClause); std::unique_ptr bindInsertClause( diff --git a/src/include/binder/copy/bound_copy_from.h b/src/include/binder/copy/bound_copy_from.h index d31ef6567d..e9ab9b4dee 100644 --- a/src/include/binder/copy/bound_copy_from.h +++ b/src/include/binder/copy/bound_copy_from.h @@ -16,22 +16,16 @@ struct BoundCopyFromInfo { catalog::TableSchema* tableSchema; std::unique_ptr fileScanInfo; bool containsSerial; - expression_vector columns; std::unique_ptr extraInfo; BoundCopyFromInfo(catalog::TableSchema* tableSchema, std::unique_ptr fileScanInfo, bool containsSerial, - expression_vector columns, std::unique_ptr extraInfo) + std::unique_ptr extraInfo) : tableSchema{tableSchema}, fileScanInfo{std::move(fileScanInfo)}, - containsSerial{containsSerial}, columns{std::move(columns)}, extraInfo{ - std::move(extraInfo)} {} + containsSerial{containsSerial}, extraInfo{std::move(extraInfo)} {} BoundCopyFromInfo(const BoundCopyFromInfo& other) : tableSchema{other.tableSchema}, fileScanInfo{other.fileScanInfo->copy()}, containsSerial{other.containsSerial} { - columns.reserve(other.columns.size()); - for (auto& column : other.columns) { - columns.push_back(column->copy()); - } if (other.extraInfo) { extraInfo = other.extraInfo->copy(); } diff --git a/src/include/binder/copy/bound_file_scan_info.h b/src/include/binder/copy/bound_file_scan_info.h index acbca7f5d6..8490d63923 100644 --- a/src/include/binder/copy/bound_file_scan_info.h +++ b/src/include/binder/copy/bound_file_scan_info.h @@ -1,7 +1,6 @@ #pragma once #include "binder/expression/expression.h" -#include "common/enums/table_type.h" #include "function/table_functions.h" #include "function/table_functions/bind_data.h" @@ -10,22 +9,18 @@ namespace binder { struct BoundFileScanInfo { function::TableFunction* copyFunc; - std::unique_ptr copyFuncBindData; + std::unique_ptr bindData; binder::expression_vector columns; - std::shared_ptr internalID; - - // TODO: remove the following field - common::TableType tableType; + std::shared_ptr offset; BoundFileScanInfo(function::TableFunction* copyFunc, - std::unique_ptr copyFuncBindData, - binder::expression_vector columns, std::shared_ptr internalID, - common::TableType tableType) - : copyFunc{copyFunc}, copyFuncBindData{std::move(copyFuncBindData)}, - columns{std::move(columns)}, internalID{std::move(internalID)}, tableType{tableType} {} + std::unique_ptr bindData, binder::expression_vector columns, + std::shared_ptr offset) + : copyFunc{copyFunc}, bindData{std::move(bindData)}, columns{std::move(columns)}, + offset{std::move(offset)} {} BoundFileScanInfo(const BoundFileScanInfo& other) - : copyFunc{other.copyFunc}, copyFuncBindData{other.copyFuncBindData->copy()}, - columns{other.columns}, internalID{other.internalID}, tableType{other.tableType} {} + : copyFunc{other.copyFunc}, bindData{other.bindData->copy()}, columns{other.columns}, + offset{other.offset} {} inline std::unique_ptr copy() const { return std::make_unique(*this); diff --git a/src/include/binder/expression/variable_expression.h b/src/include/binder/expression/variable_expression.h index e118fd60d3..6d2c6a3d5f 100644 --- a/src/include/binder/expression/variable_expression.h +++ b/src/include/binder/expression/variable_expression.h @@ -12,6 +12,8 @@ class VariableExpression : public Expression { : Expression{common::ExpressionType::VARIABLE, std::move(dataType), std::move(uniqueName)}, variableName{std::move(variableName)} {} + inline std::string getVariableName() const { return variableName; } + inline std::string toStringInternal() const final { return variableName; } inline std::unique_ptr copy() const final { diff --git a/src/include/catalog/property.h b/src/include/catalog/property.h index 82aeee4b37..3574453d71 100644 --- a/src/include/catalog/property.h +++ b/src/include/catalog/property.h @@ -11,13 +11,6 @@ namespace catalog { class Property { public: - // TODO: these should be guarded as reserved property names. - static constexpr std::string_view REL_FROM_PROPERTY_NAME = "_FROM_"; - static constexpr std::string_view REL_TO_PROPERTY_NAME = "_TO_"; - static constexpr std::string_view INTERNAL_ID_NAME = "_ID_"; - static constexpr std::string_view REL_BOUND_OFFSET_NAME = "_BOUND_OFFSET_"; - static constexpr std::string_view REL_NBR_OFFSET_NAME = "_NBR_OFFSET_"; - Property(std::string name, std::unique_ptr dataType) : Property{std::move(name), std::move(dataType), common::INVALID_PROPERTY_ID, common::INVALID_TABLE_ID} {} diff --git a/src/include/catalog/rel_table_schema.h b/src/include/catalog/rel_table_schema.h index a44ec47deb..48cd981b4c 100644 --- a/src/include/catalog/rel_table_schema.h +++ b/src/include/catalog/rel_table_schema.h @@ -47,15 +47,10 @@ class RelTableSchema : public TableSchema { inline common::table_id_t getBoundTableID(common::RelDataDirection relDirection) const { return relDirection == common::RelDataDirection::FWD ? srcTableID : dstTableID; } - inline common::table_id_t getNbrTableID(common::RelDataDirection relDirection) const { return relDirection == common::RelDataDirection::FWD ? dstTableID : srcTableID; } - - inline RelMultiplicity getRelMultiplicity() const { return relMultiplicity; } - inline common::table_id_t getSrcTableID() const { return srcTableID; } - inline common::table_id_t getDstTableID() const { return dstTableID; } static std::unique_ptr deserialize(common::Deserializer& deserializer); diff --git a/src/include/catalog/table_schema.h b/src/include/catalog/table_schema.h index db7bff4a6d..07b1ddbb80 100644 --- a/src/include/catalog/table_schema.h +++ b/src/include/catalog/table_schema.h @@ -1,7 +1,5 @@ #pragma once -#include - #include "common/enums/table_type.h" #include "property.h" @@ -33,23 +31,10 @@ class TableSchema { inline common::table_id_t getTableID() const { return tableID; } inline uint32_t getNumProperties() const { return properties.size(); } - - inline void dropProperty(common::property_id_t propertyID) { - properties.erase(std::remove_if(properties.begin(), properties.end(), - [propertyID](const std::unique_ptr& property) { - return property->getPropertyID() == propertyID; - }), - properties.end()); - } - - inline bool containProperty(std::string propertyName) const { - return std::any_of(properties.begin(), properties.end(), - [&propertyName](const std::unique_ptr& property) { - return property->getName() == propertyName; - }); - } - std::vector getProperties() const; + bool containProperty(const std::string& propertyName) const; + bool containsColumnType(const common::LogicalType& logicalType) const; + void dropProperty(common::property_id_t propertyID); inline void addNodeProperty( std::string propertyName, std::unique_ptr dataType) { diff --git a/src/include/common/constants.h b/src/include/common/constants.h index 5bb64c91d6..7ffe3a4775 100644 --- a/src/include/common/constants.h +++ b/src/include/common/constants.h @@ -37,6 +37,10 @@ struct InternalKeyword { static constexpr char PLACE_HOLDER[] = "_PLACE_HOLDER"; static constexpr char MAP_KEY[] = "KEY"; static constexpr char MAP_VALUE[] = "VALUE"; + + static constexpr char ROW_OFFSET[] = "_row_offset"; + static constexpr char SRC_OFFSET[] = "_src_offset"; + static constexpr char DST_OFFSET[] = "_dst_offset"; }; enum PageSizeClass : uint8_t { diff --git a/src/include/common/types/types.h b/src/include/common/types/types.h index 75b001a2fb..639f6b51ef 100644 --- a/src/include/common/types/types.h +++ b/src/include/common/types/types.h @@ -352,6 +352,8 @@ class LogicalType { std::unique_ptr extraTypeInfo; }; +using logical_types_t = std::vector>; + struct VarListType { static inline LogicalType* getChildType(const LogicalType* type) { KU_ASSERT(type->getPhysicalType() == PhysicalTypeID::VAR_LIST); diff --git a/src/include/parser/copy.h b/src/include/parser/copy.h index 24e5648fad..6b9576e1f6 100644 --- a/src/include/parser/copy.h +++ b/src/include/parser/copy.h @@ -1,5 +1,7 @@ #pragma once +#include + #include "parser/expression/parsed_expression.h" #include "parser/query/regular_query.h" #include "parser/statement.h" @@ -9,9 +11,9 @@ namespace parser { class Copy : public Statement { public: - explicit Copy(common::StatementType type, parsing_option_t parsingOptions) - : Statement{type}, parsingOptions{std::move(parsingOptions)} {} + explicit Copy(common::StatementType type) : Statement{type} {} + inline void setParsingOption(parsing_option_t options) { parsingOptions = std::move(options); } inline const parsing_option_t& getParsingOptionsRef() const { return parsingOptions; } protected: @@ -20,26 +22,30 @@ class Copy : public Statement { class CopyFrom : public Copy { public: - explicit CopyFrom(bool byColumn_, std::vector filePaths, std::string tableName, - parsing_option_t parsingOptions) - : Copy{common::StatementType::COPY_FROM, std::move(parsingOptions)}, byColumn_{byColumn_}, - filePaths{std::move(filePaths)}, tableName{std::move(tableName)} {} + CopyFrom(std::vector filePaths, std::string tableName) + : Copy{common::StatementType::COPY_FROM}, byColumn_{false}, filePaths{std::move(filePaths)}, + tableName{std::move(tableName)} {} + inline void setByColumn() { byColumn_ = true; } inline bool byColumn() const { return byColumn_; } + inline std::vector getFilePaths() const { return filePaths; } inline std::string getTableName() const { return tableName; } + inline void setColumnNames(std::vector names) { columnNames = std::move(names); } + inline std::vector getColumnNames() const { return columnNames; } + private: bool byColumn_; std::vector filePaths; std::string tableName; + std::vector columnNames; }; class CopyTo : public Copy { public: - explicit CopyTo(std::string filePath, std::unique_ptr regularQuery, - parsing_option_t parsingOptions) - : Copy{common::StatementType::COPY_TO, std::move(parsingOptions)}, + CopyTo(std::string filePath, std::unique_ptr regularQuery) + : Copy{common::StatementType::COPY_TO}, regularQuery{std::move(regularQuery)}, filePath{std::move(filePath)} {} inline std::string getFilePath() const { return filePath; } diff --git a/src/include/parser/transformer.h b/src/include/parser/transformer.h index 7c54d3f280..652170b459 100644 --- a/src/include/parser/transformer.h +++ b/src/include/parser/transformer.h @@ -35,6 +35,7 @@ class Transformer { std::unique_ptr transformCopyFrom(CypherParser::KU_CopyFromContext& ctx); std::unique_ptr transformCopyFromByColumn( CypherParser::KU_CopyFromByColumnContext& ctx); + std::vector transformColumnNames(CypherParser::KU_ColumnNamesContext& ctx); std::vector transformFilePaths( std::vector stringLiteral); std::unordered_map> transformParsingOptions( diff --git a/src/include/planner/operator/logical_partitioner.h b/src/include/planner/operator/logical_partitioner.h index 19d601ad55..932e5ab6a3 100644 --- a/src/include/planner/operator/logical_partitioner.h +++ b/src/include/planner/operator/logical_partitioner.h @@ -1,5 +1,6 @@ #pragma once +#include "catalog/table_schema.h" #include "common/column_data_format.h" #include "planner/operator/logical_operator.h" @@ -10,12 +11,16 @@ struct LogicalPartitionerInfo { std::shared_ptr key; binder::expression_vector payloads; common::ColumnDataFormat dataFormat; + catalog::TableSchema* tableSchema; LogicalPartitionerInfo(std::shared_ptr key, - binder::expression_vector payloads, common::ColumnDataFormat dataFormat) - : key{std::move(key)}, payloads{std::move(payloads)}, dataFormat{dataFormat} {} + binder::expression_vector payloads, common::ColumnDataFormat dataFormat, + catalog::TableSchema* tableSchema) + : key{std::move(key)}, payloads{std::move(payloads)}, dataFormat{dataFormat}, + tableSchema{tableSchema} {} LogicalPartitionerInfo(const LogicalPartitionerInfo& other) - : key{other.key}, payloads{other.payloads}, dataFormat{other.dataFormat} {} + : key{other.key}, payloads{other.payloads}, dataFormat{other.dataFormat}, + tableSchema{other.tableSchema} {} inline std::unique_ptr copy() { return std::make_unique(*this); diff --git a/src/include/processor/data_pos.h b/src/include/processor/data_pos.h index 89b3c31b67..197cb44aee 100644 --- a/src/include/processor/data_pos.h +++ b/src/include/processor/data_pos.h @@ -24,6 +24,11 @@ struct DataPos { DataPos(const DataPos& other) : DataPos(other.dataChunkPos, other.valueVectorPos) {} + static DataPos getInvalidPos() { return DataPos(); } + bool isValid() const { + return dataChunkPos != INVALID_DATA_CHUNK_POS && valueVectorPos != INVALID_VALUE_VECTOR_POS; + } + inline bool operator==(const DataPos& rhs) const { return (dataChunkPos == rhs.dataChunkPos) && (valueVectorPos == rhs.valueVectorPos); } diff --git a/src/include/processor/operator/partitioner.h b/src/include/processor/operator/partitioner.h index 987dd91619..e305d05de0 100644 --- a/src/include/processor/operator/partitioner.h +++ b/src/include/processor/operator/partitioner.h @@ -44,15 +44,17 @@ struct PartitionerLocalState { struct PartitioningInfo { DataPos keyDataPos; - std::vector columnDataPos; + std::vector columnDataPositions; + common::logical_types_t columnTypes; partitioner_func_t partitionerFunc; - PartitioningInfo( - DataPos keyDataPos, std::vector columnDataPos, partitioner_func_t partitionerFunc) - : keyDataPos{keyDataPos}, columnDataPos{std::move(columnDataPos)}, partitionerFunc{ - partitionerFunc} {} + PartitioningInfo(DataPos keyDataPos, std::vector columnDataPositions, + common::logical_types_t columnTypes, partitioner_func_t partitionerFunc) + : keyDataPos{keyDataPos}, columnDataPositions{std::move(columnDataPositions)}, + columnTypes{std::move(columnTypes)}, partitionerFunc{partitionerFunc} {} inline std::unique_ptr copy() { - return std::make_unique(keyDataPos, columnDataPos, partitionerFunc); + return std::make_unique(keyDataPos, columnDataPositions, + common::LogicalType::copy(columnTypes), partitionerFunc); } static std::vector> copy( @@ -78,9 +80,6 @@ class Partitioner : public Sink { void initializePartitioningStates( std::vector>& partitioningBuffers); - static void constructDataChunk(common::DataChunk* dataChunk, - const std::vector& dataPoses, processor::ResultSet* resultSet); - // TODO: For now, CopyRel will guarantee all data are inside one data chunk. Should be // generalized to resultSet later if needed. void copyDataToPartitions(common::partition_idx_t partitioningIdx, diff --git a/src/include/processor/operator/persistent/copy_node.h b/src/include/processor/operator/persistent/copy_node.h index 17b3402e28..83c36c61e9 100644 --- a/src/include/processor/operator/persistent/copy_node.h +++ b/src/include/processor/operator/persistent/copy_node.h @@ -115,6 +115,7 @@ class CopyNode : public Sink { std::unique_ptr info; common::DataChunkState* columnState; + std::vector> nullColumnVectors; std::vector columnVectors; std::unique_ptr localNodeGroup; }; diff --git a/src/include/processor/operator/persistent/copy_rel.h b/src/include/processor/operator/persistent/copy_rel.h index d95191a1c6..c70bd7a9de 100644 --- a/src/include/processor/operator/persistent/copy_rel.h +++ b/src/include/processor/operator/persistent/copy_rel.h @@ -2,7 +2,6 @@ #include "catalog/rel_table_schema.h" #include "common/enums/rel_direction.h" -#include "processor/data_pos.h" #include "processor/operator/partitioner.h" #include "processor/operator/sink.h" #include "storage/stats/rels_store_statistics.h" @@ -18,25 +17,18 @@ struct CopyRelInfo { common::vector_idx_t partitioningIdx; common::RelDataDirection dataDirection; common::ColumnDataFormat dataFormat; - // TODO(Guodong): the following 3 fields are not being used. - std::vector dataPoses; - DataPos srcOffsetPos; - DataPos relIDPos; + storage::WAL* wal; bool compressionEnabled; CopyRelInfo(catalog::RelTableSchema* schema, common::vector_idx_t partitioningIdx, common::RelDataDirection dataDirection, common::ColumnDataFormat dataFormat, - std::vector dataPose, const DataPos& srcOffsetPos, const DataPos& relIDPos, storage::WAL* wal, bool compressionEnabled) : schema{schema}, partitioningIdx{partitioningIdx}, dataDirection{dataDirection}, - dataFormat{dataFormat}, dataPoses{std::move(dataPose)}, srcOffsetPos{srcOffsetPos}, - relIDPos{relIDPos}, wal{wal}, compressionEnabled{compressionEnabled} {} + dataFormat{dataFormat}, wal{wal}, compressionEnabled{compressionEnabled} {} CopyRelInfo(const CopyRelInfo& other) : schema{other.schema}, partitioningIdx{other.partitioningIdx}, - dataDirection{other.dataDirection}, - dataFormat{other.dataFormat}, dataPoses{other.dataPoses}, - srcOffsetPos{other.srcOffsetPos}, relIDPos{other.relIDPos}, wal{other.wal} {} + dataDirection{other.dataDirection}, dataFormat{other.dataFormat}, wal{other.wal} {} inline std::unique_ptr copy() { return std::make_unique(*this); } }; diff --git a/src/include/processor/plan_mapper.h b/src/include/processor/plan_mapper.h index 82a098985c..dcbd77d89b 100644 --- a/src/include/processor/plan_mapper.h +++ b/src/include/processor/plan_mapper.h @@ -147,6 +147,11 @@ class PlanMapper { static std::vector getExpressionsDataPos( const binder::expression_vector& expressions, const planner::Schema& schema); + static inline DataPos getDataPos( + const binder::Expression& expression, const planner::Schema& schema) { + return DataPos(schema.getExpressionPos(expression)); + } + public: storage::StorageManager& storageManager; storage::MemoryManager* memoryManager; diff --git a/src/parser/transform/transform_copy.cpp b/src/parser/transform/transform_copy.cpp index b73619b601..c312e8a422 100644 --- a/src/parser/transform/transform_copy.cpp +++ b/src/parser/transform/transform_copy.cpp @@ -9,32 +9,42 @@ namespace parser { std::unique_ptr Transformer::transformCopyTo(CypherParser::KU_CopyTOContext& ctx) { std::string filePath = transformStringLiteral(*ctx.StringLiteral()); auto regularQuery = transformQuery(*ctx.oC_Query()); - parsing_option_t parsingOptions; + auto copyTo = std::make_unique(std::move(filePath), std::move(regularQuery)); if (ctx.kU_ParsingOptions()) { - parsingOptions = transformParsingOptions(*ctx.kU_ParsingOptions()); + copyTo->setParsingOption(transformParsingOptions(*ctx.kU_ParsingOptions())); } - return std::make_unique( - std::move(filePath), std::move(regularQuery), std::move(parsingOptions)); + return copyTo; } std::unique_ptr Transformer::transformCopyFrom(CypherParser::KU_CopyFromContext& ctx) { auto filePaths = transformFilePaths(ctx.kU_FilePaths()->StringLiteral()); auto tableName = transformSchemaName(*ctx.oC_SchemaName()); - parsing_option_t parsingOptions; + auto copyFrom = std::make_unique(std::move(filePaths), std::move(tableName)); + if (ctx.kU_ColumnNames()) { + copyFrom->setColumnNames(transformColumnNames(*ctx.kU_ColumnNames())); + } if (ctx.kU_ParsingOptions()) { - parsingOptions = transformParsingOptions(*ctx.kU_ParsingOptions()); + copyFrom->setParsingOption(transformParsingOptions(*ctx.kU_ParsingOptions())); } - return std::make_unique(false /* byColumn */, std::move(filePaths), - std::move(tableName), std::move(parsingOptions)); + return copyFrom; } std::unique_ptr Transformer::transformCopyFromByColumn( CypherParser::KU_CopyFromByColumnContext& ctx) { auto filePaths = transformFilePaths(ctx.StringLiteral()); auto tableName = transformSchemaName(*ctx.oC_SchemaName()); - auto parsingOptions = std::unordered_map>(); - return std::make_unique( - true /* byColumn */, std::move(filePaths), std::move(tableName), std::move(parsingOptions)); + auto copyFrom = std::make_unique(std::move(filePaths), std::move(tableName)); + copyFrom->setByColumn(); + return copyFrom; +} + +std::vector Transformer::transformColumnNames( + CypherParser::KU_ColumnNamesContext& ctx) { + std::vector columnNames; + for (auto& schemaName : ctx.oC_SchemaName()) { + columnNames.push_back(transformSchemaName(*schemaName)); + } + return columnNames; } std::vector Transformer::transformFilePaths( diff --git a/src/planner/operator/scan/logical_scan_file.cpp b/src/planner/operator/scan/logical_scan_file.cpp index f449fe681e..3999cbd94a 100644 --- a/src/planner/operator/scan/logical_scan_file.cpp +++ b/src/planner/operator/scan/logical_scan_file.cpp @@ -7,14 +7,14 @@ void LogicalScanFile::computeFactorizedSchema() { createEmptySchema(); auto groupPos = schema->createGroup(); schema->insertToGroupAndScope(info->columns, groupPos); - schema->insertToGroupAndScope(info->internalID, groupPos); + schema->insertToGroupAndScope(info->offset, groupPos); } void LogicalScanFile::computeFlatSchema() { createEmptySchema(); schema->createGroup(); schema->insertToGroupAndScope(info->columns, 0); - schema->insertToGroupAndScope(info->internalID, 0); + schema->insertToGroupAndScope(info->offset, 0); } } // namespace planner diff --git a/src/planner/plan/plan_copy.cpp b/src/planner/plan/plan_copy.cpp index e06daf2f1a..4fac446c75 100644 --- a/src/planner/plan/plan_copy.cpp +++ b/src/planner/plan/plan_copy.cpp @@ -13,6 +13,7 @@ using namespace kuzu::binder; using namespace kuzu::storage; using namespace kuzu::catalog; using namespace kuzu::common; +using namespace kuzu::function; namespace kuzu { namespace planner { @@ -27,36 +28,40 @@ static void appendIndexScan( static void appendPartitioner(BoundCopyFromInfo* copyFromInfo, LogicalPlan& plan) { std::vector> infos; - auto readerConfig = reinterpret_cast( - copyFromInfo->fileScanInfo->copyFuncBindData.get()) - ->config; + auto readerConfig = + reinterpret_cast(copyFromInfo->fileScanInfo->bindData.get()) + ->config; auto fileType = readerConfig.fileType; + auto payloads = copyFromInfo->fileScanInfo->columns; + payloads.push_back(copyFromInfo->fileScanInfo->offset); // TODO(Xiyang): Merge TURTLE case with other data types. switch (fileType) { case FileType::TURTLE: { auto extraInfo = reinterpret_cast(copyFromInfo->extraInfo.get()); infos.push_back(std::make_unique( - extraInfo->subjectOffset, copyFromInfo->columns, ColumnDataFormat::CSR)); + extraInfo->subjectOffset, payloads, ColumnDataFormat::CSR, copyFromInfo->tableSchema)); infos.push_back(std::make_unique( - extraInfo->objectOffset, copyFromInfo->columns, ColumnDataFormat::CSR)); + extraInfo->objectOffset, payloads, ColumnDataFormat::CSR, copyFromInfo->tableSchema)); } break; case FileType::CSV: case FileType::NPY: case FileType::PARQUET: { auto extraInfo = reinterpret_cast(copyFromInfo->extraInfo.get()); auto tableSchema = reinterpret_cast(copyFromInfo->tableSchema); + payloads.push_back(extraInfo->srcOffset); + payloads.push_back(extraInfo->dstOffset); // Partitioner for FWD direction rel data. - infos.push_back( - std::make_unique(extraInfo->srcOffset, copyFromInfo->columns, - tableSchema->isSingleMultiplicityInDirection(RelDataDirection::FWD) ? - ColumnDataFormat::REGULAR : - ColumnDataFormat::CSR)); + infos.push_back(std::make_unique(extraInfo->srcOffset, payloads, + tableSchema->isSingleMultiplicityInDirection(RelDataDirection::FWD) ? + ColumnDataFormat::REGULAR : + ColumnDataFormat::CSR, + tableSchema)); // Partitioner for BWD direction rel data. - infos.push_back( - std::make_unique(extraInfo->dstOffset, copyFromInfo->columns, - tableSchema->isSingleMultiplicityInDirection(RelDataDirection::BWD) ? - ColumnDataFormat::REGULAR : - ColumnDataFormat::CSR)); + infos.push_back(std::make_unique(extraInfo->dstOffset, payloads, + tableSchema->isSingleMultiplicityInDirection(RelDataDirection::BWD) ? + ColumnDataFormat::REGULAR : + ColumnDataFormat::CSR, + tableSchema)); } break; default: { KU_UNREACHABLE; @@ -71,9 +76,8 @@ static void appendPartitioner(BoundCopyFromInfo* copyFromInfo, LogicalPlan& plan std::unique_ptr Planner::planCopyFrom(const BoundStatement& statement) { auto& copyFrom = dynamic_cast(statement); auto copyFromInfo = copyFrom.getInfo(); - auto readerConfig = reinterpret_cast( - copyFromInfo->fileScanInfo->copyFuncBindData.get()) - ->config; + auto scanInfo = copyFromInfo->fileScanInfo.get(); + auto readerConfig = reinterpret_cast(scanInfo->bindData.get())->config; auto fileType = readerConfig.fileType; auto plan = std::make_unique(); QueryPlanner::appendScanFile(copyFromInfo->fileScanInfo.get(), *plan); diff --git a/src/processor/map/CMakeLists.txt b/src/processor/map/CMakeLists.txt index f4837d0140..e78fa24c77 100644 --- a/src/processor/map/CMakeLists.txt +++ b/src/processor/map/CMakeLists.txt @@ -33,7 +33,6 @@ add_library(kuzu_processor_mapper map_merge.cpp map_multiplicity_reducer.cpp map_order_by.cpp - map_partitioner.cpp map_path_property_probe.cpp map_projection.cpp map_recursive_extend.cpp diff --git a/src/processor/map/map_copy_from.cpp b/src/processor/map/map_copy_from.cpp index 42ad7674fa..04e6e73776 100644 --- a/src/processor/map/map_copy_from.cpp +++ b/src/processor/map/map_copy_from.cpp @@ -1,5 +1,7 @@ #include "binder/copy/bound_copy_from.h" +#include "binder/expression/variable_expression.h" #include "catalog/node_table_schema.h" +#include "planner/operator/logical_partitioner.h" #include "planner/operator/persistent/logical_copy_from.h" #include "processor/operator/call/in_query_call.h" #include "processor/operator/partitioner.h" @@ -31,6 +33,55 @@ std::unique_ptr PlanMapper::mapCopyFrom(LogicalOperator* logic // LCOV_EXCL_STOP } +static void getNodeColumnsInCopyOrder( + TableSchema* tableSchema, std::vector& columnNames, logical_types_t& columnTypes) { + for (auto& property : tableSchema->getProperties()) { + columnNames.push_back(property->getName()); + columnTypes.push_back(property->getDataType()->copy()); + } +} + +static void getRelColumnNamesInCopyOrder( + TableSchema* tableSchema, std::vector& columnNames, logical_types_t& columnTypes) { + columnNames.emplace_back(InternalKeyword::SRC_OFFSET); + columnNames.emplace_back(InternalKeyword::DST_OFFSET); + columnNames.emplace_back(InternalKeyword::ROW_OFFSET); + columnTypes.emplace_back(std::make_unique(LogicalTypeID::INT64)); + columnTypes.emplace_back(std::make_unique(LogicalTypeID::INT64)); + columnTypes.emplace_back(std::make_unique(LogicalTypeID::INT64)); + auto properties = tableSchema->getProperties(); + for (auto i = 1; i < properties.size(); ++i) { // skip internal ID + columnNames.push_back(properties[i]->getName()); + columnTypes.push_back(properties[i]->getDataType()->copy()); + } +} + +static std::shared_ptr matchColumnExpression( + const expression_vector& columnExpressions, const std::string& columnName) { + for (auto& expression : columnExpressions) { + KU_ASSERT(expression->expressionType == ExpressionType::VARIABLE); + auto var = reinterpret_cast(expression.get()); + if (columnName == var->getVariableName()) { + return expression; + } + } + return nullptr; +} + +static std::vector getColumnDataPositions(const std::vector& columnNames, + const expression_vector& inputColumns, const Schema& fSchema) { + std::vector columnPositions; + for (auto& columnName : columnNames) { + auto expr = matchColumnExpression(inputColumns, columnName); + if (expr != nullptr) { + columnPositions.emplace_back(fSchema.getExpressionPos(*expr)); + } else { + columnPositions.push_back(DataPos()); + } + } + return columnPositions; +} + std::unique_ptr PlanMapper::mapCopyNodeFrom(LogicalOperator* logicalOperator) { auto copyFrom = reinterpret_cast(logicalOperator); auto copyFromInfo = copyFrom->getInfo(); @@ -44,26 +95,31 @@ std::unique_ptr PlanMapper::mapCopyNodeFrom(LogicalOperator* l auto sharedState = std::make_shared(inQueryCall->getSharedState()); sharedState->wal = storageManager.getWAL(); sharedState->table = nodeTable; - for (auto& property : tableSchema->getProperties()) { - sharedState->columnTypes.push_back(property->getDataType()->copy()); - } - auto properties = tableSchema->getProperties(); auto pk = tableSchema->getPrimaryKey(); - for (auto i = 0u; i < properties.size(); ++i) { - if (properties[i]->getPropertyID() == pk->getPropertyID()) { - sharedState->pkColumnIdx = i; - } - } + sharedState->pkColumnIdx = tableSchema->getColumnID(pk->getPropertyID()); sharedState->pkType = pk->getDataType()->copy(); sharedState->fTable = getSingleStringColumnFTable(); - std::vector dataColumnPoses = - getExpressionsDataPos(copyFromInfo->columns, *outFSchema); - auto info = std::make_unique(std::move(dataColumnPoses), nodeTable, + std::vector columnNames; + logical_types_t columnTypes; + getNodeColumnsInCopyOrder(tableSchema, columnNames, columnTypes); + std::vector columnNamesExcludingSerial; + for (auto i = 0u; i < columnNames.size(); ++i) { + if (columnTypes[i]->getLogicalTypeID() == common::LogicalTypeID::SERIAL) { + continue; + } + columnNamesExcludingSerial.push_back(columnNames[i]); + } + auto inputColumns = copyFromInfo->fileScanInfo->columns; + inputColumns.push_back(copyFromInfo->fileScanInfo->offset); + auto columnPositions = + getColumnDataPositions(columnNamesExcludingSerial, inputColumns, *outFSchema); + sharedState->columnTypes = std::move(columnTypes); + auto info = std::make_unique(std::move(columnPositions), nodeTable, tableSchema->tableName, copyFromInfo->containsSerial, storageManager.compressionEnabled()); std::unique_ptr copyNode; - auto readerConfig = reinterpret_cast( - copyFromInfo->fileScanInfo->copyFuncBindData.get()) - ->config; + auto readerConfig = + reinterpret_cast(copyFromInfo->fileScanInfo->bindData.get()) + ->config; if (readerConfig.fileType == FileType::TURTLE && readerConfig.rdfReaderConfig->mode == RdfReaderMode::RESOURCE) { copyNode = std::make_unique(sharedState, std::move(info), @@ -79,6 +135,28 @@ std::unique_ptr PlanMapper::mapCopyNodeFrom(LogicalOperator* l sharedState->fTable, DEFAULT_VECTOR_CAPACITY /* maxMorselSize */, std::move(copyNode)); } +std::unique_ptr PlanMapper::mapPartitioner(LogicalOperator* logicalOperator) { + auto logicalPartitioner = reinterpret_cast(logicalOperator); + auto prevOperator = mapOperator(logicalPartitioner->getChild(0).get()); + auto outFSchema = logicalPartitioner->getSchema(); + std::vector> infos; + infos.reserve(logicalPartitioner->getNumInfos()); + for (auto i = 0u; i < logicalPartitioner->getNumInfos(); i++) { + auto info = logicalPartitioner->getInfo(i); + auto keyPos = getDataPos(*info->key, *outFSchema); + std::vector columnNames; + logical_types_t columnTypes; + getRelColumnNamesInCopyOrder(info->tableSchema, columnNames, columnTypes); + auto columnPositions = getColumnDataPositions(columnNames, info->payloads, *outFSchema); + infos.push_back(std::make_unique(keyPos, columnPositions, + std::move(columnTypes), PartitionerFunctions::partitionRelData)); + } + auto sharedState = std::make_shared(); + return std::make_unique(std::make_unique(outFSchema), + std::move(infos), std::move(sharedState), std::move(prevOperator), getOperatorID(), + logicalPartitioner->getExpressionsForPrinting()); +} + std::unique_ptr PlanMapper::createCopyRel( std::shared_ptr partitionerSharedState, std::shared_ptr sharedState, LogicalCopyFrom* copyFrom, @@ -94,29 +172,11 @@ std::unique_ptr PlanMapper::createCopyRel( auto numPartitions = (maxBoundNodeOffset + StorageConstants::NODE_GROUP_SIZE) / StorageConstants::NODE_GROUP_SIZE; partitionerSharedState->numPartitions[partitioningIdx] = numPartitions; - auto relIDDataPos = - DataPos{outFSchema->getExpressionPos(*copyFromInfo->fileScanInfo->internalID)}; - DataPos srcOffsetPos, dstOffsetPos; - auto readerConfig = reinterpret_cast( - copyFromInfo->fileScanInfo->copyFuncBindData.get()) - ->config; - if (readerConfig.fileType == FileType::TURTLE) { - auto extraInfo = reinterpret_cast(copyFromInfo->extraInfo.get()); - srcOffsetPos = DataPos{outFSchema->getExpressionPos(*extraInfo->subjectOffset)}; - dstOffsetPos = DataPos{outFSchema->getExpressionPos(*extraInfo->objectOffset)}; - } else { - auto extraInfo = reinterpret_cast(copyFromInfo->extraInfo.get()); - srcOffsetPos = DataPos{outFSchema->getExpressionPos(*extraInfo->srcOffset)}; - dstOffsetPos = DataPos{outFSchema->getExpressionPos(*extraInfo->dstOffset)}; - } - auto dataColumnPositions = getExpressionsDataPos(copyFromInfo->columns, *outFSchema); auto dataFormat = tableSchema->isSingleMultiplicityInDirection(direction) ? ColumnDataFormat::REGULAR : ColumnDataFormat::CSR; - auto copyRelInfo = - std::make_unique(tableSchema, partitioningIdx, direction, dataFormat, - dataColumnPositions, direction == RelDataDirection::FWD ? srcOffsetPos : dstOffsetPos, - relIDDataPos, storageManager.getWAL(), storageManager.compressionEnabled()); + auto copyRelInfo = std::make_unique(tableSchema, partitioningIdx, direction, + dataFormat, storageManager.getWAL(), storageManager.compressionEnabled()); return std::make_unique(std::move(copyRelInfo), std::move(partitionerSharedState), std::move(sharedState), std::make_unique(outFSchema), getOperatorID(), copyFrom->getExpressionsForPrinting()); diff --git a/src/processor/map/map_partitioner.cpp b/src/processor/map/map_partitioner.cpp deleted file mode 100644 index c2d7f369f4..0000000000 --- a/src/processor/map/map_partitioner.cpp +++ /dev/null @@ -1,30 +0,0 @@ -#include "planner/operator/logical_partitioner.h" -#include "processor/operator/partitioner.h" -#include "processor/plan_mapper.h" - -using namespace kuzu::planner; - -namespace kuzu { -namespace processor { - -std::unique_ptr PlanMapper::mapPartitioner(LogicalOperator* logicalOperator) { - auto logicalPartitioner = reinterpret_cast(logicalOperator); - auto prevOperator = mapOperator(logicalPartitioner->getChild(0).get()); - auto outFSchema = logicalPartitioner->getSchema(); - std::vector> infos; - infos.reserve(logicalPartitioner->getNumInfos()); - for (auto i = 0u; i < logicalPartitioner->getNumInfos(); i++) { - auto logicalInfo = logicalPartitioner->getInfo(i); - infos.push_back(std::make_unique( - DataPos{outFSchema->getExpressionPos(*logicalInfo->key)}, - getExpressionsDataPos(logicalInfo->payloads, *outFSchema), - PartitionerFunctions::partitionRelData)); - } - auto sharedState = std::make_shared(); - return std::make_unique(std::make_unique(outFSchema), - std::move(infos), std::move(sharedState), std::move(prevOperator), getOperatorID(), - logicalPartitioner->getExpressionsForPrinting()); -} - -} // namespace processor -} // namespace kuzu diff --git a/src/processor/map/map_scan_file.cpp b/src/processor/map/map_scan_file.cpp index fb7be43a09..fb48476bd0 100644 --- a/src/processor/map/map_scan_file.cpp +++ b/src/processor/map/map_scan_file.cpp @@ -18,8 +18,8 @@ std::unique_ptr PlanMapper::mapScanFile(LogicalOperator* logic dataColumnsPos.emplace_back(outSchema->getExpressionPos(*expression)); } auto inQueryCallFuncInfo = - std::make_unique(info->copyFunc, info->copyFuncBindData->copy(), - std::move(dataColumnsPos), DataPos(outSchema->getExpressionPos(*info->internalID))); + std::make_unique(info->copyFunc, info->bindData->copy(), + std::move(dataColumnsPos), DataPos(outSchema->getExpressionPos(*info->offset))); return std::make_unique(std::move(inQueryCallFuncInfo), std::make_shared(), PhysicalOperatorType::IN_QUERY_CALL, getOperatorID(), scanFile->getExpressionsForPrinting()); diff --git a/src/processor/operator/partitioner.cpp b/src/processor/operator/partitioner.cpp index fc046fed99..382ebd7a54 100644 --- a/src/processor/operator/partitioner.cpp +++ b/src/processor/operator/partitioner.cpp @@ -79,6 +79,21 @@ void Partitioner::initLocalStateInternal(ResultSet* /*resultSet*/, ExecutionCont initializePartitioningStates(localState->partitioningBuffers); } +static void constructDataChunk(DataChunk* dataChunk, const std::vector& columnPositions, + const logical_types_t& columnTypes, const ResultSet& resultSet) { + for (auto i = 0u; i < columnPositions.size(); i++) { + auto pos = columnPositions[i]; + if (pos.isValid()) { + dataChunk->insert(i, resultSet.getValueVector(pos)); + } else { + auto columnType = columnTypes[i].get(); + auto nullVector = std::make_shared(*columnType); + nullVector->setAllNull(); + dataChunk->insert(i, nullVector); + } + } +} + void Partitioner::executeInternal(ExecutionContext* context) { while (children[0]->getNextTuple(context)) { for (auto partitioningIdx = 0u; partitioningIdx < infos.size(); partitioningIdx++) { @@ -87,8 +102,9 @@ void Partitioner::executeInternal(ExecutionContext* context) { partitionIdxes->state = resultSet->getValueVector(info->keyDataPos)->state; info->partitionerFunc(keyVector.get(), partitionIdxes.get()); auto columnDataChunk = - std::make_unique(info->columnDataPos.size(), keyVector->state); - constructDataChunk(columnDataChunk.get(), info->columnDataPos, resultSet); + std::make_unique(info->columnTypes.size(), keyVector->state); + constructDataChunk( + columnDataChunk.get(), info->columnDataPositions, info->columnTypes, *resultSet); copyDataToPartitions(partitioningIdx, columnDataChunk.get(), context->memoryManager); } } @@ -110,13 +126,6 @@ void Partitioner::initializePartitioningStates( } } -void Partitioner::constructDataChunk( - DataChunk* dataChunk, const std::vector& dataPoses, ResultSet* resultSet) { - for (auto i = 0u; i < dataPoses.size(); i++) { - dataChunk->insert(i, resultSet->getValueVector(dataPoses[i])); - } -} - void Partitioner::copyDataToPartitions( partition_idx_t partitioningIdx, DataChunk* chunkToCopyFrom, MemoryManager* memoryManager) { for (auto i = 0u; i < chunkToCopyFrom->state->selVector->selectedSize; i++) { diff --git a/src/processor/operator/persistent/copy_node.cpp b/src/processor/operator/persistent/copy_node.cpp index bb95f7ba99..0fa6b936ab 100644 --- a/src/processor/operator/persistent/copy_node.cpp +++ b/src/processor/operator/persistent/copy_node.cpp @@ -61,12 +61,29 @@ void CopyNode::initGlobalStateInternal(ExecutionContext* /*context*/) { } void CopyNode::initLocalStateInternal(ResultSet* resultSet, ExecutionContext* /*context*/) { + std::shared_ptr state; for (auto& pos : info->columnPositions) { - columnVectors.push_back(resultSet->getValueVector(pos).get()); + if (pos.isValid()) { + state = resultSet->getValueVector(pos)->state; + } + } + KU_ASSERT(state != nullptr); + for (auto i = 0; i < info->columnPositions.size(); ++i) { + auto pos = info->columnPositions[i]; + if (pos.isValid()) { + columnVectors.push_back(resultSet->getValueVector(pos).get()); + } else { + auto columnType = sharedState->columnTypes[i].get(); + auto nullVector = std::make_shared(*columnType); + nullVector->setState(state); + nullVector->setAllNull(); + nullColumnVectors.push_back(nullVector); + columnVectors.push_back(nullVector.get()); + } } localNodeGroup = NodeGroupFactory::createNodeGroup( ColumnDataFormat::REGULAR, sharedState->columnTypes, info->compressionEnabled); - columnState = resultSet->getDataChunk(info->columnPositions[0].dataChunkPos)->state.get(); + columnState = state.get(); } void CopyNode::executeInternal(ExecutionContext* context) { diff --git a/src/storage/store/string_column.cpp b/src/storage/store/string_column.cpp index 86b18215f8..b0821d6dd5 100644 --- a/src/storage/store/string_column.cpp +++ b/src/storage/store/string_column.cpp @@ -1,6 +1,7 @@ #include "storage/store/string_column.h" #include "storage/store/string_column_chunk.h" +#include using namespace kuzu::catalog; using namespace kuzu::common; diff --git a/src/storage/store/string_column_chunk.cpp b/src/storage/store/string_column_chunk.cpp index 6eeac8c6b9..272adff0a3 100644 --- a/src/storage/store/string_column_chunk.cpp +++ b/src/storage/store/string_column_chunk.cpp @@ -1,5 +1,7 @@ #include "storage/store/string_column_chunk.h" +#include + using namespace kuzu::common; namespace kuzu { diff --git a/test/test_files/copy/copy_partial_column.test b/test/test_files/copy/copy_partial_column.test new file mode 100644 index 0000000000..b1d4ac7eff --- /dev/null +++ b/test/test_files/copy/copy_partial_column.test @@ -0,0 +1,210 @@ +-GROUP CopyPartialColumnsTest +-DATASET CSV empty + +-- + +-CASE RelPartialColumnsTest + +-STATEMENT CREATE NODE TABLE person (ID INt64, fName StRING, gender INT64, isStudent BoOLEAN, isWorker BOOLEAN, + age INT64, eyeSight DOUBLE, birthdate DATE, registerTime TIMESTAMP, + lastJobDuration interval, workedHours INT64[], usedNames STRING[], + courseScoresPerTerm INT64[][], grades INT64[4], height float, PRIMARY KEY (ID)); +---- ok +-STATEMENT COPY person FROM "${KUZU_ROOT_DIRECTORY}/dataset/tinysnb/vPerson.csv" (Header=True) ; +---- ok +-STATEMENT CREATE REL TABLE knows1 (FROM person TO person, nullDouble DOUBLE, date DATE, meetTime TIMESTAMP, + validInterval INTERVAL, comments STRING[], summary STRUCT(locations STRING[], + transfer STRUCT(day DATE, amount INT64[])), notes UNION(firstmet DATE, type INT16, comment STRING), MANY_MANY); +---- ok +-STATEMENT COPY knows1 (date, meetTime, validInterval, comments, summary, notes) FROM "${KUZU_ROOT_DIRECTORY}/dataset/tinysnb/eKnows.csv" ; +---- ok +-STATEMENT MATCH (p:person)-[e:knows1]->(:person) WHERE p.ID = 2 RETURN e.*; +---- 3 +|1950-05-14|1946-08-25 19:07:22|00:23:00|[fwehu9h9832wewew,23u9h989sdfsss]|{locations: ['paris'], transfer: {day: 2011-05-01, amount: [2000,5340]}}|cool stuff found +|1950-05-14|2012-12-11 20:07:22|20 years 30 days 48:00:00|[fwh9y81232uisuiehuf,ewnuihxy8dyf232]|{locations: ['vancouver'], transfer: {day: 2020-01-01, amount: [120,50]}}|matthew perry +|2021-06-30|1946-08-25 19:07:22|10 years 5 months 13:00:00.000024|[2huh9y89fsfw23,23nsihufhw723]|{locations: ['paris'], transfer: {day: 2000-01-01, amount: [20,5000]}}|4 +-STATEMENT CREATE REL TABLE knows2 (FROM person TO person,notes UNION(firstmet DATE, type INT16, comment STRING), + meetTime TIMESTAMP,nullDouble DOUBLE, date DATE, validInterval INTERVAL, comments STRING[], + summary STRUCT(locations STRING[], transfer STRUCT(day DATE, amount INT64[])), MANY_MANY); +---- ok +-STATEMENT COPY knows2 (date, meetTime, validInterval, comments, summary, notes) FROM "${KUZU_ROOT_DIRECTORY}/dataset/tinysnb/eKnows.csv" ; +---- ok +-STATEMENT MATCH (p:person)-[e:knows2]->(:person) WHERE p.ID = 2 RETURN e.*; +---- 3 +4|1946-08-25 19:07:22||2021-06-30|10 years 5 months 13:00:00.000024|[2huh9y89fsfw23,23nsihufhw723]|{locations: ['paris'], transfer: {day: 2000-01-01, amount: [20,5000]}} +cool stuff found|1946-08-25 19:07:22||1950-05-14|00:23:00|[fwehu9h9832wewew,23u9h989sdfsss]|{locations: ['paris'], transfer: {day: 2011-05-01, amount: [2000,5340]}} +matthew perry|2012-12-11 20:07:22||1950-05-14|20 years 30 days 48:00:00|[fwh9y81232uisuiehuf,ewnuihxy8dyf232]|{locations: ['vancouver'], transfer: {day: 2020-01-01, amount: [120,50]}} +-STATEMENT CREATE REL TABLE knows3 (FROM person TO person, a INT16, notes UNION(firstmet DATE, type INT16, comment STRING), + meetTime TIMESTAMP,nullDouble DOUBLE, date DATE, validInterval INTERVAL, comments STRING[], + summary STRUCT(locations STRING[], transfer STRUCT(day DATE, amount INT64[])), MANY_MANY); +---- ok +-STATEMENT COPY knows3 (meetTime, date, validInterval, comments, summary) FROM "${KUZU_ROOT_DIRECTORY}/dataset/tinysnb/eKnows.csv" ; +---- error +Binder exception: Number of columns mismatch. Expected 7 but got 8. +-STATEMENT COPY knows3 (meetTime, date, validInterval, comments, summary, dummy) FROM "${KUZU_ROOT_DIRECTORY}/dataset/tinysnb/eKnows.csv" ; +---- error +Binder exception: Table knows3 does not contain column dummy. + +-CASE NodePartialColumnsTest +-LOG AllPartialColumns +-STATEMENT CREATE NODE TABLE tableOfTypes2 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes2 (id, int64Column, doubleColumn, booleanColumn, dateColumn, timestampColumn, stringColumn, + listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- ok +-STATEMENT MATCH (row:tableOfTypes2) WHERE row.id >= 20 AND row.id <= 24 RETURN row.*; +---- 5 +20|0|57.579280|True|1731-09-26|1731-09-26 03:30:08|OdM|[93,,86,37] +21|7|64.630960|False|1307-01-26|1307-01-26 03:31:08|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX|[] +22|71|37.963386|True|1455-07-26|1455-07-26 03:07:03|dRvHHdyNXYfSUcicaxBoQEKQUfgex|[72,,45,,81] +23|58|42.774957|False|1181-10-16|1181-10-16 18:19:43|ISImRVpUjynGMFRQyYmeIUVjM| +24|75|53.813224|False|1942-10-24|1942-10-24 09:30:16|naDlQ|[97,91,28,26,] + +-LOG PartialColumns +-STATEMENT CREATE NODE TABLE tableOfTypes3 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + nullInt64Column INT64, nullDoubleColumn DOUBLE, nullBooleanColumn BOOLEAN,dateColumn DATE, + timestampColumn TIMESTAMP, stringColumn STRING, nullDateColumn DATE, nullTimestampColumn TIMESTAMP, + nullStringColumn STRING, listOfInt INT64[], nullListOfInt INT64[], PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes3 (id, int64Column, doubleColumn, booleanColumn, dateColumn, timestampColumn, stringColumn, + listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- ok +-STATEMENT MATCH (row:tableOfTypes3) WHERE row.id >= 20 AND row.id <= 24 RETURN row.*; +---- 5 +20|0|57.579280|True||||1731-09-26|1731-09-26 03:30:08|OdM||||[93,,86,37]| +21|7|64.630960|False||||1307-01-26|1307-01-26 03:31:08|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX||||[]| +22|71|37.963386|True||||1455-07-26|1455-07-26 03:07:03|dRvHHdyNXYfSUcicaxBoQEKQUfgex||||[72,,45,,81]| +23|58|42.774957|False||||1181-10-16|1181-10-16 18:19:43|ISImRVpUjynGMFRQyYmeIUVjM||||| +24|75|53.813224|False||||1942-10-24|1942-10-24 09:30:16|naDlQ||||[97,91,28,26,]| + +-LOG PartialColumnsReorder +-STATEMENT CREATE NODE TABLE tableOfTypes4 (nullDateColumn DATE, booleanColumn BOOLEAN, stringColumn STRING, + int64Column INT64, nullBooleanColumn BOOLEAN, nullStringColumn STRING, + timestampColumn TIMESTAMP, nullDoubleColumn DOUBLE, nullInt64Column INT64, + dateColumn DATE, nullListOfInt INT64[], doubleColumn DOUBLE, + listOfInt INT64[], id INT64, nullTimestampColumn TIMESTAMP, + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes4 (id, int64Column, doubleColumn, booleanColumn, dateColumn, timestampColumn, stringColumn, + listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- ok +-STATEMENT MATCH (row:tableOfTypes4) WHERE row.id >= 20 AND row.id <= 24 RETURN row.*; +---- 5 +|False|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX|7|||1307-01-26 03:31:08|||1307-01-26||64.630960|[]|21| +|False|ISImRVpUjynGMFRQyYmeIUVjM|58|||1181-10-16 18:19:43|||1181-10-16||42.774957||23| +|False|naDlQ|75|||1942-10-24 09:30:16|||1942-10-24||53.813224|[97,91,28,26,]|24| +|True|OdM|0|||1731-09-26 03:30:08|||1731-09-26||57.579280|[93,,86,37]|20| +|True|dRvHHdyNXYfSUcicaxBoQEKQUfgex|71|||1455-07-26 03:07:03|||1455-07-26||37.963386|[72,,45,,81]|22| + +-LOG PartialCopyException1 +-STATEMENT CREATE NODE TABLE tableOfTypes6 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes6 (id, int64Column, doubleColumn, dateColumn, timestampColumn, stringColumn, + listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- error +Binder exception: Number of columns mismatch. Expected 7 but got 8. + +-LOG PartialCopyException2 +-STATEMENT CREATE NODE TABLE tableOfTypes7 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes7 (id, int64Column, doubleColumn, nonexistentColumn, dateColumn, timestampColumn, + stringColumn, listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- error +Binder exception: Table tableOfTypes7 does not contain column nonexistentColumn. + +-LOG PartialCopyException3 +-STATEMENT CREATE NODE TABLE tableOfTypes8 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], extraColumn BOOLEAN, + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes8 (id, int64Column, doubleColumn, booleanColumn, dateColumn, timestampColumn, stringColumn, + listOfInt, extraColumn) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- error +Binder exception: Number of columns mismatch. Expected 9 but got 8. + +-LOG PartialCopyException4 +-STATEMENT CREATE NODE TABLE tableOfTypes9 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes9 (id, int64Column, doubleColumn, booleanColumn, booleanColumn, dateColumn, timestampColumn, + stringColumn, listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- error +Binder exception: Detect duplicate column name booleanColumn during COPY. + +-LOG PartialCopySerial +-STATEMENT CREATE NODE TABLE tableOfTypes10 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], serialPk SERIAL, + PRIMARY KEY (serialPk)); +---- ok +-STATEMENT COPY tableOfTypes10 (id, int64Column, doubleColumn, booleanColumn, dateColumn, timestampColumn, stringColumn, + listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- ok +-STATEMENT MATCH (row:tableOfTypes10) WHERE row.id >= 20 AND row.id <= 24 RETURN row.*; +---- 5 +20|0|57.579280|True|1731-09-26|1731-09-26 03:30:08|OdM|[93,,86,37]|20 +21|7|64.630960|False|1307-01-26|1307-01-26 03:31:08|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX|[]|21 +22|71|37.963386|True|1455-07-26|1455-07-26 03:07:03|dRvHHdyNXYfSUcicaxBoQEKQUfgex|[72,,45,,81]|22 +23|58|42.774957|False|1181-10-16|1181-10-16 18:19:43|ISImRVpUjynGMFRQyYmeIUVjM||23 +24|75|53.813224|False|1942-10-24|1942-10-24 09:30:16|naDlQ|[97,91,28,26,]|24 + +-LOG PartialCopyException5 +-STATEMENT CREATE NODE TABLE tableOfTypes11 (id INT64, int64Column INT64, doubleColumn DOUBLE, booleanColumn BOOLEAN, + dateColumn DATE, timestampColumn TIMESTAMP, stringColumn STRING, + listOfInt INT64[], nullPk INT64, + PRIMARY KEY (nullPk)); +---- ok +-STATEMENT COPY tableOfTypes11 (id, int64Column, doubleColumn, booleanColumn, dateColumn, timestampColumn, stringColumn, + listOfInt) FROM "${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/csv/types_50k.csv" (HEADER=true); +---- error +Copy exception: Found NULL, which violates the non-null constraint of the primary key column. + +-LOG PartialParquet +-STATEMENT CREATE NODE TABLE tableOfTypes12 (nullStructColumn STRUCT(ID int64, name STRING), booleanColumn BOOLEAN, + doubleColumn DOUBLE, listOfInt64 INT64[], nullListOfListOfInt64 INT64[][], + listOfString STRING[], int64Column INT64, nullId INT64, + nullInt64Column INT64, nullDateColumn DATE, nullListOfInt64 INT64[], + nullBooleanColumn BOOLEAN, dateColumn DATE, listOfListOfInt64 INT64[][], + id INT64, nullDoubleColumn DOUBLE, nullListOfString STRING[], + structColumn STRUCT(ID int64, name STRING), stringColumn STRING, + nullStringColumn STRING, + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes12 (id, int64Column, doubleColumn, booleanColumn, dateColumn, stringColumn, listOfInt64, +listOfString, listOfListOfInt64, structColumn) FROM +"${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/parquet/types_50k*.parquet" (HEADER=true); +---- ok +-STATEMENT MATCH (row:tableOfTypes12) WHERE row.id >= 20 AND row.id <= 24 RETURN row.*; +---- 5 +|False|42.774957|[16,38,98,61,2]||[EzPWolZ2iCsga46o,lbhcKq7DDPeiX,yaxsyrbzolAyVWlxj,5Rlse62CKuIitVf4,yKOx0P]|58||||||2043-08-19|[[95,209,75,7],[197],[69,244],[164,160,153,125]]|23|||{ID: 682, name: 06SBnT}|ISImRVpUjynGMFRQyYmeIUVjM| +|False|53.813224|[94,17,22]||[gVYovI30hQyC,b6OpP]|75||||||1971-12-05|[[81,66],[255,44],[37]]|24|||{ID: 185, name: 7xymBThq}|naDlQ| +|False|64.630960|[53,44,76,78]||[V0yNTz60W2i4J,LN3F2erCELm]|7||||||2090-07-13|[[191,62],[64,259,183,130,116],[49,29,222,249,128],[222,169,22,80],[206,59]]|21|||{ID: 956, name: GNX5sv9V}|AjbxHQThEtDDlOjbzMjCQSXlvGQEjcFLykESrnFHwPKX| +|True|37.963386|[74]||[GOLV1]|71||||||2048-04-24|[[139,156,218],[148,187,62],[158,118],[297,151]]|22|||{ID: 838, name: gRdEkZSI8qQ7dIH}|dRvHHdyNXYfSUcicaxBoQEKQUfgex| +|True|57.579280|[85,11,98,6]||[wl7evae,lLtQIMJI,vNvYnjt27]|0||||||2094-08-19|[[131,129]]|20|||{ID: 717, name: 3oOf}|OdM| +-STATEMENT CREATE NODE TABLE tableOfTypes13 (nullStructColumn STRUCT(ID int64, name STRING), booleanColumn BOOLEAN, + doubleColumn DOUBLE, listOfInt64 INT64[], nullListOfListOfInt64 INT64[][], + listOfString STRING[], int64Column INT64, nullId INT64, + nullInt64Column INT64, nullDateColumn DATE, nullListOfInt64 INT64[], + nullBooleanColumn BOOLEAN, dateColumn DATE, listOfListOfInt64 INT64[][], + id INT64, nullDoubleColumn DOUBLE, nullListOfString STRING[], + structColumn STRUCT(ID int64, name STRING), stringColumn STRING, + nullStringColumn STRING, + PRIMARY KEY (id)); +---- ok +-STATEMENT COPY tableOfTypes12 (id, dateColumn, doubleColumn, booleanColumn, int64Column, stringColumn, listOfInt64, +listOfString, listOfListOfInt64, structColumn) FROM +"${KUZU_ROOT_DIRECTORY}/dataset/copy-test/node/parquet/types_50k*.parquet" (HEADER=true); +---- error +Binder exception: Column `dateColumn` type mismatch. Expected DATE but got INT64. diff --git a/third_party/antlr4_cypher/cypher_parser.cpp b/third_party/antlr4_cypher/cypher_parser.cpp index 7eb5ff7c35..88af31e9b6 100644 --- a/third_party/antlr4_cypher/cypher_parser.cpp +++ b/third_party/antlr4_cypher/cypher_parser.cpp @@ -51,7 +51,7 @@ void cypherParserInitialize() { #endif auto staticData = std::make_unique( std::vector{ - "oC_Cypher", "oC_Statement", "kU_CopyFrom", "kU_CopyFromByColumn", + "oC_Cypher", "oC_Statement", "kU_CopyFrom", "kU_ColumnNames", "kU_CopyFromByColumn", "kU_CopyTO", "kU_StandaloneCall", "kU_CommentOn", "kU_CreateMacro", "kU_PositionalArgs", "kU_DefaultArg", "kU_FilePaths", "kU_ParsingOptions", "kU_ParsingOption", "kU_DDL", "kU_CreateNodeTable", "kU_CreateRelTable", @@ -126,7 +126,7 @@ void cypherParserInitialize() { } ); static const int32_t serializedATNSegment[] = { - 4,1,143,2158,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,143,2191,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, @@ -146,825 +146,839 @@ void cypherParserInitialize() { 7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122, 7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128, 7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134, - 7,134,2,135,7,135,2,136,7,136,2,137,7,137,1,0,3,0,278,8,0,1,0,3,0,281, - 8,0,1,0,3,0,284,8,0,1,0,1,0,3,0,288,8,0,1,0,3,0,291,8,0,1,0,3,0,294,8, - 0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,307,8,1,1,2,1,2,1,2, - 1,2,1,2,1,2,1,2,1,2,3,2,317,8,2,1,2,1,2,3,2,321,8,2,1,2,1,2,3,2,325,8, - 2,1,2,1,2,3,2,329,8,2,1,3,1,3,1,3,1,3,1,3,1,3,1,3,1,3,3,3,339,8,3,1,3, - 1,3,3,3,343,8,3,1,3,1,3,3,3,347,8,3,1,3,5,3,350,8,3,10,3,12,3,353,9,3, - 1,3,1,3,1,3,1,3,1,3,1,3,1,4,1,4,1,4,1,4,3,4,365,8,4,1,4,1,4,3,4,369,8, - 4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,377,8,4,1,4,1,4,3,4,381,8,4,1,4,1,4,3,4, - 385,8,4,1,4,1,4,3,4,389,8,4,1,5,1,5,1,5,1,5,3,5,395,8,5,1,5,1,5,3,5,399, - 8,5,1,5,1,5,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,7,1,7,1, - 7,1,7,1,7,1,7,3,7,421,8,7,1,7,1,7,3,7,425,8,7,1,7,3,7,428,8,7,1,7,3,7, - 431,8,7,1,7,3,7,434,8,7,1,7,3,7,437,8,7,1,7,1,7,3,7,441,8,7,1,7,5,7,444, - 8,7,10,7,12,7,447,9,7,1,7,3,7,450,8,7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8, - 3,8,460,8,8,1,8,1,8,3,8,464,8,8,1,8,5,8,467,8,8,10,8,12,8,470,9,8,1,9, - 1,9,3,9,474,8,9,1,9,1,9,1,9,3,9,479,8,9,1,9,1,9,1,10,1,10,3,10,485,8, - 10,1,10,1,10,3,10,489,8,10,1,10,1,10,3,10,493,8,10,1,10,5,10,496,8,10, - 10,10,12,10,499,9,10,1,10,1,10,1,10,1,10,3,10,505,8,10,1,10,1,10,3,10, - 509,8,10,1,10,1,10,3,10,513,8,10,1,10,3,10,516,8,10,1,11,1,11,3,11,520, - 8,11,1,11,1,11,3,11,524,8,11,1,11,5,11,527,8,11,10,11,12,11,530,9,11, - 1,12,1,12,3,12,534,8,12,1,12,1,12,3,12,538,8,12,1,12,1,12,1,13,1,13,1, - 13,1,13,1,13,1,13,3,13,548,8,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1, - 14,3,14,558,8,14,1,14,1,14,3,14,562,8,14,1,14,1,14,3,14,566,8,14,1,14, - 1,14,3,14,570,8,14,1,14,1,14,1,14,3,14,575,8,14,1,14,1,14,1,15,1,15,1, - 15,1,15,1,15,1,15,1,15,1,15,3,15,587,8,15,1,15,1,15,3,15,591,8,15,1,15, - 1,15,3,15,595,8,15,1,15,1,15,3,15,599,8,15,1,15,1,15,3,15,603,8,15,3, - 15,605,8,15,1,15,1,15,3,15,609,8,15,1,15,1,15,3,15,613,8,15,3,15,615, - 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,3,16, - 629,8,16,1,16,1,16,3,16,633,8,16,1,16,1,16,3,16,637,8,16,1,16,1,16,3, - 16,641,8,16,1,16,4,16,644,8,16,11,16,12,16,645,1,16,3,16,649,8,16,1,16, - 1,16,3,16,653,8,16,1,16,1,16,3,16,657,8,16,3,16,659,8,16,1,16,1,16,3, - 16,663,8,16,1,16,1,16,3,16,667,8,16,3,16,669,8,16,1,16,1,16,1,17,1,17, - 1,17,1,17,1,17,1,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18, - 1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1,20,1,20,1,20,1,20, - 1,21,1,21,1,21,1,21,3,21,707,8,21,1,22,1,22,1,22,1,22,1,22,1,22,1,22, - 1,22,1,22,3,22,718,8,22,1,23,1,23,1,23,1,23,1,24,1,24,1,24,1,24,1,24, - 1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,3,26,740,8,26, - 1,26,1,26,3,26,744,8,26,1,26,5,26,747,8,26,10,26,12,26,750,9,26,1,27, - 1,27,1,27,1,27,1,28,1,28,1,28,1,28,3,28,760,8,28,1,28,1,28,3,28,764,8, - 28,1,28,1,28,3,28,768,8,28,1,28,1,28,1,29,1,29,1,29,1,29,3,29,776,8,29, - 1,29,1,29,3,29,780,8,29,1,29,1,29,3,29,784,8,29,1,29,1,29,1,29,1,29,3, - 29,790,8,29,1,29,1,29,3,29,794,8,29,1,29,1,29,3,29,798,8,29,1,29,1,29, - 1,29,1,29,3,29,804,8,29,1,29,1,29,3,29,808,8,29,1,29,1,29,3,29,812,8, - 29,1,29,1,29,3,29,816,8,29,1,29,1,29,3,29,820,8,29,1,29,1,29,3,29,824, - 8,29,1,29,1,29,5,29,828,8,29,10,29,12,29,831,9,29,1,30,1,30,5,30,835, - 8,30,10,30,12,30,838,9,30,1,31,1,31,3,31,842,8,31,1,31,1,31,1,32,1,32, - 3,32,848,8,32,1,33,1,33,1,34,1,34,1,35,1,35,1,35,1,35,1,35,1,35,1,35, - 1,35,1,35,1,35,1,35,1,35,1,35,1,35,3,35,868,8,35,1,36,1,36,1,37,1,37, - 3,37,874,8,37,1,37,5,37,877,8,37,10,37,12,37,880,9,37,1,37,1,37,3,37, - 884,8,37,4,37,886,8,37,11,37,12,37,887,1,37,1,37,1,37,3,37,893,8,37,1, - 38,1,38,1,38,1,38,3,38,899,8,38,1,38,1,38,1,38,3,38,904,8,38,1,38,3,38, - 907,8,38,1,39,1,39,3,39,911,8,39,1,40,1,40,3,40,915,8,40,5,40,917,8,40, - 10,40,12,40,920,9,40,1,40,1,40,1,40,3,40,925,8,40,5,40,927,8,40,10,40, - 12,40,930,9,40,1,40,1,40,3,40,934,8,40,1,40,5,40,937,8,40,10,40,12,40, - 940,9,40,1,40,3,40,943,8,40,1,40,3,40,946,8,40,1,40,1,40,3,40,950,8,40, - 4,40,952,8,40,11,40,12,40,953,1,40,1,40,3,40,958,8,40,1,41,1,41,3,41, - 962,8,41,4,41,964,8,41,11,41,12,41,965,1,41,1,41,1,42,1,42,3,42,972,8, - 42,5,42,974,8,42,10,42,12,42,977,9,42,1,42,1,42,3,42,981,8,42,5,42,983, - 8,42,10,42,12,42,986,9,42,1,42,1,42,1,43,1,43,1,43,1,43,3,43,994,8,43, - 1,44,1,44,1,44,1,44,3,44,1000,8,44,1,45,1,45,1,45,1,45,1,45,1,45,3,45, - 1008,8,45,1,45,1,45,3,45,1012,8,45,1,45,1,45,3,45,1016,8,45,1,45,1,45, - 3,45,1020,8,45,1,45,1,45,1,45,1,45,1,45,3,45,1027,8,45,1,45,1,45,3,45, - 1031,8,45,1,45,1,45,3,45,1035,8,45,1,45,1,45,3,45,1039,8,45,1,45,3,45, - 1042,8,45,1,45,3,45,1045,8,45,1,46,1,46,1,46,1,46,3,46,1051,8,46,1,46, - 3,46,1054,8,46,1,47,1,47,3,47,1058,8,47,1,47,1,47,3,47,1062,8,47,1,47, - 1,47,3,47,1066,8,47,1,47,3,47,1069,8,47,1,48,1,48,3,48,1073,8,48,1,48, - 1,48,1,48,1,48,1,48,1,48,1,49,1,49,3,49,1083,8,49,1,49,1,49,1,50,1,50, - 3,50,1089,8,50,1,50,1,50,1,50,5,50,1094,8,50,10,50,12,50,1097,9,50,1, - 51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,1,51,3,51,1109,8,51,1,52,1, - 52,3,52,1113,8,52,1,52,1,52,3,52,1117,8,52,1,52,1,52,3,52,1121,8,52,1, - 52,5,52,1124,8,52,10,52,12,52,1127,9,52,1,53,1,53,3,53,1131,8,53,1,53, - 1,53,3,53,1135,8,53,1,53,1,53,1,54,1,54,3,54,1141,8,54,1,54,1,54,3,54, - 1145,8,54,1,54,1,54,3,54,1149,8,54,1,54,5,54,1152,8,54,10,54,12,54,1155, - 9,54,1,55,1,55,1,55,3,55,1160,8,55,1,55,3,55,1163,8,55,1,56,1,56,1,56, - 1,57,3,57,1169,8,57,1,57,3,57,1172,8,57,1,57,1,57,1,57,1,57,3,57,1178, - 8,57,1,57,1,57,3,57,1182,8,57,1,57,1,57,3,57,1186,8,57,1,58,1,58,3,58, - 1190,8,58,1,58,1,58,3,58,1194,8,58,1,58,5,58,1197,8,58,10,58,12,58,1200, - 9,58,1,58,1,58,3,58,1204,8,58,1,58,1,58,3,58,1208,8,58,1,58,5,58,1211, - 8,58,10,58,12,58,1214,9,58,3,58,1216,8,58,1,59,1,59,1,59,1,59,1,59,1, - 59,1,59,3,59,1225,8,59,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60,1234,8, - 60,1,60,5,60,1237,8,60,10,60,12,60,1240,9,60,1,61,1,61,1,61,1,61,1,62, - 1,62,1,62,1,62,1,63,1,63,3,63,1252,8,63,1,63,3,63,1255,8,63,1,64,1,64, - 1,64,1,64,1,65,1,65,3,65,1263,8,65,1,65,1,65,3,65,1267,8,65,1,65,5,65, - 1270,8,65,10,65,12,65,1273,9,65,1,66,1,66,3,66,1277,8,66,1,66,1,66,3, - 66,1281,8,66,1,66,1,66,1,66,3,66,1286,8,66,1,67,1,67,1,68,1,68,3,68,1292, - 8,68,1,68,5,68,1295,8,68,10,68,12,68,1298,9,68,1,68,1,68,1,68,1,68,3, - 68,1304,8,68,1,69,1,69,3,69,1308,8,69,1,69,1,69,3,69,1312,8,69,3,69,1314, - 8,69,1,69,1,69,3,69,1318,8,69,3,69,1320,8,69,1,69,1,69,3,69,1324,8,69, - 3,69,1326,8,69,1,69,1,69,1,70,1,70,3,70,1332,8,70,1,70,1,70,1,71,1,71, - 3,71,1338,8,71,1,71,1,71,3,71,1342,8,71,1,71,3,71,1345,8,71,1,71,3,71, - 1348,8,71,1,71,1,71,1,71,1,71,3,71,1354,8,71,1,71,3,71,1357,8,71,1,71, - 3,71,1360,8,71,1,71,1,71,3,71,1364,8,71,1,71,1,71,1,71,1,71,3,71,1370, - 8,71,1,71,3,71,1373,8,71,1,71,3,71,1376,8,71,1,71,1,71,3,71,1380,8,71, - 1,72,1,72,3,72,1384,8,72,1,72,1,72,3,72,1388,8,72,3,72,1390,8,72,1,72, - 1,72,3,72,1394,8,72,3,72,1396,8,72,1,72,1,72,3,72,1400,8,72,3,72,1402, - 8,72,1,72,1,72,3,72,1406,8,72,3,72,1408,8,72,1,72,1,72,1,73,1,73,3,73, - 1414,8,73,1,73,1,73,3,73,1418,8,73,1,73,1,73,3,73,1422,8,73,1,73,1,73, - 3,73,1426,8,73,1,73,1,73,3,73,1430,8,73,1,73,1,73,3,73,1434,8,73,1,73, - 1,73,3,73,1438,8,73,1,73,1,73,3,73,1442,8,73,5,73,1444,8,73,10,73,12, - 73,1447,9,73,3,73,1449,8,73,1,73,1,73,1,74,1,74,3,74,1455,8,74,1,74,1, - 74,3,74,1459,8,74,1,74,1,74,3,74,1463,8,74,1,74,3,74,1466,8,74,1,74,5, - 74,1469,8,74,10,74,12,74,1472,9,74,1,75,1,75,3,75,1476,8,75,1,75,5,75, - 1479,8,75,10,75,12,75,1482,9,75,1,76,1,76,3,76,1486,8,76,1,76,1,76,1, - 77,1,77,3,77,1492,8,77,1,77,1,77,1,77,1,77,3,77,1498,8,77,1,77,3,77,1501, - 8,77,1,77,3,77,1504,8,77,1,77,3,77,1507,8,77,1,77,1,77,3,77,1511,8,77, - 1,77,3,77,1514,8,77,1,77,3,77,1517,8,77,1,77,3,77,1520,8,77,1,77,3,77, - 1523,8,77,1,78,1,78,3,78,1527,8,78,1,78,1,78,3,78,1531,8,78,1,78,1,78, - 3,78,1535,8,78,1,78,1,78,3,78,1539,8,78,1,78,1,78,3,78,1543,8,78,1,78, - 3,78,1546,8,78,1,78,3,78,1549,8,78,1,78,1,78,3,78,1553,8,78,1,78,1,78, - 3,78,1557,8,78,1,78,1,78,3,78,1561,8,78,1,78,1,78,3,78,1565,8,78,3,78, - 1567,8,78,1,78,1,78,1,79,1,79,3,79,1573,8,79,1,79,3,79,1576,8,79,1,79, - 3,79,1579,8,79,1,79,1,79,1,80,1,80,3,80,1585,8,80,1,80,3,80,1588,8,80, - 1,80,3,80,1591,8,80,1,80,1,80,1,81,1,81,1,82,1,82,1,83,1,83,1,84,1,84, - 1,85,1,85,1,86,1,86,1,86,1,86,1,86,5,86,1610,8,86,10,86,12,86,1613,9, - 86,1,87,1,87,1,87,1,87,1,87,5,87,1620,8,87,10,87,12,87,1623,9,87,1,88, - 1,88,1,88,1,88,1,88,5,88,1630,8,88,10,88,12,88,1633,9,88,1,89,1,89,3, - 89,1637,8,89,3,89,1639,8,89,1,89,1,89,1,90,1,90,3,90,1645,8,90,1,90,1, - 90,3,90,1649,8,90,1,90,1,90,3,90,1653,8,90,1,90,1,90,3,90,1657,8,90,1, - 90,1,90,3,90,1661,8,90,1,90,1,90,1,90,1,90,1,90,1,90,3,90,1669,8,90,1, - 90,1,90,3,90,1673,8,90,1,90,1,90,3,90,1677,8,90,1,90,1,90,3,90,1681,8, - 90,1,90,1,90,4,90,1685,8,90,11,90,12,90,1686,1,90,1,90,3,90,1691,8,90, - 1,91,1,91,1,92,1,92,3,92,1697,8,92,1,92,1,92,3,92,1701,8,92,1,92,5,92, - 1704,8,92,10,92,12,92,1707,9,92,1,93,1,93,3,93,1711,8,93,1,93,1,93,3, - 93,1715,8,93,1,93,5,93,1718,8,93,10,93,12,93,1721,9,93,1,94,1,94,3,94, - 1725,8,94,1,94,1,94,3,94,1729,8,94,1,94,1,94,5,94,1733,8,94,10,94,12, - 94,1736,9,94,1,95,1,95,1,96,1,96,3,96,1742,8,96,1,96,1,96,3,96,1746,8, - 96,1,96,1,96,5,96,1750,8,96,10,96,12,96,1753,9,96,1,97,1,97,1,98,1,98, - 3,98,1759,8,98,1,98,1,98,3,98,1763,8,98,1,98,1,98,5,98,1767,8,98,10,98, - 12,98,1770,9,98,1,99,1,99,1,100,1,100,3,100,1776,8,100,1,100,1,100,3, - 100,1780,8,100,1,100,5,100,1783,8,100,10,100,12,100,1786,9,100,1,101, - 1,101,3,101,1790,8,101,3,101,1792,8,101,1,101,1,101,3,101,1796,8,101, - 1,101,3,101,1799,8,101,1,102,1,102,1,102,4,102,1804,8,102,11,102,12,102, - 1805,1,102,3,102,1809,8,102,1,103,1,103,3,103,1813,8,103,1,104,1,104, - 1,104,1,104,1,105,1,105,3,105,1821,8,105,1,105,1,105,3,105,1825,8,105, - 1,105,1,105,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106,1,106, - 1,106,3,106,1840,8,106,1,106,3,106,1843,8,106,1,106,1,106,1,107,3,107, - 1848,8,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,3,108,1862,8,108,1,109,1,109,3,109,1866,8,109,1,109,5,109, - 1869,8,109,10,109,12,109,1872,9,109,1,110,1,110,1,110,1,110,1,110,1,110, - 1,110,3,110,1881,8,110,1,111,1,111,1,111,1,111,1,111,1,111,3,111,1889, - 8,111,1,112,1,112,1,113,1,113,3,113,1895,8,113,1,113,1,113,3,113,1899, - 8,113,1,113,1,113,3,113,1903,8,113,5,113,1905,8,113,10,113,12,113,1908, - 9,113,3,113,1910,8,113,1,113,1,113,1,114,1,114,3,114,1916,8,114,1,114, - 3,114,1919,8,114,1,115,1,115,3,115,1923,8,115,1,115,1,115,3,115,1927, - 8,115,1,115,1,115,3,115,1931,8,115,1,115,1,115,3,115,1935,8,115,5,115, - 1937,8,115,10,115,12,115,1940,9,115,1,115,1,115,1,116,1,116,3,116,1946, - 8,116,1,116,3,116,1949,8,116,1,116,1,116,3,116,1953,8,116,1,116,1,116, - 1,117,1,117,3,117,1959,8,117,1,117,1,117,3,117,1963,8,117,1,117,1,117, - 1,118,1,118,3,118,1969,8,118,1,118,1,118,3,118,1973,8,118,1,118,1,118, - 3,118,1977,8,118,1,118,1,118,1,118,1,118,3,118,1983,8,118,1,118,1,118, - 3,118,1987,8,118,1,118,1,118,3,118,1991,8,118,3,118,1993,8,118,1,118, - 1,118,3,118,1997,8,118,1,118,1,118,3,118,2001,8,118,1,118,1,118,3,118, - 2005,8,118,5,118,2007,8,118,10,118,12,118,2010,9,118,3,118,2012,8,118, - 1,118,1,118,3,118,2016,8,118,1,119,1,119,1,120,1,120,3,120,2022,8,120, - 1,120,1,120,1,120,3,120,2027,8,120,3,120,2029,8,120,1,120,1,120,1,121, - 1,121,3,121,2035,8,121,1,121,1,121,3,121,2039,8,121,1,121,1,121,3,121, - 2043,8,121,1,121,1,121,3,121,2047,8,121,1,121,3,121,2050,8,121,1,121, - 3,121,2053,8,121,1,121,1,121,1,122,1,122,3,122,2059,8,122,1,122,1,122, - 3,122,2063,8,122,1,123,1,123,3,123,2067,8,123,1,123,4,123,2070,8,123, - 11,123,12,123,2071,1,123,1,123,3,123,2076,8,123,1,123,1,123,3,123,2080, - 8,123,1,123,4,123,2083,8,123,11,123,12,123,2084,3,123,2087,8,123,1,123, - 3,123,2090,8,123,1,123,1,123,3,123,2094,8,123,1,123,3,123,2097,8,123, - 1,123,3,123,2100,8,123,1,123,1,123,1,124,1,124,3,124,2106,8,124,1,124, - 1,124,3,124,2110,8,124,1,124,1,124,3,124,2114,8,124,1,124,1,124,1,125, - 1,125,1,126,1,126,3,126,2122,8,126,1,127,1,127,1,127,3,127,2127,8,127, - 1,128,1,128,3,128,2131,8,128,1,128,1,128,1,129,1,129,1,130,1,130,1,131, - 1,131,1,132,1,132,1,133,1,133,1,133,1,133,1,133,3,133,2148,8,133,1,134, - 1,134,1,135,1,135,1,136,1,136,1,137,1,137,1,137,0,1,58,138,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,0,9,1,0,100, - 103,2,0,5,5,13,17,1,0,19,20,2,0,21,21,111,111,2,0,22,23,94,94,1,0,118, - 119,2,0,14,14,28,31,2,0,16,16,32,35,2,0,36,46,111,111,2436,0,277,1,0, - 0,0,2,306,1,0,0,0,4,308,1,0,0,0,6,330,1,0,0,0,8,360,1,0,0,0,10,390,1, - 0,0,0,12,402,1,0,0,0,14,414,1,0,0,0,16,457,1,0,0,0,18,471,1,0,0,0,20, - 515,1,0,0,0,22,517,1,0,0,0,24,531,1,0,0,0,26,547,1,0,0,0,28,549,1,0,0, - 0,30,578,1,0,0,0,32,618,1,0,0,0,34,672,1,0,0,0,36,680,1,0,0,0,38,688, - 1,0,0,0,40,694,1,0,0,0,42,706,1,0,0,0,44,708,1,0,0,0,46,719,1,0,0,0,48, - 723,1,0,0,0,50,729,1,0,0,0,52,737,1,0,0,0,54,751,1,0,0,0,56,755,1,0,0, - 0,58,823,1,0,0,0,60,832,1,0,0,0,62,839,1,0,0,0,64,847,1,0,0,0,66,849, - 1,0,0,0,68,851,1,0,0,0,70,867,1,0,0,0,72,869,1,0,0,0,74,892,1,0,0,0,76, - 906,1,0,0,0,78,910,1,0,0,0,80,957,1,0,0,0,82,963,1,0,0,0,84,975,1,0,0, - 0,86,993,1,0,0,0,88,999,1,0,0,0,90,1001,1,0,0,0,92,1046,1,0,0,0,94,1057, - 1,0,0,0,96,1070,1,0,0,0,98,1080,1,0,0,0,100,1086,1,0,0,0,102,1108,1,0, - 0,0,104,1110,1,0,0,0,106,1128,1,0,0,0,108,1138,1,0,0,0,110,1156,1,0,0, - 0,112,1164,1,0,0,0,114,1171,1,0,0,0,116,1215,1,0,0,0,118,1224,1,0,0,0, - 120,1226,1,0,0,0,122,1241,1,0,0,0,124,1245,1,0,0,0,126,1249,1,0,0,0,128, - 1256,1,0,0,0,130,1260,1,0,0,0,132,1285,1,0,0,0,134,1287,1,0,0,0,136,1303, - 1,0,0,0,138,1305,1,0,0,0,140,1329,1,0,0,0,142,1379,1,0,0,0,144,1381,1, - 0,0,0,146,1411,1,0,0,0,148,1452,1,0,0,0,150,1473,1,0,0,0,152,1483,1,0, - 0,0,154,1489,1,0,0,0,156,1524,1,0,0,0,158,1570,1,0,0,0,160,1582,1,0,0, - 0,162,1594,1,0,0,0,164,1596,1,0,0,0,166,1598,1,0,0,0,168,1600,1,0,0,0, - 170,1602,1,0,0,0,172,1604,1,0,0,0,174,1614,1,0,0,0,176,1624,1,0,0,0,178, - 1638,1,0,0,0,180,1690,1,0,0,0,182,1692,1,0,0,0,184,1694,1,0,0,0,186,1708, - 1,0,0,0,188,1722,1,0,0,0,190,1737,1,0,0,0,192,1739,1,0,0,0,194,1754,1, - 0,0,0,196,1756,1,0,0,0,198,1771,1,0,0,0,200,1773,1,0,0,0,202,1791,1,0, - 0,0,204,1800,1,0,0,0,206,1812,1,0,0,0,208,1814,1,0,0,0,210,1818,1,0,0, - 0,212,1839,1,0,0,0,214,1847,1,0,0,0,216,1861,1,0,0,0,218,1863,1,0,0,0, - 220,1880,1,0,0,0,222,1888,1,0,0,0,224,1890,1,0,0,0,226,1892,1,0,0,0,228, - 1913,1,0,0,0,230,1920,1,0,0,0,232,1945,1,0,0,0,234,1956,1,0,0,0,236,2015, - 1,0,0,0,238,2017,1,0,0,0,240,2028,1,0,0,0,242,2032,1,0,0,0,244,2056,1, - 0,0,0,246,2086,1,0,0,0,248,2103,1,0,0,0,250,2117,1,0,0,0,252,2121,1,0, - 0,0,254,2123,1,0,0,0,256,2128,1,0,0,0,258,2134,1,0,0,0,260,2136,1,0,0, - 0,262,2138,1,0,0,0,264,2140,1,0,0,0,266,2147,1,0,0,0,268,2149,1,0,0,0, - 270,2151,1,0,0,0,272,2153,1,0,0,0,274,2155,1,0,0,0,276,278,5,140,0,0, - 277,276,1,0,0,0,277,278,1,0,0,0,278,280,1,0,0,0,279,281,3,64,32,0,280, - 279,1,0,0,0,280,281,1,0,0,0,281,283,1,0,0,0,282,284,5,140,0,0,283,282, - 1,0,0,0,283,284,1,0,0,0,284,285,1,0,0,0,285,290,3,2,1,0,286,288,5,140, - 0,0,287,286,1,0,0,0,287,288,1,0,0,0,288,289,1,0,0,0,289,291,5,1,0,0,290, - 287,1,0,0,0,290,291,1,0,0,0,291,293,1,0,0,0,292,294,5,140,0,0,293,292, - 1,0,0,0,293,294,1,0,0,0,294,295,1,0,0,0,295,296,5,0,0,1,296,1,1,0,0,0, - 297,307,3,72,36,0,298,307,3,26,13,0,299,307,3,4,2,0,300,307,3,6,3,0,301, - 307,3,8,4,0,302,307,3,10,5,0,303,307,3,14,7,0,304,307,3,12,6,0,305,307, - 3,70,35,0,306,297,1,0,0,0,306,298,1,0,0,0,306,299,1,0,0,0,306,300,1,0, - 0,0,306,301,1,0,0,0,306,302,1,0,0,0,306,303,1,0,0,0,306,304,1,0,0,0,306, - 305,1,0,0,0,307,3,1,0,0,0,308,309,5,51,0,0,309,310,5,140,0,0,310,311, - 3,264,132,0,311,312,5,140,0,0,312,313,5,52,0,0,313,314,5,140,0,0,314, - 328,3,20,10,0,315,317,5,140,0,0,316,315,1,0,0,0,316,317,1,0,0,0,317,318, - 1,0,0,0,318,320,5,2,0,0,319,321,5,140,0,0,320,319,1,0,0,0,320,321,1,0, - 0,0,321,322,1,0,0,0,322,324,3,22,11,0,323,325,5,140,0,0,324,323,1,0,0, - 0,324,325,1,0,0,0,325,326,1,0,0,0,326,327,5,3,0,0,327,329,1,0,0,0,328, - 316,1,0,0,0,328,329,1,0,0,0,329,5,1,0,0,0,330,331,5,51,0,0,331,332,5, - 140,0,0,332,333,3,264,132,0,333,334,5,140,0,0,334,335,5,52,0,0,335,336, - 5,140,0,0,336,338,5,2,0,0,337,339,5,140,0,0,338,337,1,0,0,0,338,339,1, - 0,0,0,339,340,1,0,0,0,340,351,5,126,0,0,341,343,5,140,0,0,342,341,1,0, - 0,0,342,343,1,0,0,0,343,344,1,0,0,0,344,346,5,4,0,0,345,347,5,140,0,0, - 346,345,1,0,0,0,346,347,1,0,0,0,347,348,1,0,0,0,348,350,5,126,0,0,349, - 342,1,0,0,0,350,353,1,0,0,0,351,349,1,0,0,0,351,352,1,0,0,0,352,354,1, - 0,0,0,353,351,1,0,0,0,354,355,5,3,0,0,355,356,5,140,0,0,356,357,5,97, - 0,0,357,358,5,140,0,0,358,359,5,53,0,0,359,7,1,0,0,0,360,361,5,51,0,0, - 361,362,5,140,0,0,362,364,5,2,0,0,363,365,5,140,0,0,364,363,1,0,0,0,364, - 365,1,0,0,0,365,366,1,0,0,0,366,368,3,72,36,0,367,369,5,140,0,0,368,367, - 1,0,0,0,368,369,1,0,0,0,369,370,1,0,0,0,370,371,5,3,0,0,371,372,5,140, - 0,0,372,373,5,67,0,0,373,374,5,140,0,0,374,388,5,126,0,0,375,377,5,140, - 0,0,376,375,1,0,0,0,376,377,1,0,0,0,377,378,1,0,0,0,378,380,5,2,0,0,379, - 381,5,140,0,0,380,379,1,0,0,0,380,381,1,0,0,0,381,382,1,0,0,0,382,384, - 3,22,11,0,383,385,5,140,0,0,384,383,1,0,0,0,384,385,1,0,0,0,385,386,1, - 0,0,0,386,387,5,3,0,0,387,389,1,0,0,0,388,376,1,0,0,0,388,389,1,0,0,0, - 389,9,1,0,0,0,390,391,5,47,0,0,391,392,5,140,0,0,392,394,3,266,133,0, - 393,395,5,140,0,0,394,393,1,0,0,0,394,395,1,0,0,0,395,396,1,0,0,0,396, - 398,5,5,0,0,397,399,5,140,0,0,398,397,1,0,0,0,398,399,1,0,0,0,399,400, - 1,0,0,0,400,401,3,222,111,0,401,11,1,0,0,0,402,403,5,48,0,0,403,404,5, - 140,0,0,404,405,5,88,0,0,405,406,5,140,0,0,406,407,5,55,0,0,407,408,5, - 140,0,0,408,409,3,264,132,0,409,410,5,140,0,0,410,411,5,116,0,0,411,412, - 5,140,0,0,412,413,5,126,0,0,413,13,1,0,0,0,414,415,5,86,0,0,415,416,5, - 140,0,0,416,417,5,49,0,0,417,418,5,140,0,0,418,420,3,238,119,0,419,421, - 5,140,0,0,420,419,1,0,0,0,420,421,1,0,0,0,421,422,1,0,0,0,422,424,5,2, - 0,0,423,425,5,140,0,0,424,423,1,0,0,0,424,425,1,0,0,0,425,427,1,0,0,0, - 426,428,3,16,8,0,427,426,1,0,0,0,427,428,1,0,0,0,428,430,1,0,0,0,429, - 431,5,140,0,0,430,429,1,0,0,0,430,431,1,0,0,0,431,433,1,0,0,0,432,434, - 3,18,9,0,433,432,1,0,0,0,433,434,1,0,0,0,434,445,1,0,0,0,435,437,5,140, - 0,0,436,435,1,0,0,0,436,437,1,0,0,0,437,438,1,0,0,0,438,440,5,4,0,0,439, - 441,5,140,0,0,440,439,1,0,0,0,440,441,1,0,0,0,441,442,1,0,0,0,442,444, - 3,18,9,0,443,436,1,0,0,0,444,447,1,0,0,0,445,443,1,0,0,0,445,446,1,0, - 0,0,446,449,1,0,0,0,447,445,1,0,0,0,448,450,5,140,0,0,449,448,1,0,0,0, - 449,450,1,0,0,0,450,451,1,0,0,0,451,452,5,3,0,0,452,453,5,140,0,0,453, - 454,5,95,0,0,454,455,5,140,0,0,455,456,3,170,85,0,456,15,1,0,0,0,457, - 468,3,266,133,0,458,460,5,140,0,0,459,458,1,0,0,0,459,460,1,0,0,0,460, - 461,1,0,0,0,461,463,5,4,0,0,462,464,5,140,0,0,463,462,1,0,0,0,463,464, - 1,0,0,0,464,465,1,0,0,0,465,467,3,266,133,0,466,459,1,0,0,0,467,470,1, - 0,0,0,468,466,1,0,0,0,468,469,1,0,0,0,469,17,1,0,0,0,470,468,1,0,0,0, - 471,473,3,266,133,0,472,474,5,140,0,0,473,472,1,0,0,0,473,474,1,0,0,0, - 474,475,1,0,0,0,475,476,5,6,0,0,476,478,5,5,0,0,477,479,5,140,0,0,478, - 477,1,0,0,0,478,479,1,0,0,0,479,480,1,0,0,0,480,481,3,222,111,0,481,19, - 1,0,0,0,482,484,5,7,0,0,483,485,5,140,0,0,484,483,1,0,0,0,484,485,1,0, - 0,0,485,486,1,0,0,0,486,497,5,126,0,0,487,489,5,140,0,0,488,487,1,0,0, - 0,488,489,1,0,0,0,489,490,1,0,0,0,490,492,5,4,0,0,491,493,5,140,0,0,492, - 491,1,0,0,0,492,493,1,0,0,0,493,494,1,0,0,0,494,496,5,126,0,0,495,488, - 1,0,0,0,496,499,1,0,0,0,497,495,1,0,0,0,497,498,1,0,0,0,498,500,1,0,0, - 0,499,497,1,0,0,0,500,516,5,8,0,0,501,516,5,126,0,0,502,504,5,50,0,0, - 503,505,5,140,0,0,504,503,1,0,0,0,504,505,1,0,0,0,505,506,1,0,0,0,506, - 508,5,2,0,0,507,509,5,140,0,0,508,507,1,0,0,0,508,509,1,0,0,0,509,510, - 1,0,0,0,510,512,5,126,0,0,511,513,5,140,0,0,512,511,1,0,0,0,512,513,1, - 0,0,0,513,514,1,0,0,0,514,516,5,3,0,0,515,482,1,0,0,0,515,501,1,0,0,0, - 515,502,1,0,0,0,516,21,1,0,0,0,517,528,3,24,12,0,518,520,5,140,0,0,519, - 518,1,0,0,0,519,520,1,0,0,0,520,521,1,0,0,0,521,523,5,4,0,0,522,524,5, - 140,0,0,523,522,1,0,0,0,523,524,1,0,0,0,524,525,1,0,0,0,525,527,3,24, - 12,0,526,519,1,0,0,0,527,530,1,0,0,0,528,526,1,0,0,0,528,529,1,0,0,0, - 529,23,1,0,0,0,530,528,1,0,0,0,531,533,3,266,133,0,532,534,5,140,0,0, - 533,532,1,0,0,0,533,534,1,0,0,0,534,535,1,0,0,0,535,537,5,5,0,0,536,538, - 5,140,0,0,537,536,1,0,0,0,537,538,1,0,0,0,538,539,1,0,0,0,539,540,3,222, - 111,0,540,25,1,0,0,0,541,548,3,28,14,0,542,548,3,30,15,0,543,548,3,32, - 16,0,544,548,3,36,18,0,545,548,3,38,19,0,546,548,3,40,20,0,547,541,1, - 0,0,0,547,542,1,0,0,0,547,543,1,0,0,0,547,544,1,0,0,0,547,545,1,0,0,0, - 547,546,1,0,0,0,548,27,1,0,0,0,549,550,5,86,0,0,550,551,5,140,0,0,551, - 552,5,54,0,0,552,553,5,140,0,0,553,554,5,55,0,0,554,555,5,140,0,0,555, - 557,3,264,132,0,556,558,5,140,0,0,557,556,1,0,0,0,557,558,1,0,0,0,558, - 559,1,0,0,0,559,561,5,2,0,0,560,562,5,140,0,0,561,560,1,0,0,0,561,562, - 1,0,0,0,562,563,1,0,0,0,563,565,3,52,26,0,564,566,5,140,0,0,565,564,1, - 0,0,0,565,566,1,0,0,0,566,567,1,0,0,0,567,569,5,4,0,0,568,570,5,140,0, - 0,569,568,1,0,0,0,569,570,1,0,0,0,570,571,1,0,0,0,571,572,3,56,28,0,572, - 574,1,0,0,0,573,575,5,140,0,0,574,573,1,0,0,0,574,575,1,0,0,0,575,576, - 1,0,0,0,576,577,5,3,0,0,577,29,1,0,0,0,578,579,5,86,0,0,579,580,5,140, - 0,0,580,581,5,66,0,0,581,582,5,140,0,0,582,583,5,55,0,0,583,584,5,140, - 0,0,584,586,3,264,132,0,585,587,5,140,0,0,586,585,1,0,0,0,586,587,1,0, - 0,0,587,588,1,0,0,0,588,590,5,2,0,0,589,591,5,140,0,0,590,589,1,0,0,0, - 590,591,1,0,0,0,591,592,1,0,0,0,592,594,3,34,17,0,593,595,5,140,0,0,594, - 593,1,0,0,0,594,595,1,0,0,0,595,604,1,0,0,0,596,598,5,4,0,0,597,599,5, - 140,0,0,598,597,1,0,0,0,598,599,1,0,0,0,599,600,1,0,0,0,600,602,3,52, - 26,0,601,603,5,140,0,0,602,601,1,0,0,0,602,603,1,0,0,0,603,605,1,0,0, - 0,604,596,1,0,0,0,604,605,1,0,0,0,605,614,1,0,0,0,606,608,5,4,0,0,607, - 609,5,140,0,0,608,607,1,0,0,0,608,609,1,0,0,0,609,610,1,0,0,0,610,612, - 3,266,133,0,611,613,5,140,0,0,612,611,1,0,0,0,612,613,1,0,0,0,613,615, - 1,0,0,0,614,606,1,0,0,0,614,615,1,0,0,0,615,616,1,0,0,0,616,617,5,3,0, - 0,617,31,1,0,0,0,618,619,5,86,0,0,619,620,5,140,0,0,620,621,5,66,0,0, - 621,622,5,140,0,0,622,623,5,55,0,0,623,624,5,140,0,0,624,625,5,56,0,0, - 625,626,5,140,0,0,626,628,3,264,132,0,627,629,5,140,0,0,628,627,1,0,0, - 0,628,629,1,0,0,0,629,630,1,0,0,0,630,632,5,2,0,0,631,633,5,140,0,0,632, - 631,1,0,0,0,632,633,1,0,0,0,633,634,1,0,0,0,634,636,3,34,17,0,635,637, - 5,140,0,0,636,635,1,0,0,0,636,637,1,0,0,0,637,643,1,0,0,0,638,640,5,4, - 0,0,639,641,5,140,0,0,640,639,1,0,0,0,640,641,1,0,0,0,641,642,1,0,0,0, - 642,644,3,34,17,0,643,638,1,0,0,0,644,645,1,0,0,0,645,643,1,0,0,0,645, - 646,1,0,0,0,646,648,1,0,0,0,647,649,5,140,0,0,648,647,1,0,0,0,648,649, - 1,0,0,0,649,658,1,0,0,0,650,652,5,4,0,0,651,653,5,140,0,0,652,651,1,0, - 0,0,652,653,1,0,0,0,653,654,1,0,0,0,654,656,3,52,26,0,655,657,5,140,0, - 0,656,655,1,0,0,0,656,657,1,0,0,0,657,659,1,0,0,0,658,650,1,0,0,0,658, - 659,1,0,0,0,659,668,1,0,0,0,660,662,5,4,0,0,661,663,5,140,0,0,662,661, - 1,0,0,0,662,663,1,0,0,0,663,664,1,0,0,0,664,666,3,266,133,0,665,667,5, - 140,0,0,666,665,1,0,0,0,666,667,1,0,0,0,667,669,1,0,0,0,668,660,1,0,0, - 0,668,669,1,0,0,0,669,670,1,0,0,0,670,671,5,3,0,0,671,33,1,0,0,0,672, - 673,5,52,0,0,673,674,5,140,0,0,674,675,3,264,132,0,675,676,5,140,0,0, - 676,677,5,67,0,0,677,678,5,140,0,0,678,679,3,264,132,0,679,35,1,0,0,0, - 680,681,5,86,0,0,681,682,5,140,0,0,682,683,5,57,0,0,683,684,5,140,0,0, - 684,685,5,58,0,0,685,686,5,140,0,0,686,687,3,264,132,0,687,37,1,0,0,0, - 688,689,5,59,0,0,689,690,5,140,0,0,690,691,5,55,0,0,691,692,5,140,0,0, - 692,693,3,264,132,0,693,39,1,0,0,0,694,695,5,60,0,0,695,696,5,140,0,0, - 696,697,5,55,0,0,697,698,5,140,0,0,698,699,3,264,132,0,699,700,5,140, - 0,0,700,701,3,42,21,0,701,41,1,0,0,0,702,707,3,44,22,0,703,707,3,46,23, - 0,704,707,3,48,24,0,705,707,3,50,25,0,706,702,1,0,0,0,706,703,1,0,0,0, - 706,704,1,0,0,0,706,705,1,0,0,0,707,43,1,0,0,0,708,709,5,63,0,0,709,710, - 5,140,0,0,710,711,3,258,129,0,711,712,5,140,0,0,712,717,3,58,29,0,713, - 714,5,140,0,0,714,715,5,61,0,0,715,716,5,140,0,0,716,718,3,170,85,0,717, - 713,1,0,0,0,717,718,1,0,0,0,718,45,1,0,0,0,719,720,5,59,0,0,720,721,5, - 140,0,0,721,722,3,258,129,0,722,47,1,0,0,0,723,724,5,62,0,0,724,725,5, - 140,0,0,725,726,5,67,0,0,726,727,5,140,0,0,727,728,3,264,132,0,728,49, - 1,0,0,0,729,730,5,62,0,0,730,731,5,140,0,0,731,732,3,258,129,0,732,733, - 5,140,0,0,733,734,5,67,0,0,734,735,5,140,0,0,735,736,3,258,129,0,736, - 51,1,0,0,0,737,748,3,54,27,0,738,740,5,140,0,0,739,738,1,0,0,0,739,740, - 1,0,0,0,740,741,1,0,0,0,741,743,5,4,0,0,742,744,5,140,0,0,743,742,1,0, - 0,0,743,744,1,0,0,0,744,745,1,0,0,0,745,747,3,54,27,0,746,739,1,0,0,0, - 747,750,1,0,0,0,748,746,1,0,0,0,748,749,1,0,0,0,749,53,1,0,0,0,750,748, - 1,0,0,0,751,752,3,258,129,0,752,753,5,140,0,0,753,754,3,58,29,0,754,55, - 1,0,0,0,755,756,5,64,0,0,756,757,5,140,0,0,757,759,5,65,0,0,758,760,5, - 140,0,0,759,758,1,0,0,0,759,760,1,0,0,0,760,761,1,0,0,0,761,763,5,2,0, - 0,762,764,5,140,0,0,763,762,1,0,0,0,763,764,1,0,0,0,764,765,1,0,0,0,765, - 767,3,258,129,0,766,768,5,140,0,0,767,766,1,0,0,0,767,768,1,0,0,0,768, - 769,1,0,0,0,769,770,5,3,0,0,770,57,1,0,0,0,771,772,6,29,-1,0,772,824, - 3,266,133,0,773,775,5,79,0,0,774,776,5,140,0,0,775,774,1,0,0,0,775,776, - 1,0,0,0,776,777,1,0,0,0,777,779,5,2,0,0,778,780,5,140,0,0,779,778,1,0, - 0,0,779,780,1,0,0,0,780,781,1,0,0,0,781,783,3,52,26,0,782,784,5,140,0, - 0,783,782,1,0,0,0,783,784,1,0,0,0,784,785,1,0,0,0,785,786,5,3,0,0,786, - 824,1,0,0,0,787,789,3,266,133,0,788,790,5,140,0,0,789,788,1,0,0,0,789, - 790,1,0,0,0,790,791,1,0,0,0,791,793,5,2,0,0,792,794,5,140,0,0,793,792, - 1,0,0,0,793,794,1,0,0,0,794,795,1,0,0,0,795,797,3,52,26,0,796,798,5,140, - 0,0,797,796,1,0,0,0,797,798,1,0,0,0,798,799,1,0,0,0,799,800,5,3,0,0,800, - 824,1,0,0,0,801,803,3,266,133,0,802,804,5,140,0,0,803,802,1,0,0,0,803, - 804,1,0,0,0,804,805,1,0,0,0,805,807,5,2,0,0,806,808,5,140,0,0,807,806, - 1,0,0,0,807,808,1,0,0,0,808,809,1,0,0,0,809,811,3,58,29,0,810,812,5,140, - 0,0,811,810,1,0,0,0,811,812,1,0,0,0,812,813,1,0,0,0,813,815,5,4,0,0,814, - 816,5,140,0,0,815,814,1,0,0,0,815,816,1,0,0,0,816,817,1,0,0,0,817,819, - 3,58,29,0,818,820,5,140,0,0,819,818,1,0,0,0,819,820,1,0,0,0,820,821,1, - 0,0,0,821,822,5,3,0,0,822,824,1,0,0,0,823,771,1,0,0,0,823,773,1,0,0,0, - 823,787,1,0,0,0,823,801,1,0,0,0,824,829,1,0,0,0,825,826,10,4,0,0,826, - 828,3,60,30,0,827,825,1,0,0,0,828,831,1,0,0,0,829,827,1,0,0,0,829,830, - 1,0,0,0,830,59,1,0,0,0,831,829,1,0,0,0,832,836,3,62,31,0,833,835,3,62, - 31,0,834,833,1,0,0,0,835,838,1,0,0,0,836,834,1,0,0,0,836,837,1,0,0,0, - 837,61,1,0,0,0,838,836,1,0,0,0,839,841,5,7,0,0,840,842,3,260,130,0,841, - 840,1,0,0,0,841,842,1,0,0,0,842,843,1,0,0,0,843,844,5,8,0,0,844,63,1, - 0,0,0,845,848,3,66,33,0,846,848,3,68,34,0,847,845,1,0,0,0,847,846,1,0, - 0,0,848,65,1,0,0,0,849,850,5,68,0,0,850,67,1,0,0,0,851,852,5,69,0,0,852, - 69,1,0,0,0,853,854,5,70,0,0,854,855,5,140,0,0,855,868,5,71,0,0,856,857, - 5,70,0,0,857,858,5,140,0,0,858,859,5,71,0,0,859,860,5,140,0,0,860,861, - 5,72,0,0,861,862,5,140,0,0,862,868,5,73,0,0,863,868,5,75,0,0,864,868, - 5,76,0,0,865,868,5,77,0,0,866,868,5,78,0,0,867,853,1,0,0,0,867,856,1, - 0,0,0,867,863,1,0,0,0,867,864,1,0,0,0,867,865,1,0,0,0,867,866,1,0,0,0, - 868,71,1,0,0,0,869,870,3,74,37,0,870,73,1,0,0,0,871,878,3,78,39,0,872, - 874,5,140,0,0,873,872,1,0,0,0,873,874,1,0,0,0,874,875,1,0,0,0,875,877, - 3,76,38,0,876,873,1,0,0,0,877,880,1,0,0,0,878,876,1,0,0,0,878,879,1,0, - 0,0,879,893,1,0,0,0,880,878,1,0,0,0,881,883,3,112,56,0,882,884,5,140, - 0,0,883,882,1,0,0,0,883,884,1,0,0,0,884,886,1,0,0,0,885,881,1,0,0,0,886, - 887,1,0,0,0,887,885,1,0,0,0,887,888,1,0,0,0,888,889,1,0,0,0,889,890,3, - 78,39,0,890,891,6,37,-1,0,891,893,1,0,0,0,892,871,1,0,0,0,892,885,1,0, - 0,0,893,75,1,0,0,0,894,895,5,79,0,0,895,896,5,140,0,0,896,898,5,80,0, - 0,897,899,5,140,0,0,898,897,1,0,0,0,898,899,1,0,0,0,899,900,1,0,0,0,900, - 907,3,78,39,0,901,903,5,79,0,0,902,904,5,140,0,0,903,902,1,0,0,0,903, - 904,1,0,0,0,904,905,1,0,0,0,905,907,3,78,39,0,906,894,1,0,0,0,906,901, - 1,0,0,0,907,77,1,0,0,0,908,911,3,80,40,0,909,911,3,82,41,0,910,908,1, - 0,0,0,910,909,1,0,0,0,911,79,1,0,0,0,912,914,3,88,44,0,913,915,5,140, - 0,0,914,913,1,0,0,0,914,915,1,0,0,0,915,917,1,0,0,0,916,912,1,0,0,0,917, - 920,1,0,0,0,918,916,1,0,0,0,918,919,1,0,0,0,919,921,1,0,0,0,920,918,1, - 0,0,0,921,958,3,112,56,0,922,924,3,88,44,0,923,925,5,140,0,0,924,923, - 1,0,0,0,924,925,1,0,0,0,925,927,1,0,0,0,926,922,1,0,0,0,927,930,1,0,0, - 0,928,926,1,0,0,0,928,929,1,0,0,0,929,931,1,0,0,0,930,928,1,0,0,0,931, - 938,3,86,43,0,932,934,5,140,0,0,933,932,1,0,0,0,933,934,1,0,0,0,934,935, - 1,0,0,0,935,937,3,86,43,0,936,933,1,0,0,0,937,940,1,0,0,0,938,936,1,0, - 0,0,938,939,1,0,0,0,939,945,1,0,0,0,940,938,1,0,0,0,941,943,5,140,0,0, - 942,941,1,0,0,0,942,943,1,0,0,0,943,944,1,0,0,0,944,946,3,112,56,0,945, - 942,1,0,0,0,945,946,1,0,0,0,946,958,1,0,0,0,947,949,3,88,44,0,948,950, - 5,140,0,0,949,948,1,0,0,0,949,950,1,0,0,0,950,952,1,0,0,0,951,947,1,0, - 0,0,952,953,1,0,0,0,953,951,1,0,0,0,953,954,1,0,0,0,954,955,1,0,0,0,955, - 956,6,40,-1,0,956,958,1,0,0,0,957,918,1,0,0,0,957,928,1,0,0,0,957,951, - 1,0,0,0,958,81,1,0,0,0,959,961,3,84,42,0,960,962,5,140,0,0,961,960,1, - 0,0,0,961,962,1,0,0,0,962,964,1,0,0,0,963,959,1,0,0,0,964,965,1,0,0,0, - 965,963,1,0,0,0,965,966,1,0,0,0,966,967,1,0,0,0,967,968,3,80,40,0,968, - 83,1,0,0,0,969,971,3,88,44,0,970,972,5,140,0,0,971,970,1,0,0,0,971,972, - 1,0,0,0,972,974,1,0,0,0,973,969,1,0,0,0,974,977,1,0,0,0,975,973,1,0,0, - 0,975,976,1,0,0,0,976,984,1,0,0,0,977,975,1,0,0,0,978,980,3,86,43,0,979, - 981,5,140,0,0,980,979,1,0,0,0,980,981,1,0,0,0,981,983,1,0,0,0,982,978, - 1,0,0,0,983,986,1,0,0,0,984,982,1,0,0,0,984,985,1,0,0,0,985,987,1,0,0, - 0,986,984,1,0,0,0,987,988,3,110,55,0,988,85,1,0,0,0,989,994,3,98,49,0, - 990,994,3,100,50,0,991,994,3,104,52,0,992,994,3,108,54,0,993,989,1,0, - 0,0,993,990,1,0,0,0,993,991,1,0,0,0,993,992,1,0,0,0,994,87,1,0,0,0,995, - 1000,3,94,47,0,996,1000,3,96,48,0,997,1000,3,92,46,0,998,1000,3,90,45, - 0,999,995,1,0,0,0,999,996,1,0,0,0,999,997,1,0,0,0,999,998,1,0,0,0,1000, - 89,1,0,0,0,1001,1019,5,81,0,0,1002,1003,5,140,0,0,1003,1004,5,91,0,0, - 1004,1005,5,140,0,0,1005,1007,5,82,0,0,1006,1008,5,140,0,0,1007,1006, - 1,0,0,0,1007,1008,1,0,0,0,1008,1009,1,0,0,0,1009,1011,5,2,0,0,1010,1012, - 5,140,0,0,1011,1010,1,0,0,0,1011,1012,1,0,0,0,1012,1013,1,0,0,0,1013, - 1015,3,52,26,0,1014,1016,5,140,0,0,1015,1014,1,0,0,0,1015,1016,1,0,0, - 0,1016,1017,1,0,0,0,1017,1018,5,3,0,0,1018,1020,1,0,0,0,1019,1002,1,0, - 0,0,1019,1020,1,0,0,0,1020,1021,1,0,0,0,1021,1022,5,140,0,0,1022,1023, - 5,52,0,0,1023,1024,5,140,0,0,1024,1038,3,20,10,0,1025,1027,5,140,0,0, - 1026,1025,1,0,0,0,1026,1027,1,0,0,0,1027,1028,1,0,0,0,1028,1030,5,2,0, - 0,1029,1031,5,140,0,0,1030,1029,1,0,0,0,1030,1031,1,0,0,0,1031,1032,1, - 0,0,0,1032,1034,3,22,11,0,1033,1035,5,140,0,0,1034,1033,1,0,0,0,1034, - 1035,1,0,0,0,1035,1036,1,0,0,0,1036,1037,5,3,0,0,1037,1039,1,0,0,0,1038, - 1026,1,0,0,0,1038,1039,1,0,0,0,1039,1044,1,0,0,0,1040,1042,5,140,0,0, - 1041,1040,1,0,0,0,1041,1042,1,0,0,0,1042,1043,1,0,0,0,1043,1045,3,128, - 64,0,1044,1041,1,0,0,0,1044,1045,1,0,0,0,1045,91,1,0,0,0,1046,1047,5, - 47,0,0,1047,1048,5,140,0,0,1048,1053,3,236,118,0,1049,1051,5,140,0,0, - 1050,1049,1,0,0,0,1050,1051,1,0,0,0,1051,1052,1,0,0,0,1052,1054,3,128, - 64,0,1053,1050,1,0,0,0,1053,1054,1,0,0,0,1054,93,1,0,0,0,1055,1056,5, - 83,0,0,1056,1058,5,140,0,0,1057,1055,1,0,0,0,1057,1058,1,0,0,0,1058,1059, - 1,0,0,0,1059,1061,5,84,0,0,1060,1062,5,140,0,0,1061,1060,1,0,0,0,1061, - 1062,1,0,0,0,1062,1063,1,0,0,0,1063,1068,3,130,65,0,1064,1066,5,140,0, - 0,1065,1064,1,0,0,0,1065,1066,1,0,0,0,1066,1067,1,0,0,0,1067,1069,3,128, - 64,0,1068,1065,1,0,0,0,1068,1069,1,0,0,0,1069,95,1,0,0,0,1070,1072,5, - 85,0,0,1071,1073,5,140,0,0,1072,1071,1,0,0,0,1072,1073,1,0,0,0,1073,1074, - 1,0,0,0,1074,1075,3,170,85,0,1075,1076,5,140,0,0,1076,1077,5,95,0,0,1077, - 1078,5,140,0,0,1078,1079,3,250,125,0,1079,97,1,0,0,0,1080,1082,5,86,0, - 0,1081,1083,5,140,0,0,1082,1081,1,0,0,0,1082,1083,1,0,0,0,1083,1084,1, - 0,0,0,1084,1085,3,130,65,0,1085,99,1,0,0,0,1086,1088,5,87,0,0,1087,1089, - 5,140,0,0,1088,1087,1,0,0,0,1088,1089,1,0,0,0,1089,1090,1,0,0,0,1090, - 1095,3,130,65,0,1091,1092,5,140,0,0,1092,1094,3,102,51,0,1093,1091,1, - 0,0,0,1094,1097,1,0,0,0,1095,1093,1,0,0,0,1095,1096,1,0,0,0,1096,101, - 1,0,0,0,1097,1095,1,0,0,0,1098,1099,5,88,0,0,1099,1100,5,140,0,0,1100, - 1101,5,84,0,0,1101,1102,5,140,0,0,1102,1109,3,104,52,0,1103,1104,5,88, - 0,0,1104,1105,5,140,0,0,1105,1106,5,86,0,0,1106,1107,5,140,0,0,1107,1109, - 3,104,52,0,1108,1098,1,0,0,0,1108,1103,1,0,0,0,1109,103,1,0,0,0,1110, - 1112,5,89,0,0,1111,1113,5,140,0,0,1112,1111,1,0,0,0,1112,1113,1,0,0,0, - 1113,1114,1,0,0,0,1114,1125,3,106,53,0,1115,1117,5,140,0,0,1116,1115, - 1,0,0,0,1116,1117,1,0,0,0,1117,1118,1,0,0,0,1118,1120,5,4,0,0,1119,1121, - 5,140,0,0,1120,1119,1,0,0,0,1120,1121,1,0,0,0,1121,1122,1,0,0,0,1122, - 1124,3,106,53,0,1123,1116,1,0,0,0,1124,1127,1,0,0,0,1125,1123,1,0,0,0, - 1125,1126,1,0,0,0,1126,105,1,0,0,0,1127,1125,1,0,0,0,1128,1130,3,256, - 128,0,1129,1131,5,140,0,0,1130,1129,1,0,0,0,1130,1131,1,0,0,0,1131,1132, - 1,0,0,0,1132,1134,5,5,0,0,1133,1135,5,140,0,0,1134,1133,1,0,0,0,1134, - 1135,1,0,0,0,1135,1136,1,0,0,0,1136,1137,3,170,85,0,1137,107,1,0,0,0, - 1138,1140,5,90,0,0,1139,1141,5,140,0,0,1140,1139,1,0,0,0,1140,1141,1, - 0,0,0,1141,1142,1,0,0,0,1142,1153,3,170,85,0,1143,1145,5,140,0,0,1144, - 1143,1,0,0,0,1144,1145,1,0,0,0,1145,1146,1,0,0,0,1146,1148,5,4,0,0,1147, - 1149,5,140,0,0,1148,1147,1,0,0,0,1148,1149,1,0,0,0,1149,1150,1,0,0,0, - 1150,1152,3,170,85,0,1151,1144,1,0,0,0,1152,1155,1,0,0,0,1153,1151,1, - 0,0,0,1153,1154,1,0,0,0,1154,109,1,0,0,0,1155,1153,1,0,0,0,1156,1157, - 5,91,0,0,1157,1162,3,114,57,0,1158,1160,5,140,0,0,1159,1158,1,0,0,0,1159, - 1160,1,0,0,0,1160,1161,1,0,0,0,1161,1163,3,128,64,0,1162,1159,1,0,0,0, - 1162,1163,1,0,0,0,1163,111,1,0,0,0,1164,1165,5,92,0,0,1165,1166,3,114, - 57,0,1166,113,1,0,0,0,1167,1169,5,140,0,0,1168,1167,1,0,0,0,1168,1169, - 1,0,0,0,1169,1170,1,0,0,0,1170,1172,5,93,0,0,1171,1168,1,0,0,0,1171,1172, - 1,0,0,0,1172,1173,1,0,0,0,1173,1174,5,140,0,0,1174,1177,3,116,58,0,1175, - 1176,5,140,0,0,1176,1178,3,120,60,0,1177,1175,1,0,0,0,1177,1178,1,0,0, - 0,1178,1181,1,0,0,0,1179,1180,5,140,0,0,1180,1182,3,122,61,0,1181,1179, - 1,0,0,0,1181,1182,1,0,0,0,1182,1185,1,0,0,0,1183,1184,5,140,0,0,1184, - 1186,3,124,62,0,1185,1183,1,0,0,0,1185,1186,1,0,0,0,1186,115,1,0,0,0, - 1187,1198,5,94,0,0,1188,1190,5,140,0,0,1189,1188,1,0,0,0,1189,1190,1, - 0,0,0,1190,1191,1,0,0,0,1191,1193,5,4,0,0,1192,1194,5,140,0,0,1193,1192, - 1,0,0,0,1193,1194,1,0,0,0,1194,1195,1,0,0,0,1195,1197,3,118,59,0,1196, - 1189,1,0,0,0,1197,1200,1,0,0,0,1198,1196,1,0,0,0,1198,1199,1,0,0,0,1199, - 1216,1,0,0,0,1200,1198,1,0,0,0,1201,1212,3,118,59,0,1202,1204,5,140,0, - 0,1203,1202,1,0,0,0,1203,1204,1,0,0,0,1204,1205,1,0,0,0,1205,1207,5,4, - 0,0,1206,1208,5,140,0,0,1207,1206,1,0,0,0,1207,1208,1,0,0,0,1208,1209, - 1,0,0,0,1209,1211,3,118,59,0,1210,1203,1,0,0,0,1211,1214,1,0,0,0,1212, - 1210,1,0,0,0,1212,1213,1,0,0,0,1213,1216,1,0,0,0,1214,1212,1,0,0,0,1215, - 1187,1,0,0,0,1215,1201,1,0,0,0,1216,117,1,0,0,0,1217,1218,3,170,85,0, - 1218,1219,5,140,0,0,1219,1220,5,95,0,0,1220,1221,5,140,0,0,1221,1222, - 3,250,125,0,1222,1225,1,0,0,0,1223,1225,3,170,85,0,1224,1217,1,0,0,0, - 1224,1223,1,0,0,0,1225,119,1,0,0,0,1226,1227,5,96,0,0,1227,1228,5,140, - 0,0,1228,1229,5,97,0,0,1229,1230,5,140,0,0,1230,1238,3,126,63,0,1231, - 1233,5,4,0,0,1232,1234,5,140,0,0,1233,1232,1,0,0,0,1233,1234,1,0,0,0, - 1234,1235,1,0,0,0,1235,1237,3,126,63,0,1236,1231,1,0,0,0,1237,1240,1, - 0,0,0,1238,1236,1,0,0,0,1238,1239,1,0,0,0,1239,121,1,0,0,0,1240,1238, - 1,0,0,0,1241,1242,5,98,0,0,1242,1243,5,140,0,0,1243,1244,3,170,85,0,1244, - 123,1,0,0,0,1245,1246,5,99,0,0,1246,1247,5,140,0,0,1247,1248,3,170,85, - 0,1248,125,1,0,0,0,1249,1254,3,170,85,0,1250,1252,5,140,0,0,1251,1250, - 1,0,0,0,1251,1252,1,0,0,0,1252,1253,1,0,0,0,1253,1255,7,0,0,0,1254,1251, - 1,0,0,0,1254,1255,1,0,0,0,1255,127,1,0,0,0,1256,1257,5,104,0,0,1257,1258, - 5,140,0,0,1258,1259,3,170,85,0,1259,129,1,0,0,0,1260,1271,3,132,66,0, - 1261,1263,5,140,0,0,1262,1261,1,0,0,0,1262,1263,1,0,0,0,1263,1264,1,0, - 0,0,1264,1266,5,4,0,0,1265,1267,5,140,0,0,1266,1265,1,0,0,0,1266,1267, - 1,0,0,0,1267,1268,1,0,0,0,1268,1270,3,132,66,0,1269,1262,1,0,0,0,1270, - 1273,1,0,0,0,1271,1269,1,0,0,0,1271,1272,1,0,0,0,1272,131,1,0,0,0,1273, - 1271,1,0,0,0,1274,1276,3,250,125,0,1275,1277,5,140,0,0,1276,1275,1,0, - 0,0,1276,1277,1,0,0,0,1277,1278,1,0,0,0,1278,1280,5,5,0,0,1279,1281,5, - 140,0,0,1280,1279,1,0,0,0,1280,1281,1,0,0,0,1281,1282,1,0,0,0,1282,1283, - 3,134,67,0,1283,1286,1,0,0,0,1284,1286,3,134,67,0,1285,1274,1,0,0,0,1285, - 1284,1,0,0,0,1286,133,1,0,0,0,1287,1288,3,136,68,0,1288,135,1,0,0,0,1289, - 1296,3,138,69,0,1290,1292,5,140,0,0,1291,1290,1,0,0,0,1291,1292,1,0,0, - 0,1292,1293,1,0,0,0,1293,1295,3,140,70,0,1294,1291,1,0,0,0,1295,1298, - 1,0,0,0,1296,1294,1,0,0,0,1296,1297,1,0,0,0,1297,1304,1,0,0,0,1298,1296, - 1,0,0,0,1299,1300,5,2,0,0,1300,1301,3,136,68,0,1301,1302,5,3,0,0,1302, - 1304,1,0,0,0,1303,1289,1,0,0,0,1303,1299,1,0,0,0,1304,137,1,0,0,0,1305, - 1307,5,2,0,0,1306,1308,5,140,0,0,1307,1306,1,0,0,0,1307,1308,1,0,0,0, - 1308,1313,1,0,0,0,1309,1311,3,250,125,0,1310,1312,5,140,0,0,1311,1310, - 1,0,0,0,1311,1312,1,0,0,0,1312,1314,1,0,0,0,1313,1309,1,0,0,0,1313,1314, - 1,0,0,0,1314,1319,1,0,0,0,1315,1317,3,150,75,0,1316,1318,5,140,0,0,1317, - 1316,1,0,0,0,1317,1318,1,0,0,0,1318,1320,1,0,0,0,1319,1315,1,0,0,0,1319, - 1320,1,0,0,0,1320,1325,1,0,0,0,1321,1323,3,146,73,0,1322,1324,5,140,0, - 0,1323,1322,1,0,0,0,1323,1324,1,0,0,0,1324,1326,1,0,0,0,1325,1321,1,0, - 0,0,1325,1326,1,0,0,0,1326,1327,1,0,0,0,1327,1328,5,3,0,0,1328,139,1, - 0,0,0,1329,1331,3,142,71,0,1330,1332,5,140,0,0,1331,1330,1,0,0,0,1331, - 1332,1,0,0,0,1332,1333,1,0,0,0,1333,1334,3,138,69,0,1334,141,1,0,0,0, - 1335,1337,3,270,135,0,1336,1338,5,140,0,0,1337,1336,1,0,0,0,1337,1338, - 1,0,0,0,1338,1339,1,0,0,0,1339,1341,3,274,137,0,1340,1342,5,140,0,0,1341, - 1340,1,0,0,0,1341,1342,1,0,0,0,1342,1344,1,0,0,0,1343,1345,3,144,72,0, - 1344,1343,1,0,0,0,1344,1345,1,0,0,0,1345,1347,1,0,0,0,1346,1348,5,140, - 0,0,1347,1346,1,0,0,0,1347,1348,1,0,0,0,1348,1349,1,0,0,0,1349,1350,3, - 274,137,0,1350,1380,1,0,0,0,1351,1353,3,274,137,0,1352,1354,5,140,0,0, - 1353,1352,1,0,0,0,1353,1354,1,0,0,0,1354,1356,1,0,0,0,1355,1357,3,144, - 72,0,1356,1355,1,0,0,0,1356,1357,1,0,0,0,1357,1359,1,0,0,0,1358,1360, - 5,140,0,0,1359,1358,1,0,0,0,1359,1360,1,0,0,0,1360,1361,1,0,0,0,1361, - 1363,3,274,137,0,1362,1364,5,140,0,0,1363,1362,1,0,0,0,1363,1364,1,0, - 0,0,1364,1365,1,0,0,0,1365,1366,3,272,136,0,1366,1380,1,0,0,0,1367,1369, - 3,274,137,0,1368,1370,5,140,0,0,1369,1368,1,0,0,0,1369,1370,1,0,0,0,1370, - 1372,1,0,0,0,1371,1373,3,144,72,0,1372,1371,1,0,0,0,1372,1373,1,0,0,0, - 1373,1375,1,0,0,0,1374,1376,5,140,0,0,1375,1374,1,0,0,0,1375,1376,1,0, - 0,0,1376,1377,1,0,0,0,1377,1378,3,274,137,0,1378,1380,1,0,0,0,1379,1335, - 1,0,0,0,1379,1351,1,0,0,0,1379,1367,1,0,0,0,1380,143,1,0,0,0,1381,1383, - 5,7,0,0,1382,1384,5,140,0,0,1383,1382,1,0,0,0,1383,1384,1,0,0,0,1384, - 1389,1,0,0,0,1385,1387,3,250,125,0,1386,1388,5,140,0,0,1387,1386,1,0, - 0,0,1387,1388,1,0,0,0,1388,1390,1,0,0,0,1389,1385,1,0,0,0,1389,1390,1, - 0,0,0,1390,1395,1,0,0,0,1391,1393,3,148,74,0,1392,1394,5,140,0,0,1393, - 1392,1,0,0,0,1393,1394,1,0,0,0,1394,1396,1,0,0,0,1395,1391,1,0,0,0,1395, - 1396,1,0,0,0,1396,1401,1,0,0,0,1397,1399,3,154,77,0,1398,1400,5,140,0, - 0,1399,1398,1,0,0,0,1399,1400,1,0,0,0,1400,1402,1,0,0,0,1401,1397,1,0, - 0,0,1401,1402,1,0,0,0,1402,1407,1,0,0,0,1403,1405,3,146,73,0,1404,1406, - 5,140,0,0,1405,1404,1,0,0,0,1405,1406,1,0,0,0,1406,1408,1,0,0,0,1407, - 1403,1,0,0,0,1407,1408,1,0,0,0,1408,1409,1,0,0,0,1409,1410,5,8,0,0,1410, - 145,1,0,0,0,1411,1413,5,9,0,0,1412,1414,5,140,0,0,1413,1412,1,0,0,0,1413, - 1414,1,0,0,0,1414,1448,1,0,0,0,1415,1417,3,258,129,0,1416,1418,5,140, - 0,0,1417,1416,1,0,0,0,1417,1418,1,0,0,0,1418,1419,1,0,0,0,1419,1421,5, - 6,0,0,1420,1422,5,140,0,0,1421,1420,1,0,0,0,1421,1422,1,0,0,0,1422,1423, - 1,0,0,0,1423,1425,3,170,85,0,1424,1426,5,140,0,0,1425,1424,1,0,0,0,1425, - 1426,1,0,0,0,1426,1445,1,0,0,0,1427,1429,5,4,0,0,1428,1430,5,140,0,0, - 1429,1428,1,0,0,0,1429,1430,1,0,0,0,1430,1431,1,0,0,0,1431,1433,3,258, - 129,0,1432,1434,5,140,0,0,1433,1432,1,0,0,0,1433,1434,1,0,0,0,1434,1435, - 1,0,0,0,1435,1437,5,6,0,0,1436,1438,5,140,0,0,1437,1436,1,0,0,0,1437, - 1438,1,0,0,0,1438,1439,1,0,0,0,1439,1441,3,170,85,0,1440,1442,5,140,0, - 0,1441,1440,1,0,0,0,1441,1442,1,0,0,0,1442,1444,1,0,0,0,1443,1427,1,0, - 0,0,1444,1447,1,0,0,0,1445,1443,1,0,0,0,1445,1446,1,0,0,0,1446,1449,1, - 0,0,0,1447,1445,1,0,0,0,1448,1415,1,0,0,0,1448,1449,1,0,0,0,1449,1450, - 1,0,0,0,1450,1451,5,10,0,0,1451,147,1,0,0,0,1452,1454,5,6,0,0,1453,1455, - 5,140,0,0,1454,1453,1,0,0,0,1454,1455,1,0,0,0,1455,1456,1,0,0,0,1456, - 1470,3,168,84,0,1457,1459,5,140,0,0,1458,1457,1,0,0,0,1458,1459,1,0,0, - 0,1459,1460,1,0,0,0,1460,1462,5,11,0,0,1461,1463,5,6,0,0,1462,1461,1, - 0,0,0,1462,1463,1,0,0,0,1463,1465,1,0,0,0,1464,1466,5,140,0,0,1465,1464, - 1,0,0,0,1465,1466,1,0,0,0,1466,1467,1,0,0,0,1467,1469,3,168,84,0,1468, - 1458,1,0,0,0,1469,1472,1,0,0,0,1470,1468,1,0,0,0,1470,1471,1,0,0,0,1471, - 149,1,0,0,0,1472,1470,1,0,0,0,1473,1480,3,152,76,0,1474,1476,5,140,0, - 0,1475,1474,1,0,0,0,1475,1476,1,0,0,0,1476,1477,1,0,0,0,1477,1479,3,152, - 76,0,1478,1475,1,0,0,0,1479,1482,1,0,0,0,1480,1478,1,0,0,0,1480,1481, - 1,0,0,0,1481,151,1,0,0,0,1482,1480,1,0,0,0,1483,1485,5,6,0,0,1484,1486, - 5,140,0,0,1485,1484,1,0,0,0,1485,1486,1,0,0,0,1486,1487,1,0,0,0,1487, - 1488,3,166,83,0,1488,153,1,0,0,0,1489,1491,5,94,0,0,1490,1492,5,140,0, - 0,1491,1490,1,0,0,0,1491,1492,1,0,0,0,1492,1497,1,0,0,0,1493,1498,5,105, - 0,0,1494,1495,5,80,0,0,1495,1496,5,140,0,0,1496,1498,5,105,0,0,1497,1493, - 1,0,0,0,1497,1494,1,0,0,0,1497,1498,1,0,0,0,1498,1500,1,0,0,0,1499,1501, - 5,140,0,0,1500,1499,1,0,0,0,1500,1501,1,0,0,0,1501,1516,1,0,0,0,1502, - 1504,3,162,81,0,1503,1502,1,0,0,0,1503,1504,1,0,0,0,1504,1506,1,0,0,0, - 1505,1507,5,140,0,0,1506,1505,1,0,0,0,1506,1507,1,0,0,0,1507,1508,1,0, - 0,0,1508,1510,5,12,0,0,1509,1511,5,140,0,0,1510,1509,1,0,0,0,1510,1511, - 1,0,0,0,1511,1513,1,0,0,0,1512,1514,3,164,82,0,1513,1512,1,0,0,0,1513, - 1514,1,0,0,0,1514,1517,1,0,0,0,1515,1517,3,260,130,0,1516,1503,1,0,0, - 0,1516,1515,1,0,0,0,1516,1517,1,0,0,0,1517,1522,1,0,0,0,1518,1520,5,140, - 0,0,1519,1518,1,0,0,0,1519,1520,1,0,0,0,1520,1521,1,0,0,0,1521,1523,3, - 156,78,0,1522,1519,1,0,0,0,1522,1523,1,0,0,0,1523,155,1,0,0,0,1524,1526, - 5,2,0,0,1525,1527,5,140,0,0,1526,1525,1,0,0,0,1526,1527,1,0,0,0,1527, - 1528,1,0,0,0,1528,1530,3,250,125,0,1529,1531,5,140,0,0,1530,1529,1,0, - 0,0,1530,1531,1,0,0,0,1531,1532,1,0,0,0,1532,1534,5,4,0,0,1533,1535,5, - 140,0,0,1534,1533,1,0,0,0,1534,1535,1,0,0,0,1535,1536,1,0,0,0,1536,1545, - 3,250,125,0,1537,1539,5,140,0,0,1538,1537,1,0,0,0,1538,1539,1,0,0,0,1539, - 1540,1,0,0,0,1540,1542,5,11,0,0,1541,1543,5,140,0,0,1542,1541,1,0,0,0, - 1542,1543,1,0,0,0,1543,1544,1,0,0,0,1544,1546,3,128,64,0,1545,1538,1, - 0,0,0,1545,1546,1,0,0,0,1546,1566,1,0,0,0,1547,1549,5,140,0,0,1548,1547, - 1,0,0,0,1548,1549,1,0,0,0,1549,1550,1,0,0,0,1550,1552,5,11,0,0,1551,1553, - 5,140,0,0,1552,1551,1,0,0,0,1552,1553,1,0,0,0,1553,1554,1,0,0,0,1554, - 1556,3,160,80,0,1555,1557,5,140,0,0,1556,1555,1,0,0,0,1556,1557,1,0,0, - 0,1557,1558,1,0,0,0,1558,1560,5,4,0,0,1559,1561,5,140,0,0,1560,1559,1, - 0,0,0,1560,1561,1,0,0,0,1561,1562,1,0,0,0,1562,1564,3,158,79,0,1563,1565, - 5,140,0,0,1564,1563,1,0,0,0,1564,1565,1,0,0,0,1565,1567,1,0,0,0,1566, - 1548,1,0,0,0,1566,1567,1,0,0,0,1567,1568,1,0,0,0,1568,1569,5,3,0,0,1569, - 157,1,0,0,0,1570,1572,5,9,0,0,1571,1573,5,140,0,0,1572,1571,1,0,0,0,1572, - 1573,1,0,0,0,1573,1575,1,0,0,0,1574,1576,3,116,58,0,1575,1574,1,0,0,0, - 1575,1576,1,0,0,0,1576,1578,1,0,0,0,1577,1579,5,140,0,0,1578,1577,1,0, - 0,0,1578,1579,1,0,0,0,1579,1580,1,0,0,0,1580,1581,5,10,0,0,1581,159,1, - 0,0,0,1582,1584,5,9,0,0,1583,1585,5,140,0,0,1584,1583,1,0,0,0,1584,1585, - 1,0,0,0,1585,1587,1,0,0,0,1586,1588,3,116,58,0,1587,1586,1,0,0,0,1587, - 1588,1,0,0,0,1588,1590,1,0,0,0,1589,1591,5,140,0,0,1590,1589,1,0,0,0, - 1590,1591,1,0,0,0,1591,1592,1,0,0,0,1592,1593,5,10,0,0,1593,161,1,0,0, - 0,1594,1595,5,128,0,0,1595,163,1,0,0,0,1596,1597,5,128,0,0,1597,165,1, - 0,0,0,1598,1599,3,264,132,0,1599,167,1,0,0,0,1600,1601,3,264,132,0,1601, - 169,1,0,0,0,1602,1603,3,172,86,0,1603,171,1,0,0,0,1604,1611,3,174,87, - 0,1605,1606,5,140,0,0,1606,1607,5,106,0,0,1607,1608,5,140,0,0,1608,1610, - 3,174,87,0,1609,1605,1,0,0,0,1610,1613,1,0,0,0,1611,1609,1,0,0,0,1611, - 1612,1,0,0,0,1612,173,1,0,0,0,1613,1611,1,0,0,0,1614,1621,3,176,88,0, - 1615,1616,5,140,0,0,1616,1617,5,107,0,0,1617,1618,5,140,0,0,1618,1620, - 3,176,88,0,1619,1615,1,0,0,0,1620,1623,1,0,0,0,1621,1619,1,0,0,0,1621, - 1622,1,0,0,0,1622,175,1,0,0,0,1623,1621,1,0,0,0,1624,1631,3,178,89,0, - 1625,1626,5,140,0,0,1626,1627,5,108,0,0,1627,1628,5,140,0,0,1628,1630, - 3,178,89,0,1629,1625,1,0,0,0,1630,1633,1,0,0,0,1631,1629,1,0,0,0,1631, - 1632,1,0,0,0,1632,177,1,0,0,0,1633,1631,1,0,0,0,1634,1636,5,109,0,0,1635, - 1637,5,140,0,0,1636,1635,1,0,0,0,1636,1637,1,0,0,0,1637,1639,1,0,0,0, - 1638,1634,1,0,0,0,1638,1639,1,0,0,0,1639,1640,1,0,0,0,1640,1641,3,180, - 90,0,1641,179,1,0,0,0,1642,1652,3,184,92,0,1643,1645,5,140,0,0,1644,1643, - 1,0,0,0,1644,1645,1,0,0,0,1645,1646,1,0,0,0,1646,1648,3,182,91,0,1647, - 1649,5,140,0,0,1648,1647,1,0,0,0,1648,1649,1,0,0,0,1649,1650,1,0,0,0, - 1650,1651,3,184,92,0,1651,1653,1,0,0,0,1652,1644,1,0,0,0,1652,1653,1, - 0,0,0,1653,1691,1,0,0,0,1654,1656,3,184,92,0,1655,1657,5,140,0,0,1656, - 1655,1,0,0,0,1656,1657,1,0,0,0,1657,1658,1,0,0,0,1658,1660,5,110,0,0, - 1659,1661,5,140,0,0,1660,1659,1,0,0,0,1660,1661,1,0,0,0,1661,1662,1,0, - 0,0,1662,1663,3,184,92,0,1663,1664,1,0,0,0,1664,1665,6,90,-1,0,1665,1691, - 1,0,0,0,1666,1668,3,184,92,0,1667,1669,5,140,0,0,1668,1667,1,0,0,0,1668, - 1669,1,0,0,0,1669,1670,1,0,0,0,1670,1672,3,182,91,0,1671,1673,5,140,0, - 0,1672,1671,1,0,0,0,1672,1673,1,0,0,0,1673,1674,1,0,0,0,1674,1684,3,184, - 92,0,1675,1677,5,140,0,0,1676,1675,1,0,0,0,1676,1677,1,0,0,0,1677,1678, - 1,0,0,0,1678,1680,3,182,91,0,1679,1681,5,140,0,0,1680,1679,1,0,0,0,1680, - 1681,1,0,0,0,1681,1682,1,0,0,0,1682,1683,3,184,92,0,1683,1685,1,0,0,0, - 1684,1676,1,0,0,0,1685,1686,1,0,0,0,1686,1684,1,0,0,0,1686,1687,1,0,0, - 0,1687,1688,1,0,0,0,1688,1689,6,90,-1,0,1689,1691,1,0,0,0,1690,1642,1, - 0,0,0,1690,1654,1,0,0,0,1690,1666,1,0,0,0,1691,181,1,0,0,0,1692,1693, - 7,1,0,0,1693,183,1,0,0,0,1694,1705,3,186,93,0,1695,1697,5,140,0,0,1696, - 1695,1,0,0,0,1696,1697,1,0,0,0,1697,1698,1,0,0,0,1698,1700,5,11,0,0,1699, - 1701,5,140,0,0,1700,1699,1,0,0,0,1700,1701,1,0,0,0,1701,1702,1,0,0,0, - 1702,1704,3,186,93,0,1703,1696,1,0,0,0,1704,1707,1,0,0,0,1705,1703,1, - 0,0,0,1705,1706,1,0,0,0,1706,185,1,0,0,0,1707,1705,1,0,0,0,1708,1719, - 3,188,94,0,1709,1711,5,140,0,0,1710,1709,1,0,0,0,1710,1711,1,0,0,0,1711, - 1712,1,0,0,0,1712,1714,5,18,0,0,1713,1715,5,140,0,0,1714,1713,1,0,0,0, - 1714,1715,1,0,0,0,1715,1716,1,0,0,0,1716,1718,3,188,94,0,1717,1710,1, - 0,0,0,1718,1721,1,0,0,0,1719,1717,1,0,0,0,1719,1720,1,0,0,0,1720,187, - 1,0,0,0,1721,1719,1,0,0,0,1722,1734,3,192,96,0,1723,1725,5,140,0,0,1724, - 1723,1,0,0,0,1724,1725,1,0,0,0,1725,1726,1,0,0,0,1726,1728,3,190,95,0, - 1727,1729,5,140,0,0,1728,1727,1,0,0,0,1728,1729,1,0,0,0,1729,1730,1,0, - 0,0,1730,1731,3,192,96,0,1731,1733,1,0,0,0,1732,1724,1,0,0,0,1733,1736, - 1,0,0,0,1734,1732,1,0,0,0,1734,1735,1,0,0,0,1735,189,1,0,0,0,1736,1734, - 1,0,0,0,1737,1738,7,2,0,0,1738,191,1,0,0,0,1739,1751,3,196,98,0,1740, - 1742,5,140,0,0,1741,1740,1,0,0,0,1741,1742,1,0,0,0,1742,1743,1,0,0,0, - 1743,1745,3,194,97,0,1744,1746,5,140,0,0,1745,1744,1,0,0,0,1745,1746, - 1,0,0,0,1746,1747,1,0,0,0,1747,1748,3,196,98,0,1748,1750,1,0,0,0,1749, - 1741,1,0,0,0,1750,1753,1,0,0,0,1751,1749,1,0,0,0,1751,1752,1,0,0,0,1752, - 193,1,0,0,0,1753,1751,1,0,0,0,1754,1755,7,3,0,0,1755,195,1,0,0,0,1756, - 1768,3,200,100,0,1757,1759,5,140,0,0,1758,1757,1,0,0,0,1758,1759,1,0, - 0,0,1759,1760,1,0,0,0,1760,1762,3,198,99,0,1761,1763,5,140,0,0,1762,1761, - 1,0,0,0,1762,1763,1,0,0,0,1763,1764,1,0,0,0,1764,1765,3,200,100,0,1765, - 1767,1,0,0,0,1766,1758,1,0,0,0,1767,1770,1,0,0,0,1768,1766,1,0,0,0,1768, - 1769,1,0,0,0,1769,197,1,0,0,0,1770,1768,1,0,0,0,1771,1772,7,4,0,0,1772, - 199,1,0,0,0,1773,1784,3,202,101,0,1774,1776,5,140,0,0,1775,1774,1,0,0, - 0,1775,1776,1,0,0,0,1776,1777,1,0,0,0,1777,1779,5,24,0,0,1778,1780,5, - 140,0,0,1779,1778,1,0,0,0,1779,1780,1,0,0,0,1780,1781,1,0,0,0,1781,1783, - 3,202,101,0,1782,1775,1,0,0,0,1783,1786,1,0,0,0,1784,1782,1,0,0,0,1784, - 1785,1,0,0,0,1785,201,1,0,0,0,1786,1784,1,0,0,0,1787,1789,5,111,0,0,1788, - 1790,5,140,0,0,1789,1788,1,0,0,0,1789,1790,1,0,0,0,1790,1792,1,0,0,0, - 1791,1787,1,0,0,0,1791,1792,1,0,0,0,1792,1793,1,0,0,0,1793,1798,3,204, - 102,0,1794,1796,5,140,0,0,1795,1794,1,0,0,0,1795,1796,1,0,0,0,1796,1797, - 1,0,0,0,1797,1799,5,112,0,0,1798,1795,1,0,0,0,1798,1799,1,0,0,0,1799, - 203,1,0,0,0,1800,1808,3,218,109,0,1801,1809,3,212,106,0,1802,1804,3,206, - 103,0,1803,1802,1,0,0,0,1804,1805,1,0,0,0,1805,1803,1,0,0,0,1805,1806, - 1,0,0,0,1806,1809,1,0,0,0,1807,1809,3,216,108,0,1808,1801,1,0,0,0,1808, - 1803,1,0,0,0,1808,1807,1,0,0,0,1808,1809,1,0,0,0,1809,205,1,0,0,0,1810, - 1813,3,208,104,0,1811,1813,3,210,105,0,1812,1810,1,0,0,0,1812,1811,1, - 0,0,0,1813,207,1,0,0,0,1814,1815,5,7,0,0,1815,1816,3,170,85,0,1816,1817, - 5,8,0,0,1817,209,1,0,0,0,1818,1820,5,7,0,0,1819,1821,3,170,85,0,1820, - 1819,1,0,0,0,1820,1821,1,0,0,0,1821,1822,1,0,0,0,1822,1824,5,6,0,0,1823, - 1825,3,170,85,0,1824,1823,1,0,0,0,1824,1825,1,0,0,0,1825,1826,1,0,0,0, - 1826,1827,5,8,0,0,1827,211,1,0,0,0,1828,1840,3,214,107,0,1829,1830,5, - 140,0,0,1830,1831,5,113,0,0,1831,1832,5,140,0,0,1832,1840,5,91,0,0,1833, - 1834,5,140,0,0,1834,1835,5,114,0,0,1835,1836,5,140,0,0,1836,1840,5,91, - 0,0,1837,1838,5,140,0,0,1838,1840,5,115,0,0,1839,1828,1,0,0,0,1839,1829, - 1,0,0,0,1839,1833,1,0,0,0,1839,1837,1,0,0,0,1840,1842,1,0,0,0,1841,1843, - 5,140,0,0,1842,1841,1,0,0,0,1842,1843,1,0,0,0,1843,1844,1,0,0,0,1844, - 1845,3,218,109,0,1845,213,1,0,0,0,1846,1848,5,140,0,0,1847,1846,1,0,0, - 0,1847,1848,1,0,0,0,1848,1849,1,0,0,0,1849,1850,5,25,0,0,1850,215,1,0, - 0,0,1851,1852,5,140,0,0,1852,1853,5,116,0,0,1853,1854,5,140,0,0,1854, - 1862,5,117,0,0,1855,1856,5,140,0,0,1856,1857,5,116,0,0,1857,1858,5,140, - 0,0,1858,1859,5,109,0,0,1859,1860,5,140,0,0,1860,1862,5,117,0,0,1861, - 1851,1,0,0,0,1861,1855,1,0,0,0,1862,217,1,0,0,0,1863,1870,3,220,110,0, - 1864,1866,5,140,0,0,1865,1864,1,0,0,0,1865,1866,1,0,0,0,1866,1867,1,0, - 0,0,1867,1869,3,244,122,0,1868,1865,1,0,0,0,1869,1872,1,0,0,0,1870,1868, - 1,0,0,0,1870,1871,1,0,0,0,1871,219,1,0,0,0,1872,1870,1,0,0,0,1873,1881, - 3,222,111,0,1874,1881,3,254,127,0,1875,1881,3,246,123,0,1876,1881,3,234, - 117,0,1877,1881,3,236,118,0,1878,1881,3,242,121,0,1879,1881,3,250,125, - 0,1880,1873,1,0,0,0,1880,1874,1,0,0,0,1880,1875,1,0,0,0,1880,1876,1,0, - 0,0,1880,1877,1,0,0,0,1880,1878,1,0,0,0,1880,1879,1,0,0,0,1881,221,1, - 0,0,0,1882,1889,3,252,126,0,1883,1889,5,126,0,0,1884,1889,3,224,112,0, - 1885,1889,5,117,0,0,1886,1889,3,226,113,0,1887,1889,3,230,115,0,1888, - 1882,1,0,0,0,1888,1883,1,0,0,0,1888,1884,1,0,0,0,1888,1885,1,0,0,0,1888, - 1886,1,0,0,0,1888,1887,1,0,0,0,1889,223,1,0,0,0,1890,1891,7,5,0,0,1891, - 225,1,0,0,0,1892,1894,5,7,0,0,1893,1895,5,140,0,0,1894,1893,1,0,0,0,1894, - 1895,1,0,0,0,1895,1909,1,0,0,0,1896,1898,3,170,85,0,1897,1899,5,140,0, - 0,1898,1897,1,0,0,0,1898,1899,1,0,0,0,1899,1906,1,0,0,0,1900,1902,3,228, - 114,0,1901,1903,5,140,0,0,1902,1901,1,0,0,0,1902,1903,1,0,0,0,1903,1905, - 1,0,0,0,1904,1900,1,0,0,0,1905,1908,1,0,0,0,1906,1904,1,0,0,0,1906,1907, - 1,0,0,0,1907,1910,1,0,0,0,1908,1906,1,0,0,0,1909,1896,1,0,0,0,1909,1910, - 1,0,0,0,1910,1911,1,0,0,0,1911,1912,5,8,0,0,1912,227,1,0,0,0,1913,1915, - 5,4,0,0,1914,1916,5,140,0,0,1915,1914,1,0,0,0,1915,1916,1,0,0,0,1916, - 1918,1,0,0,0,1917,1919,3,170,85,0,1918,1917,1,0,0,0,1918,1919,1,0,0,0, - 1919,229,1,0,0,0,1920,1922,5,9,0,0,1921,1923,5,140,0,0,1922,1921,1,0, - 0,0,1922,1923,1,0,0,0,1923,1924,1,0,0,0,1924,1926,3,232,116,0,1925,1927, - 5,140,0,0,1926,1925,1,0,0,0,1926,1927,1,0,0,0,1927,1938,1,0,0,0,1928, - 1930,5,4,0,0,1929,1931,5,140,0,0,1930,1929,1,0,0,0,1930,1931,1,0,0,0, - 1931,1932,1,0,0,0,1932,1934,3,232,116,0,1933,1935,5,140,0,0,1934,1933, - 1,0,0,0,1934,1935,1,0,0,0,1935,1937,1,0,0,0,1936,1928,1,0,0,0,1937,1940, - 1,0,0,0,1938,1936,1,0,0,0,1938,1939,1,0,0,0,1939,1941,1,0,0,0,1940,1938, - 1,0,0,0,1941,1942,5,10,0,0,1942,231,1,0,0,0,1943,1946,3,266,133,0,1944, - 1946,5,126,0,0,1945,1943,1,0,0,0,1945,1944,1,0,0,0,1946,1948,1,0,0,0, - 1947,1949,5,140,0,0,1948,1947,1,0,0,0,1948,1949,1,0,0,0,1949,1950,1,0, - 0,0,1950,1952,5,6,0,0,1951,1953,5,140,0,0,1952,1951,1,0,0,0,1952,1953, - 1,0,0,0,1953,1954,1,0,0,0,1954,1955,3,170,85,0,1955,233,1,0,0,0,1956, - 1958,5,2,0,0,1957,1959,5,140,0,0,1958,1957,1,0,0,0,1958,1959,1,0,0,0, - 1959,1960,1,0,0,0,1960,1962,3,170,85,0,1961,1963,5,140,0,0,1962,1961, - 1,0,0,0,1962,1963,1,0,0,0,1963,1964,1,0,0,0,1964,1965,5,3,0,0,1965,235, - 1,0,0,0,1966,1968,3,238,119,0,1967,1969,5,140,0,0,1968,1967,1,0,0,0,1968, - 1969,1,0,0,0,1969,1970,1,0,0,0,1970,1972,5,2,0,0,1971,1973,5,140,0,0, - 1972,1971,1,0,0,0,1972,1973,1,0,0,0,1973,1974,1,0,0,0,1974,1976,5,94, - 0,0,1975,1977,5,140,0,0,1976,1975,1,0,0,0,1976,1977,1,0,0,0,1977,1978, - 1,0,0,0,1978,1979,5,3,0,0,1979,2016,1,0,0,0,1980,1982,3,238,119,0,1981, - 1983,5,140,0,0,1982,1981,1,0,0,0,1982,1983,1,0,0,0,1983,1984,1,0,0,0, - 1984,1986,5,2,0,0,1985,1987,5,140,0,0,1986,1985,1,0,0,0,1986,1987,1,0, - 0,0,1987,1992,1,0,0,0,1988,1990,5,93,0,0,1989,1991,5,140,0,0,1990,1989, - 1,0,0,0,1990,1991,1,0,0,0,1991,1993,1,0,0,0,1992,1988,1,0,0,0,1992,1993, - 1,0,0,0,1993,2011,1,0,0,0,1994,1996,3,240,120,0,1995,1997,5,140,0,0,1996, - 1995,1,0,0,0,1996,1997,1,0,0,0,1997,2008,1,0,0,0,1998,2000,5,4,0,0,1999, - 2001,5,140,0,0,2000,1999,1,0,0,0,2000,2001,1,0,0,0,2001,2002,1,0,0,0, - 2002,2004,3,240,120,0,2003,2005,5,140,0,0,2004,2003,1,0,0,0,2004,2005, - 1,0,0,0,2005,2007,1,0,0,0,2006,1998,1,0,0,0,2007,2010,1,0,0,0,2008,2006, - 1,0,0,0,2008,2009,1,0,0,0,2009,2012,1,0,0,0,2010,2008,1,0,0,0,2011,1994, - 1,0,0,0,2011,2012,1,0,0,0,2012,2013,1,0,0,0,2013,2014,5,3,0,0,2014,2016, - 1,0,0,0,2015,1966,1,0,0,0,2015,1980,1,0,0,0,2016,237,1,0,0,0,2017,2018, - 3,266,133,0,2018,239,1,0,0,0,2019,2021,3,266,133,0,2020,2022,5,140,0, - 0,2021,2020,1,0,0,0,2021,2022,1,0,0,0,2022,2023,1,0,0,0,2023,2024,5,6, - 0,0,2024,2026,5,5,0,0,2025,2027,5,140,0,0,2026,2025,1,0,0,0,2026,2027, - 1,0,0,0,2027,2029,1,0,0,0,2028,2019,1,0,0,0,2028,2029,1,0,0,0,2029,2030, - 1,0,0,0,2030,2031,3,170,85,0,2031,241,1,0,0,0,2032,2034,5,120,0,0,2033, - 2035,5,140,0,0,2034,2033,1,0,0,0,2034,2035,1,0,0,0,2035,2036,1,0,0,0, - 2036,2038,5,9,0,0,2037,2039,5,140,0,0,2038,2037,1,0,0,0,2038,2039,1,0, - 0,0,2039,2040,1,0,0,0,2040,2042,5,84,0,0,2041,2043,5,140,0,0,2042,2041, - 1,0,0,0,2042,2043,1,0,0,0,2043,2044,1,0,0,0,2044,2049,3,130,65,0,2045, - 2047,5,140,0,0,2046,2045,1,0,0,0,2046,2047,1,0,0,0,2047,2048,1,0,0,0, - 2048,2050,3,128,64,0,2049,2046,1,0,0,0,2049,2050,1,0,0,0,2050,2052,1, - 0,0,0,2051,2053,5,140,0,0,2052,2051,1,0,0,0,2052,2053,1,0,0,0,2053,2054, - 1,0,0,0,2054,2055,5,10,0,0,2055,243,1,0,0,0,2056,2058,5,26,0,0,2057,2059, - 5,140,0,0,2058,2057,1,0,0,0,2058,2059,1,0,0,0,2059,2062,1,0,0,0,2060, - 2063,3,258,129,0,2061,2063,5,94,0,0,2062,2060,1,0,0,0,2062,2061,1,0,0, - 0,2063,245,1,0,0,0,2064,2069,5,121,0,0,2065,2067,5,140,0,0,2066,2065, - 1,0,0,0,2066,2067,1,0,0,0,2067,2068,1,0,0,0,2068,2070,3,248,124,0,2069, - 2066,1,0,0,0,2070,2071,1,0,0,0,2071,2069,1,0,0,0,2071,2072,1,0,0,0,2072, - 2087,1,0,0,0,2073,2075,5,121,0,0,2074,2076,5,140,0,0,2075,2074,1,0,0, - 0,2075,2076,1,0,0,0,2076,2077,1,0,0,0,2077,2082,3,170,85,0,2078,2080, - 5,140,0,0,2079,2078,1,0,0,0,2079,2080,1,0,0,0,2080,2081,1,0,0,0,2081, - 2083,3,248,124,0,2082,2079,1,0,0,0,2083,2084,1,0,0,0,2084,2082,1,0,0, - 0,2084,2085,1,0,0,0,2085,2087,1,0,0,0,2086,2064,1,0,0,0,2086,2073,1,0, - 0,0,2087,2096,1,0,0,0,2088,2090,5,140,0,0,2089,2088,1,0,0,0,2089,2090, - 1,0,0,0,2090,2091,1,0,0,0,2091,2093,5,122,0,0,2092,2094,5,140,0,0,2093, - 2092,1,0,0,0,2093,2094,1,0,0,0,2094,2095,1,0,0,0,2095,2097,3,170,85,0, - 2096,2089,1,0,0,0,2096,2097,1,0,0,0,2097,2099,1,0,0,0,2098,2100,5,140, - 0,0,2099,2098,1,0,0,0,2099,2100,1,0,0,0,2100,2101,1,0,0,0,2101,2102,5, - 123,0,0,2102,247,1,0,0,0,2103,2105,5,124,0,0,2104,2106,5,140,0,0,2105, - 2104,1,0,0,0,2105,2106,1,0,0,0,2106,2107,1,0,0,0,2107,2109,3,170,85,0, - 2108,2110,5,140,0,0,2109,2108,1,0,0,0,2109,2110,1,0,0,0,2110,2111,1,0, - 0,0,2111,2113,5,125,0,0,2112,2114,5,140,0,0,2113,2112,1,0,0,0,2113,2114, - 1,0,0,0,2114,2115,1,0,0,0,2115,2116,3,170,85,0,2116,249,1,0,0,0,2117, - 2118,3,266,133,0,2118,251,1,0,0,0,2119,2122,3,262,131,0,2120,2122,3,260, - 130,0,2121,2119,1,0,0,0,2121,2120,1,0,0,0,2122,253,1,0,0,0,2123,2126, - 5,27,0,0,2124,2127,3,266,133,0,2125,2127,5,128,0,0,2126,2124,1,0,0,0, - 2126,2125,1,0,0,0,2127,255,1,0,0,0,2128,2130,3,220,110,0,2129,2131,5, - 140,0,0,2130,2129,1,0,0,0,2130,2131,1,0,0,0,2131,2132,1,0,0,0,2132,2133, - 3,244,122,0,2133,257,1,0,0,0,2134,2135,3,264,132,0,2135,259,1,0,0,0,2136, - 2137,5,128,0,0,2137,261,1,0,0,0,2138,2139,5,135,0,0,2139,263,1,0,0,0, - 2140,2141,3,266,133,0,2141,265,1,0,0,0,2142,2148,5,136,0,0,2143,2144, - 5,139,0,0,2144,2148,6,133,-1,0,2145,2148,5,129,0,0,2146,2148,3,268,134, - 0,2147,2142,1,0,0,0,2147,2143,1,0,0,0,2147,2145,1,0,0,0,2147,2146,1,0, - 0,0,2148,267,1,0,0,0,2149,2150,5,48,0,0,2150,269,1,0,0,0,2151,2152,7, - 6,0,0,2152,271,1,0,0,0,2153,2154,7,7,0,0,2154,273,1,0,0,0,2155,2156,7, - 8,0,0,2156,275,1,0,0,0,373,277,280,283,287,290,293,306,316,320,324,328, - 338,342,346,351,364,368,376,380,384,388,394,398,420,424,427,430,433,436, - 440,445,449,459,463,468,473,478,484,488,492,497,504,508,512,515,519,523, - 528,533,537,547,557,561,565,569,574,586,590,594,598,602,604,608,612,614, - 628,632,636,640,645,648,652,656,658,662,666,668,706,717,739,743,748,759, - 763,767,775,779,783,789,793,797,803,807,811,815,819,823,829,836,841,847, - 867,873,878,883,887,892,898,903,906,910,914,918,924,928,933,938,942,945, - 949,953,957,961,965,971,975,980,984,993,999,1007,1011,1015,1019,1026, - 1030,1034,1038,1041,1044,1050,1053,1057,1061,1065,1068,1072,1082,1088, - 1095,1108,1112,1116,1120,1125,1130,1134,1140,1144,1148,1153,1159,1162, - 1168,1171,1177,1181,1185,1189,1193,1198,1203,1207,1212,1215,1224,1233, - 1238,1251,1254,1262,1266,1271,1276,1280,1285,1291,1296,1303,1307,1311, - 1313,1317,1319,1323,1325,1331,1337,1341,1344,1347,1353,1356,1359,1363, - 1369,1372,1375,1379,1383,1387,1389,1393,1395,1399,1401,1405,1407,1413, - 1417,1421,1425,1429,1433,1437,1441,1445,1448,1454,1458,1462,1465,1470, - 1475,1480,1485,1491,1497,1500,1503,1506,1510,1513,1516,1519,1522,1526, - 1530,1534,1538,1542,1545,1548,1552,1556,1560,1564,1566,1572,1575,1578, - 1584,1587,1590,1611,1621,1631,1636,1638,1644,1648,1652,1656,1660,1668, - 1672,1676,1680,1686,1690,1696,1700,1705,1710,1714,1719,1724,1728,1734, - 1741,1745,1751,1758,1762,1768,1775,1779,1784,1789,1791,1795,1798,1805, - 1808,1812,1820,1824,1839,1842,1847,1861,1865,1870,1880,1888,1894,1898, - 1902,1906,1909,1915,1918,1922,1926,1930,1934,1938,1945,1948,1952,1958, - 1962,1968,1972,1976,1982,1986,1990,1992,1996,2000,2004,2008,2011,2015, - 2021,2026,2028,2034,2038,2042,2046,2049,2052,2058,2062,2066,2071,2075, - 2079,2084,2086,2089,2093,2096,2099,2105,2109,2113,2121,2126,2130,2147 + 7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,1,0,3,0,280,8,0, + 1,0,3,0,283,8,0,1,0,3,0,286,8,0,1,0,1,0,3,0,290,8,0,1,0,3,0,293,8,0,1, + 0,3,0,296,8,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,309,8,1, + 1,2,1,2,1,2,1,2,3,2,315,8,2,1,2,1,2,3,2,319,8,2,1,2,1,2,3,2,323,8,2,1, + 2,1,2,3,2,327,8,2,1,2,3,2,330,8,2,1,2,1,2,1,2,1,2,3,2,336,8,2,1,2,1,2, + 3,2,340,8,2,1,2,1,2,3,2,344,8,2,1,2,1,2,3,2,348,8,2,1,3,1,3,3,3,352,8, + 3,1,3,1,3,3,3,356,8,3,1,3,5,3,359,8,3,10,3,12,3,362,9,3,1,4,1,4,1,4,1, + 4,1,4,1,4,1,4,1,4,3,4,372,8,4,1,4,1,4,3,4,376,8,4,1,4,1,4,3,4,380,8,4, + 1,4,5,4,383,8,4,10,4,12,4,386,9,4,1,4,1,4,1,4,1,4,1,4,1,4,1,5,1,5,1,5, + 1,5,3,5,398,8,5,1,5,1,5,3,5,402,8,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,410,8, + 5,1,5,1,5,3,5,414,8,5,1,5,1,5,3,5,418,8,5,1,5,1,5,3,5,422,8,5,1,6,1,6, + 1,6,1,6,3,6,428,8,6,1,6,1,6,3,6,432,8,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1, + 7,1,7,1,7,1,7,1,7,1,7,1,7,1,8,1,8,1,8,1,8,1,8,1,8,3,8,454,8,8,1,8,1,8, + 3,8,458,8,8,1,8,3,8,461,8,8,1,8,3,8,464,8,8,1,8,3,8,467,8,8,1,8,3,8,470, + 8,8,1,8,1,8,3,8,474,8,8,1,8,5,8,477,8,8,10,8,12,8,480,9,8,1,8,3,8,483, + 8,8,1,8,1,8,1,8,1,8,1,8,1,8,1,9,1,9,3,9,493,8,9,1,9,1,9,3,9,497,8,9,1, + 9,5,9,500,8,9,10,9,12,9,503,9,9,1,10,1,10,3,10,507,8,10,1,10,1,10,1,10, + 3,10,512,8,10,1,10,1,10,1,11,1,11,3,11,518,8,11,1,11,1,11,3,11,522,8, + 11,1,11,1,11,3,11,526,8,11,1,11,5,11,529,8,11,10,11,12,11,532,9,11,1, + 11,1,11,1,11,1,11,3,11,538,8,11,1,11,1,11,3,11,542,8,11,1,11,1,11,3,11, + 546,8,11,1,11,3,11,549,8,11,1,12,1,12,3,12,553,8,12,1,12,1,12,3,12,557, + 8,12,1,12,5,12,560,8,12,10,12,12,12,563,9,12,1,13,1,13,3,13,567,8,13, + 1,13,1,13,3,13,571,8,13,1,13,1,13,1,14,1,14,1,14,1,14,1,14,1,14,3,14, + 581,8,14,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,591,8,15,1,15,1, + 15,3,15,595,8,15,1,15,1,15,3,15,599,8,15,1,15,1,15,3,15,603,8,15,1,15, + 1,15,1,15,3,15,608,8,15,1,15,1,15,1,16,1,16,1,16,1,16,1,16,1,16,1,16, + 1,16,3,16,620,8,16,1,16,1,16,3,16,624,8,16,1,16,1,16,3,16,628,8,16,1, + 16,1,16,3,16,632,8,16,1,16,1,16,3,16,636,8,16,3,16,638,8,16,1,16,1,16, + 3,16,642,8,16,1,16,1,16,3,16,646,8,16,3,16,648,8,16,1,16,1,16,1,17,1, + 17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,662,8,17,1,17,1,17,3, + 17,666,8,17,1,17,1,17,3,17,670,8,17,1,17,1,17,3,17,674,8,17,1,17,4,17, + 677,8,17,11,17,12,17,678,1,17,3,17,682,8,17,1,17,1,17,3,17,686,8,17,1, + 17,1,17,3,17,690,8,17,3,17,692,8,17,1,17,1,17,3,17,696,8,17,1,17,1,17, + 3,17,700,8,17,3,17,702,8,17,1,17,1,17,1,18,1,18,1,18,1,18,1,18,1,18,1, + 18,1,18,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,19,1,20,1,20,1,20,1,20,1, + 20,1,20,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,21,1,22,1,22,1,22,1,22,3, + 22,740,8,22,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,1,23,3,23,751,8,23, + 1,24,1,24,1,24,1,24,1,25,1,25,1,25,1,25,1,25,1,25,1,26,1,26,1,26,1,26, + 1,26,1,26,1,26,1,26,1,27,1,27,3,27,773,8,27,1,27,1,27,3,27,777,8,27,1, + 27,5,27,780,8,27,10,27,12,27,783,9,27,1,28,1,28,1,28,1,28,1,29,1,29,1, + 29,1,29,3,29,793,8,29,1,29,1,29,3,29,797,8,29,1,29,1,29,3,29,801,8,29, + 1,29,1,29,1,30,1,30,1,30,1,30,3,30,809,8,30,1,30,1,30,3,30,813,8,30,1, + 30,1,30,3,30,817,8,30,1,30,1,30,1,30,1,30,3,30,823,8,30,1,30,1,30,3,30, + 827,8,30,1,30,1,30,3,30,831,8,30,1,30,1,30,1,30,1,30,3,30,837,8,30,1, + 30,1,30,3,30,841,8,30,1,30,1,30,3,30,845,8,30,1,30,1,30,3,30,849,8,30, + 1,30,1,30,3,30,853,8,30,1,30,1,30,3,30,857,8,30,1,30,1,30,5,30,861,8, + 30,10,30,12,30,864,9,30,1,31,1,31,5,31,868,8,31,10,31,12,31,871,9,31, + 1,32,1,32,3,32,875,8,32,1,32,1,32,1,33,1,33,3,33,881,8,33,1,34,1,34,1, + 35,1,35,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1, + 36,1,36,3,36,901,8,36,1,37,1,37,1,38,1,38,3,38,907,8,38,1,38,5,38,910, + 8,38,10,38,12,38,913,9,38,1,38,1,38,3,38,917,8,38,4,38,919,8,38,11,38, + 12,38,920,1,38,1,38,1,38,3,38,926,8,38,1,39,1,39,1,39,1,39,3,39,932,8, + 39,1,39,1,39,1,39,3,39,937,8,39,1,39,3,39,940,8,39,1,40,1,40,3,40,944, + 8,40,1,41,1,41,3,41,948,8,41,5,41,950,8,41,10,41,12,41,953,9,41,1,41, + 1,41,1,41,3,41,958,8,41,5,41,960,8,41,10,41,12,41,963,9,41,1,41,1,41, + 3,41,967,8,41,1,41,5,41,970,8,41,10,41,12,41,973,9,41,1,41,3,41,976,8, + 41,1,41,3,41,979,8,41,1,41,1,41,3,41,983,8,41,4,41,985,8,41,11,41,12, + 41,986,1,41,1,41,3,41,991,8,41,1,42,1,42,3,42,995,8,42,4,42,997,8,42, + 11,42,12,42,998,1,42,1,42,1,43,1,43,3,43,1005,8,43,5,43,1007,8,43,10, + 43,12,43,1010,9,43,1,43,1,43,3,43,1014,8,43,5,43,1016,8,43,10,43,12,43, + 1019,9,43,1,43,1,43,1,44,1,44,1,44,1,44,3,44,1027,8,44,1,45,1,45,1,45, + 1,45,3,45,1033,8,45,1,46,1,46,1,46,1,46,1,46,1,46,3,46,1041,8,46,1,46, + 1,46,3,46,1045,8,46,1,46,1,46,3,46,1049,8,46,1,46,1,46,3,46,1053,8,46, + 1,46,1,46,1,46,1,46,1,46,3,46,1060,8,46,1,46,1,46,3,46,1064,8,46,1,46, + 1,46,3,46,1068,8,46,1,46,1,46,3,46,1072,8,46,1,46,3,46,1075,8,46,1,46, + 3,46,1078,8,46,1,47,1,47,1,47,1,47,3,47,1084,8,47,1,47,3,47,1087,8,47, + 1,48,1,48,3,48,1091,8,48,1,48,1,48,3,48,1095,8,48,1,48,1,48,3,48,1099, + 8,48,1,48,3,48,1102,8,48,1,49,1,49,3,49,1106,8,49,1,49,1,49,1,49,1,49, + 1,49,1,49,1,50,1,50,3,50,1116,8,50,1,50,1,50,1,51,1,51,3,51,1122,8,51, + 1,51,1,51,1,51,5,51,1127,8,51,10,51,12,51,1130,9,51,1,52,1,52,1,52,1, + 52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,1142,8,52,1,53,1,53,3,53,1146,8, + 53,1,53,1,53,3,53,1150,8,53,1,53,1,53,3,53,1154,8,53,1,53,5,53,1157,8, + 53,10,53,12,53,1160,9,53,1,54,1,54,3,54,1164,8,54,1,54,1,54,3,54,1168, + 8,54,1,54,1,54,1,55,1,55,3,55,1174,8,55,1,55,1,55,3,55,1178,8,55,1,55, + 1,55,3,55,1182,8,55,1,55,5,55,1185,8,55,10,55,12,55,1188,9,55,1,56,1, + 56,1,56,3,56,1193,8,56,1,56,3,56,1196,8,56,1,57,1,57,1,57,1,58,3,58,1202, + 8,58,1,58,3,58,1205,8,58,1,58,1,58,1,58,1,58,3,58,1211,8,58,1,58,1,58, + 3,58,1215,8,58,1,58,1,58,3,58,1219,8,58,1,59,1,59,3,59,1223,8,59,1,59, + 1,59,3,59,1227,8,59,1,59,5,59,1230,8,59,10,59,12,59,1233,9,59,1,59,1, + 59,3,59,1237,8,59,1,59,1,59,3,59,1241,8,59,1,59,5,59,1244,8,59,10,59, + 12,59,1247,9,59,3,59,1249,8,59,1,60,1,60,1,60,1,60,1,60,1,60,1,60,3,60, + 1258,8,60,1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,1267,8,61,1,61,5,61, + 1270,8,61,10,61,12,61,1273,9,61,1,62,1,62,1,62,1,62,1,63,1,63,1,63,1, + 63,1,64,1,64,3,64,1285,8,64,1,64,3,64,1288,8,64,1,65,1,65,1,65,1,65,1, + 66,1,66,3,66,1296,8,66,1,66,1,66,3,66,1300,8,66,1,66,5,66,1303,8,66,10, + 66,12,66,1306,9,66,1,67,1,67,3,67,1310,8,67,1,67,1,67,3,67,1314,8,67, + 1,67,1,67,1,67,3,67,1319,8,67,1,68,1,68,1,69,1,69,3,69,1325,8,69,1,69, + 5,69,1328,8,69,10,69,12,69,1331,9,69,1,69,1,69,1,69,1,69,3,69,1337,8, + 69,1,70,1,70,3,70,1341,8,70,1,70,1,70,3,70,1345,8,70,3,70,1347,8,70,1, + 70,1,70,3,70,1351,8,70,3,70,1353,8,70,1,70,1,70,3,70,1357,8,70,3,70,1359, + 8,70,1,70,1,70,1,71,1,71,3,71,1365,8,71,1,71,1,71,1,72,1,72,3,72,1371, + 8,72,1,72,1,72,3,72,1375,8,72,1,72,3,72,1378,8,72,1,72,3,72,1381,8,72, + 1,72,1,72,1,72,1,72,3,72,1387,8,72,1,72,3,72,1390,8,72,1,72,3,72,1393, + 8,72,1,72,1,72,3,72,1397,8,72,1,72,1,72,1,72,1,72,3,72,1403,8,72,1,72, + 3,72,1406,8,72,1,72,3,72,1409,8,72,1,72,1,72,3,72,1413,8,72,1,73,1,73, + 3,73,1417,8,73,1,73,1,73,3,73,1421,8,73,3,73,1423,8,73,1,73,1,73,3,73, + 1427,8,73,3,73,1429,8,73,1,73,1,73,3,73,1433,8,73,3,73,1435,8,73,1,73, + 1,73,3,73,1439,8,73,3,73,1441,8,73,1,73,1,73,1,74,1,74,3,74,1447,8,74, + 1,74,1,74,3,74,1451,8,74,1,74,1,74,3,74,1455,8,74,1,74,1,74,3,74,1459, + 8,74,1,74,1,74,3,74,1463,8,74,1,74,1,74,3,74,1467,8,74,1,74,1,74,3,74, + 1471,8,74,1,74,1,74,3,74,1475,8,74,5,74,1477,8,74,10,74,12,74,1480,9, + 74,3,74,1482,8,74,1,74,1,74,1,75,1,75,3,75,1488,8,75,1,75,1,75,3,75,1492, + 8,75,1,75,1,75,3,75,1496,8,75,1,75,3,75,1499,8,75,1,75,5,75,1502,8,75, + 10,75,12,75,1505,9,75,1,76,1,76,3,76,1509,8,76,1,76,5,76,1512,8,76,10, + 76,12,76,1515,9,76,1,77,1,77,3,77,1519,8,77,1,77,1,77,1,78,1,78,3,78, + 1525,8,78,1,78,1,78,1,78,1,78,3,78,1531,8,78,1,78,3,78,1534,8,78,1,78, + 3,78,1537,8,78,1,78,3,78,1540,8,78,1,78,1,78,3,78,1544,8,78,1,78,3,78, + 1547,8,78,1,78,3,78,1550,8,78,1,78,3,78,1553,8,78,1,78,3,78,1556,8,78, + 1,79,1,79,3,79,1560,8,79,1,79,1,79,3,79,1564,8,79,1,79,1,79,3,79,1568, + 8,79,1,79,1,79,3,79,1572,8,79,1,79,1,79,3,79,1576,8,79,1,79,3,79,1579, + 8,79,1,79,3,79,1582,8,79,1,79,1,79,3,79,1586,8,79,1,79,1,79,3,79,1590, + 8,79,1,79,1,79,3,79,1594,8,79,1,79,1,79,3,79,1598,8,79,3,79,1600,8,79, + 1,79,1,79,1,80,1,80,3,80,1606,8,80,1,80,3,80,1609,8,80,1,80,3,80,1612, + 8,80,1,80,1,80,1,81,1,81,3,81,1618,8,81,1,81,3,81,1621,8,81,1,81,3,81, + 1624,8,81,1,81,1,81,1,82,1,82,1,83,1,83,1,84,1,84,1,85,1,85,1,86,1,86, + 1,87,1,87,1,87,1,87,1,87,5,87,1643,8,87,10,87,12,87,1646,9,87,1,88,1, + 88,1,88,1,88,1,88,5,88,1653,8,88,10,88,12,88,1656,9,88,1,89,1,89,1,89, + 1,89,1,89,5,89,1663,8,89,10,89,12,89,1666,9,89,1,90,1,90,3,90,1670,8, + 90,3,90,1672,8,90,1,90,1,90,1,91,1,91,3,91,1678,8,91,1,91,1,91,3,91,1682, + 8,91,1,91,1,91,3,91,1686,8,91,1,91,1,91,3,91,1690,8,91,1,91,1,91,3,91, + 1694,8,91,1,91,1,91,1,91,1,91,1,91,1,91,3,91,1702,8,91,1,91,1,91,3,91, + 1706,8,91,1,91,1,91,3,91,1710,8,91,1,91,1,91,3,91,1714,8,91,1,91,1,91, + 4,91,1718,8,91,11,91,12,91,1719,1,91,1,91,3,91,1724,8,91,1,92,1,92,1, + 93,1,93,3,93,1730,8,93,1,93,1,93,3,93,1734,8,93,1,93,5,93,1737,8,93,10, + 93,12,93,1740,9,93,1,94,1,94,3,94,1744,8,94,1,94,1,94,3,94,1748,8,94, + 1,94,5,94,1751,8,94,10,94,12,94,1754,9,94,1,95,1,95,3,95,1758,8,95,1, + 95,1,95,3,95,1762,8,95,1,95,1,95,5,95,1766,8,95,10,95,12,95,1769,9,95, + 1,96,1,96,1,97,1,97,3,97,1775,8,97,1,97,1,97,3,97,1779,8,97,1,97,1,97, + 5,97,1783,8,97,10,97,12,97,1786,9,97,1,98,1,98,1,99,1,99,3,99,1792,8, + 99,1,99,1,99,3,99,1796,8,99,1,99,1,99,5,99,1800,8,99,10,99,12,99,1803, + 9,99,1,100,1,100,1,101,1,101,3,101,1809,8,101,1,101,1,101,3,101,1813, + 8,101,1,101,5,101,1816,8,101,10,101,12,101,1819,9,101,1,102,1,102,3,102, + 1823,8,102,3,102,1825,8,102,1,102,1,102,3,102,1829,8,102,1,102,3,102, + 1832,8,102,1,103,1,103,1,103,4,103,1837,8,103,11,103,12,103,1838,1,103, + 3,103,1842,8,103,1,104,1,104,3,104,1846,8,104,1,105,1,105,1,105,1,105, + 1,106,1,106,3,106,1854,8,106,1,106,1,106,3,106,1858,8,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,3,107, + 1873,8,107,1,107,3,107,1876,8,107,1,107,1,107,1,108,3,108,1881,8,108, + 1,108,1,108,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109,1,109, + 3,109,1895,8,109,1,110,1,110,3,110,1899,8,110,1,110,5,110,1902,8,110, + 10,110,12,110,1905,9,110,1,111,1,111,1,111,1,111,1,111,1,111,1,111,3, + 111,1914,8,111,1,112,1,112,1,112,1,112,1,112,1,112,3,112,1922,8,112,1, + 113,1,113,1,114,1,114,3,114,1928,8,114,1,114,1,114,3,114,1932,8,114,1, + 114,1,114,3,114,1936,8,114,5,114,1938,8,114,10,114,12,114,1941,9,114, + 3,114,1943,8,114,1,114,1,114,1,115,1,115,3,115,1949,8,115,1,115,3,115, + 1952,8,115,1,116,1,116,3,116,1956,8,116,1,116,1,116,3,116,1960,8,116, + 1,116,1,116,3,116,1964,8,116,1,116,1,116,3,116,1968,8,116,5,116,1970, + 8,116,10,116,12,116,1973,9,116,1,116,1,116,1,117,1,117,3,117,1979,8,117, + 1,117,3,117,1982,8,117,1,117,1,117,3,117,1986,8,117,1,117,1,117,1,118, + 1,118,3,118,1992,8,118,1,118,1,118,3,118,1996,8,118,1,118,1,118,1,119, + 1,119,3,119,2002,8,119,1,119,1,119,3,119,2006,8,119,1,119,1,119,3,119, + 2010,8,119,1,119,1,119,1,119,1,119,3,119,2016,8,119,1,119,1,119,3,119, + 2020,8,119,1,119,1,119,3,119,2024,8,119,3,119,2026,8,119,1,119,1,119, + 3,119,2030,8,119,1,119,1,119,3,119,2034,8,119,1,119,1,119,3,119,2038, + 8,119,5,119,2040,8,119,10,119,12,119,2043,9,119,3,119,2045,8,119,1,119, + 1,119,3,119,2049,8,119,1,120,1,120,1,121,1,121,3,121,2055,8,121,1,121, + 1,121,1,121,3,121,2060,8,121,3,121,2062,8,121,1,121,1,121,1,122,1,122, + 3,122,2068,8,122,1,122,1,122,3,122,2072,8,122,1,122,1,122,3,122,2076, + 8,122,1,122,1,122,3,122,2080,8,122,1,122,3,122,2083,8,122,1,122,3,122, + 2086,8,122,1,122,1,122,1,123,1,123,3,123,2092,8,123,1,123,1,123,3,123, + 2096,8,123,1,124,1,124,3,124,2100,8,124,1,124,4,124,2103,8,124,11,124, + 12,124,2104,1,124,1,124,3,124,2109,8,124,1,124,1,124,3,124,2113,8,124, + 1,124,4,124,2116,8,124,11,124,12,124,2117,3,124,2120,8,124,1,124,3,124, + 2123,8,124,1,124,1,124,3,124,2127,8,124,1,124,3,124,2130,8,124,1,124, + 3,124,2133,8,124,1,124,1,124,1,125,1,125,3,125,2139,8,125,1,125,1,125, + 3,125,2143,8,125,1,125,1,125,3,125,2147,8,125,1,125,1,125,1,126,1,126, + 1,127,1,127,3,127,2155,8,127,1,128,1,128,1,128,3,128,2160,8,128,1,129, + 1,129,3,129,2164,8,129,1,129,1,129,1,130,1,130,1,131,1,131,1,132,1,132, + 1,133,1,133,1,134,1,134,1,134,1,134,1,134,3,134,2181,8,134,1,135,1,135, + 1,136,1,136,1,137,1,137,1,138,1,138,1,138,0,1,60,139,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,0,9,1,0,100,103, + 2,0,5,5,13,17,1,0,19,20,2,0,21,21,111,111,2,0,22,23,94,94,1,0,118,119, + 2,0,14,14,28,31,2,0,16,16,32,35,2,0,36,46,111,111,2476,0,279,1,0,0,0, + 2,308,1,0,0,0,4,310,1,0,0,0,6,349,1,0,0,0,8,363,1,0,0,0,10,393,1,0,0, + 0,12,423,1,0,0,0,14,435,1,0,0,0,16,447,1,0,0,0,18,490,1,0,0,0,20,504, + 1,0,0,0,22,548,1,0,0,0,24,550,1,0,0,0,26,564,1,0,0,0,28,580,1,0,0,0,30, + 582,1,0,0,0,32,611,1,0,0,0,34,651,1,0,0,0,36,705,1,0,0,0,38,713,1,0,0, + 0,40,721,1,0,0,0,42,727,1,0,0,0,44,739,1,0,0,0,46,741,1,0,0,0,48,752, + 1,0,0,0,50,756,1,0,0,0,52,762,1,0,0,0,54,770,1,0,0,0,56,784,1,0,0,0,58, + 788,1,0,0,0,60,856,1,0,0,0,62,865,1,0,0,0,64,872,1,0,0,0,66,880,1,0,0, + 0,68,882,1,0,0,0,70,884,1,0,0,0,72,900,1,0,0,0,74,902,1,0,0,0,76,925, + 1,0,0,0,78,939,1,0,0,0,80,943,1,0,0,0,82,990,1,0,0,0,84,996,1,0,0,0,86, + 1008,1,0,0,0,88,1026,1,0,0,0,90,1032,1,0,0,0,92,1034,1,0,0,0,94,1079, + 1,0,0,0,96,1090,1,0,0,0,98,1103,1,0,0,0,100,1113,1,0,0,0,102,1119,1,0, + 0,0,104,1141,1,0,0,0,106,1143,1,0,0,0,108,1161,1,0,0,0,110,1171,1,0,0, + 0,112,1189,1,0,0,0,114,1197,1,0,0,0,116,1204,1,0,0,0,118,1248,1,0,0,0, + 120,1257,1,0,0,0,122,1259,1,0,0,0,124,1274,1,0,0,0,126,1278,1,0,0,0,128, + 1282,1,0,0,0,130,1289,1,0,0,0,132,1293,1,0,0,0,134,1318,1,0,0,0,136,1320, + 1,0,0,0,138,1336,1,0,0,0,140,1338,1,0,0,0,142,1362,1,0,0,0,144,1412,1, + 0,0,0,146,1414,1,0,0,0,148,1444,1,0,0,0,150,1485,1,0,0,0,152,1506,1,0, + 0,0,154,1516,1,0,0,0,156,1522,1,0,0,0,158,1557,1,0,0,0,160,1603,1,0,0, + 0,162,1615,1,0,0,0,164,1627,1,0,0,0,166,1629,1,0,0,0,168,1631,1,0,0,0, + 170,1633,1,0,0,0,172,1635,1,0,0,0,174,1637,1,0,0,0,176,1647,1,0,0,0,178, + 1657,1,0,0,0,180,1671,1,0,0,0,182,1723,1,0,0,0,184,1725,1,0,0,0,186,1727, + 1,0,0,0,188,1741,1,0,0,0,190,1755,1,0,0,0,192,1770,1,0,0,0,194,1772,1, + 0,0,0,196,1787,1,0,0,0,198,1789,1,0,0,0,200,1804,1,0,0,0,202,1806,1,0, + 0,0,204,1824,1,0,0,0,206,1833,1,0,0,0,208,1845,1,0,0,0,210,1847,1,0,0, + 0,212,1851,1,0,0,0,214,1872,1,0,0,0,216,1880,1,0,0,0,218,1894,1,0,0,0, + 220,1896,1,0,0,0,222,1913,1,0,0,0,224,1921,1,0,0,0,226,1923,1,0,0,0,228, + 1925,1,0,0,0,230,1946,1,0,0,0,232,1953,1,0,0,0,234,1978,1,0,0,0,236,1989, + 1,0,0,0,238,2048,1,0,0,0,240,2050,1,0,0,0,242,2061,1,0,0,0,244,2065,1, + 0,0,0,246,2089,1,0,0,0,248,2119,1,0,0,0,250,2136,1,0,0,0,252,2150,1,0, + 0,0,254,2154,1,0,0,0,256,2156,1,0,0,0,258,2161,1,0,0,0,260,2167,1,0,0, + 0,262,2169,1,0,0,0,264,2171,1,0,0,0,266,2173,1,0,0,0,268,2180,1,0,0,0, + 270,2182,1,0,0,0,272,2184,1,0,0,0,274,2186,1,0,0,0,276,2188,1,0,0,0,278, + 280,5,140,0,0,279,278,1,0,0,0,279,280,1,0,0,0,280,282,1,0,0,0,281,283, + 3,66,33,0,282,281,1,0,0,0,282,283,1,0,0,0,283,285,1,0,0,0,284,286,5,140, + 0,0,285,284,1,0,0,0,285,286,1,0,0,0,286,287,1,0,0,0,287,292,3,2,1,0,288, + 290,5,140,0,0,289,288,1,0,0,0,289,290,1,0,0,0,290,291,1,0,0,0,291,293, + 5,1,0,0,292,289,1,0,0,0,292,293,1,0,0,0,293,295,1,0,0,0,294,296,5,140, + 0,0,295,294,1,0,0,0,295,296,1,0,0,0,296,297,1,0,0,0,297,298,5,0,0,1,298, + 1,1,0,0,0,299,309,3,74,37,0,300,309,3,28,14,0,301,309,3,4,2,0,302,309, + 3,8,4,0,303,309,3,10,5,0,304,309,3,12,6,0,305,309,3,16,8,0,306,309,3, + 14,7,0,307,309,3,72,36,0,308,299,1,0,0,0,308,300,1,0,0,0,308,301,1,0, + 0,0,308,302,1,0,0,0,308,303,1,0,0,0,308,304,1,0,0,0,308,305,1,0,0,0,308, + 306,1,0,0,0,308,307,1,0,0,0,309,3,1,0,0,0,310,311,5,51,0,0,311,312,5, + 140,0,0,312,329,3,266,133,0,313,315,5,140,0,0,314,313,1,0,0,0,314,315, + 1,0,0,0,315,316,1,0,0,0,316,318,5,2,0,0,317,319,5,140,0,0,318,317,1,0, + 0,0,318,319,1,0,0,0,319,320,1,0,0,0,320,322,3,6,3,0,321,323,5,140,0,0, + 322,321,1,0,0,0,322,323,1,0,0,0,323,324,1,0,0,0,324,326,5,3,0,0,325,327, + 5,140,0,0,326,325,1,0,0,0,326,327,1,0,0,0,327,330,1,0,0,0,328,330,5,140, + 0,0,329,314,1,0,0,0,329,328,1,0,0,0,330,331,1,0,0,0,331,332,5,52,0,0, + 332,333,5,140,0,0,333,347,3,22,11,0,334,336,5,140,0,0,335,334,1,0,0,0, + 335,336,1,0,0,0,336,337,1,0,0,0,337,339,5,2,0,0,338,340,5,140,0,0,339, + 338,1,0,0,0,339,340,1,0,0,0,340,341,1,0,0,0,341,343,3,24,12,0,342,344, + 5,140,0,0,343,342,1,0,0,0,343,344,1,0,0,0,344,345,1,0,0,0,345,346,5,3, + 0,0,346,348,1,0,0,0,347,335,1,0,0,0,347,348,1,0,0,0,348,5,1,0,0,0,349, + 360,3,266,133,0,350,352,5,140,0,0,351,350,1,0,0,0,351,352,1,0,0,0,352, + 353,1,0,0,0,353,355,5,4,0,0,354,356,5,140,0,0,355,354,1,0,0,0,355,356, + 1,0,0,0,356,357,1,0,0,0,357,359,3,266,133,0,358,351,1,0,0,0,359,362,1, + 0,0,0,360,358,1,0,0,0,360,361,1,0,0,0,361,7,1,0,0,0,362,360,1,0,0,0,363, + 364,5,51,0,0,364,365,5,140,0,0,365,366,3,266,133,0,366,367,5,140,0,0, + 367,368,5,52,0,0,368,369,5,140,0,0,369,371,5,2,0,0,370,372,5,140,0,0, + 371,370,1,0,0,0,371,372,1,0,0,0,372,373,1,0,0,0,373,384,5,126,0,0,374, + 376,5,140,0,0,375,374,1,0,0,0,375,376,1,0,0,0,376,377,1,0,0,0,377,379, + 5,4,0,0,378,380,5,140,0,0,379,378,1,0,0,0,379,380,1,0,0,0,380,381,1,0, + 0,0,381,383,5,126,0,0,382,375,1,0,0,0,383,386,1,0,0,0,384,382,1,0,0,0, + 384,385,1,0,0,0,385,387,1,0,0,0,386,384,1,0,0,0,387,388,5,3,0,0,388,389, + 5,140,0,0,389,390,5,97,0,0,390,391,5,140,0,0,391,392,5,53,0,0,392,9,1, + 0,0,0,393,394,5,51,0,0,394,395,5,140,0,0,395,397,5,2,0,0,396,398,5,140, + 0,0,397,396,1,0,0,0,397,398,1,0,0,0,398,399,1,0,0,0,399,401,3,74,37,0, + 400,402,5,140,0,0,401,400,1,0,0,0,401,402,1,0,0,0,402,403,1,0,0,0,403, + 404,5,3,0,0,404,405,5,140,0,0,405,406,5,67,0,0,406,407,5,140,0,0,407, + 421,5,126,0,0,408,410,5,140,0,0,409,408,1,0,0,0,409,410,1,0,0,0,410,411, + 1,0,0,0,411,413,5,2,0,0,412,414,5,140,0,0,413,412,1,0,0,0,413,414,1,0, + 0,0,414,415,1,0,0,0,415,417,3,24,12,0,416,418,5,140,0,0,417,416,1,0,0, + 0,417,418,1,0,0,0,418,419,1,0,0,0,419,420,5,3,0,0,420,422,1,0,0,0,421, + 409,1,0,0,0,421,422,1,0,0,0,422,11,1,0,0,0,423,424,5,47,0,0,424,425,5, + 140,0,0,425,427,3,268,134,0,426,428,5,140,0,0,427,426,1,0,0,0,427,428, + 1,0,0,0,428,429,1,0,0,0,429,431,5,5,0,0,430,432,5,140,0,0,431,430,1,0, + 0,0,431,432,1,0,0,0,432,433,1,0,0,0,433,434,3,224,112,0,434,13,1,0,0, + 0,435,436,5,48,0,0,436,437,5,140,0,0,437,438,5,88,0,0,438,439,5,140,0, + 0,439,440,5,55,0,0,440,441,5,140,0,0,441,442,3,266,133,0,442,443,5,140, + 0,0,443,444,5,116,0,0,444,445,5,140,0,0,445,446,5,126,0,0,446,15,1,0, + 0,0,447,448,5,86,0,0,448,449,5,140,0,0,449,450,5,49,0,0,450,451,5,140, + 0,0,451,453,3,240,120,0,452,454,5,140,0,0,453,452,1,0,0,0,453,454,1,0, + 0,0,454,455,1,0,0,0,455,457,5,2,0,0,456,458,5,140,0,0,457,456,1,0,0,0, + 457,458,1,0,0,0,458,460,1,0,0,0,459,461,3,18,9,0,460,459,1,0,0,0,460, + 461,1,0,0,0,461,463,1,0,0,0,462,464,5,140,0,0,463,462,1,0,0,0,463,464, + 1,0,0,0,464,466,1,0,0,0,465,467,3,20,10,0,466,465,1,0,0,0,466,467,1,0, + 0,0,467,478,1,0,0,0,468,470,5,140,0,0,469,468,1,0,0,0,469,470,1,0,0,0, + 470,471,1,0,0,0,471,473,5,4,0,0,472,474,5,140,0,0,473,472,1,0,0,0,473, + 474,1,0,0,0,474,475,1,0,0,0,475,477,3,20,10,0,476,469,1,0,0,0,477,480, + 1,0,0,0,478,476,1,0,0,0,478,479,1,0,0,0,479,482,1,0,0,0,480,478,1,0,0, + 0,481,483,5,140,0,0,482,481,1,0,0,0,482,483,1,0,0,0,483,484,1,0,0,0,484, + 485,5,3,0,0,485,486,5,140,0,0,486,487,5,95,0,0,487,488,5,140,0,0,488, + 489,3,172,86,0,489,17,1,0,0,0,490,501,3,268,134,0,491,493,5,140,0,0,492, + 491,1,0,0,0,492,493,1,0,0,0,493,494,1,0,0,0,494,496,5,4,0,0,495,497,5, + 140,0,0,496,495,1,0,0,0,496,497,1,0,0,0,497,498,1,0,0,0,498,500,3,268, + 134,0,499,492,1,0,0,0,500,503,1,0,0,0,501,499,1,0,0,0,501,502,1,0,0,0, + 502,19,1,0,0,0,503,501,1,0,0,0,504,506,3,268,134,0,505,507,5,140,0,0, + 506,505,1,0,0,0,506,507,1,0,0,0,507,508,1,0,0,0,508,509,5,6,0,0,509,511, + 5,5,0,0,510,512,5,140,0,0,511,510,1,0,0,0,511,512,1,0,0,0,512,513,1,0, + 0,0,513,514,3,224,112,0,514,21,1,0,0,0,515,517,5,7,0,0,516,518,5,140, + 0,0,517,516,1,0,0,0,517,518,1,0,0,0,518,519,1,0,0,0,519,530,5,126,0,0, + 520,522,5,140,0,0,521,520,1,0,0,0,521,522,1,0,0,0,522,523,1,0,0,0,523, + 525,5,4,0,0,524,526,5,140,0,0,525,524,1,0,0,0,525,526,1,0,0,0,526,527, + 1,0,0,0,527,529,5,126,0,0,528,521,1,0,0,0,529,532,1,0,0,0,530,528,1,0, + 0,0,530,531,1,0,0,0,531,533,1,0,0,0,532,530,1,0,0,0,533,549,5,8,0,0,534, + 549,5,126,0,0,535,537,5,50,0,0,536,538,5,140,0,0,537,536,1,0,0,0,537, + 538,1,0,0,0,538,539,1,0,0,0,539,541,5,2,0,0,540,542,5,140,0,0,541,540, + 1,0,0,0,541,542,1,0,0,0,542,543,1,0,0,0,543,545,5,126,0,0,544,546,5,140, + 0,0,545,544,1,0,0,0,545,546,1,0,0,0,546,547,1,0,0,0,547,549,5,3,0,0,548, + 515,1,0,0,0,548,534,1,0,0,0,548,535,1,0,0,0,549,23,1,0,0,0,550,561,3, + 26,13,0,551,553,5,140,0,0,552,551,1,0,0,0,552,553,1,0,0,0,553,554,1,0, + 0,0,554,556,5,4,0,0,555,557,5,140,0,0,556,555,1,0,0,0,556,557,1,0,0,0, + 557,558,1,0,0,0,558,560,3,26,13,0,559,552,1,0,0,0,560,563,1,0,0,0,561, + 559,1,0,0,0,561,562,1,0,0,0,562,25,1,0,0,0,563,561,1,0,0,0,564,566,3, + 268,134,0,565,567,5,140,0,0,566,565,1,0,0,0,566,567,1,0,0,0,567,568,1, + 0,0,0,568,570,5,5,0,0,569,571,5,140,0,0,570,569,1,0,0,0,570,571,1,0,0, + 0,571,572,1,0,0,0,572,573,3,224,112,0,573,27,1,0,0,0,574,581,3,30,15, + 0,575,581,3,32,16,0,576,581,3,34,17,0,577,581,3,38,19,0,578,581,3,40, + 20,0,579,581,3,42,21,0,580,574,1,0,0,0,580,575,1,0,0,0,580,576,1,0,0, + 0,580,577,1,0,0,0,580,578,1,0,0,0,580,579,1,0,0,0,581,29,1,0,0,0,582, + 583,5,86,0,0,583,584,5,140,0,0,584,585,5,54,0,0,585,586,5,140,0,0,586, + 587,5,55,0,0,587,588,5,140,0,0,588,590,3,266,133,0,589,591,5,140,0,0, + 590,589,1,0,0,0,590,591,1,0,0,0,591,592,1,0,0,0,592,594,5,2,0,0,593,595, + 5,140,0,0,594,593,1,0,0,0,594,595,1,0,0,0,595,596,1,0,0,0,596,598,3,54, + 27,0,597,599,5,140,0,0,598,597,1,0,0,0,598,599,1,0,0,0,599,600,1,0,0, + 0,600,602,5,4,0,0,601,603,5,140,0,0,602,601,1,0,0,0,602,603,1,0,0,0,603, + 604,1,0,0,0,604,605,3,58,29,0,605,607,1,0,0,0,606,608,5,140,0,0,607,606, + 1,0,0,0,607,608,1,0,0,0,608,609,1,0,0,0,609,610,5,3,0,0,610,31,1,0,0, + 0,611,612,5,86,0,0,612,613,5,140,0,0,613,614,5,66,0,0,614,615,5,140,0, + 0,615,616,5,55,0,0,616,617,5,140,0,0,617,619,3,266,133,0,618,620,5,140, + 0,0,619,618,1,0,0,0,619,620,1,0,0,0,620,621,1,0,0,0,621,623,5,2,0,0,622, + 624,5,140,0,0,623,622,1,0,0,0,623,624,1,0,0,0,624,625,1,0,0,0,625,627, + 3,36,18,0,626,628,5,140,0,0,627,626,1,0,0,0,627,628,1,0,0,0,628,637,1, + 0,0,0,629,631,5,4,0,0,630,632,5,140,0,0,631,630,1,0,0,0,631,632,1,0,0, + 0,632,633,1,0,0,0,633,635,3,54,27,0,634,636,5,140,0,0,635,634,1,0,0,0, + 635,636,1,0,0,0,636,638,1,0,0,0,637,629,1,0,0,0,637,638,1,0,0,0,638,647, + 1,0,0,0,639,641,5,4,0,0,640,642,5,140,0,0,641,640,1,0,0,0,641,642,1,0, + 0,0,642,643,1,0,0,0,643,645,3,268,134,0,644,646,5,140,0,0,645,644,1,0, + 0,0,645,646,1,0,0,0,646,648,1,0,0,0,647,639,1,0,0,0,647,648,1,0,0,0,648, + 649,1,0,0,0,649,650,5,3,0,0,650,33,1,0,0,0,651,652,5,86,0,0,652,653,5, + 140,0,0,653,654,5,66,0,0,654,655,5,140,0,0,655,656,5,55,0,0,656,657,5, + 140,0,0,657,658,5,56,0,0,658,659,5,140,0,0,659,661,3,266,133,0,660,662, + 5,140,0,0,661,660,1,0,0,0,661,662,1,0,0,0,662,663,1,0,0,0,663,665,5,2, + 0,0,664,666,5,140,0,0,665,664,1,0,0,0,665,666,1,0,0,0,666,667,1,0,0,0, + 667,669,3,36,18,0,668,670,5,140,0,0,669,668,1,0,0,0,669,670,1,0,0,0,670, + 676,1,0,0,0,671,673,5,4,0,0,672,674,5,140,0,0,673,672,1,0,0,0,673,674, + 1,0,0,0,674,675,1,0,0,0,675,677,3,36,18,0,676,671,1,0,0,0,677,678,1,0, + 0,0,678,676,1,0,0,0,678,679,1,0,0,0,679,681,1,0,0,0,680,682,5,140,0,0, + 681,680,1,0,0,0,681,682,1,0,0,0,682,691,1,0,0,0,683,685,5,4,0,0,684,686, + 5,140,0,0,685,684,1,0,0,0,685,686,1,0,0,0,686,687,1,0,0,0,687,689,3,54, + 27,0,688,690,5,140,0,0,689,688,1,0,0,0,689,690,1,0,0,0,690,692,1,0,0, + 0,691,683,1,0,0,0,691,692,1,0,0,0,692,701,1,0,0,0,693,695,5,4,0,0,694, + 696,5,140,0,0,695,694,1,0,0,0,695,696,1,0,0,0,696,697,1,0,0,0,697,699, + 3,268,134,0,698,700,5,140,0,0,699,698,1,0,0,0,699,700,1,0,0,0,700,702, + 1,0,0,0,701,693,1,0,0,0,701,702,1,0,0,0,702,703,1,0,0,0,703,704,5,3,0, + 0,704,35,1,0,0,0,705,706,5,52,0,0,706,707,5,140,0,0,707,708,3,266,133, + 0,708,709,5,140,0,0,709,710,5,67,0,0,710,711,5,140,0,0,711,712,3,266, + 133,0,712,37,1,0,0,0,713,714,5,86,0,0,714,715,5,140,0,0,715,716,5,57, + 0,0,716,717,5,140,0,0,717,718,5,58,0,0,718,719,5,140,0,0,719,720,3,266, + 133,0,720,39,1,0,0,0,721,722,5,59,0,0,722,723,5,140,0,0,723,724,5,55, + 0,0,724,725,5,140,0,0,725,726,3,266,133,0,726,41,1,0,0,0,727,728,5,60, + 0,0,728,729,5,140,0,0,729,730,5,55,0,0,730,731,5,140,0,0,731,732,3,266, + 133,0,732,733,5,140,0,0,733,734,3,44,22,0,734,43,1,0,0,0,735,740,3,46, + 23,0,736,740,3,48,24,0,737,740,3,50,25,0,738,740,3,52,26,0,739,735,1, + 0,0,0,739,736,1,0,0,0,739,737,1,0,0,0,739,738,1,0,0,0,740,45,1,0,0,0, + 741,742,5,63,0,0,742,743,5,140,0,0,743,744,3,260,130,0,744,745,5,140, + 0,0,745,750,3,60,30,0,746,747,5,140,0,0,747,748,5,61,0,0,748,749,5,140, + 0,0,749,751,3,172,86,0,750,746,1,0,0,0,750,751,1,0,0,0,751,47,1,0,0,0, + 752,753,5,59,0,0,753,754,5,140,0,0,754,755,3,260,130,0,755,49,1,0,0,0, + 756,757,5,62,0,0,757,758,5,140,0,0,758,759,5,67,0,0,759,760,5,140,0,0, + 760,761,3,266,133,0,761,51,1,0,0,0,762,763,5,62,0,0,763,764,5,140,0,0, + 764,765,3,260,130,0,765,766,5,140,0,0,766,767,5,67,0,0,767,768,5,140, + 0,0,768,769,3,260,130,0,769,53,1,0,0,0,770,781,3,56,28,0,771,773,5,140, + 0,0,772,771,1,0,0,0,772,773,1,0,0,0,773,774,1,0,0,0,774,776,5,4,0,0,775, + 777,5,140,0,0,776,775,1,0,0,0,776,777,1,0,0,0,777,778,1,0,0,0,778,780, + 3,56,28,0,779,772,1,0,0,0,780,783,1,0,0,0,781,779,1,0,0,0,781,782,1,0, + 0,0,782,55,1,0,0,0,783,781,1,0,0,0,784,785,3,260,130,0,785,786,5,140, + 0,0,786,787,3,60,30,0,787,57,1,0,0,0,788,789,5,64,0,0,789,790,5,140,0, + 0,790,792,5,65,0,0,791,793,5,140,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,140,0,0,796,795,1,0,0,0,796, + 797,1,0,0,0,797,798,1,0,0,0,798,800,3,260,130,0,799,801,5,140,0,0,800, + 799,1,0,0,0,800,801,1,0,0,0,801,802,1,0,0,0,802,803,5,3,0,0,803,59,1, + 0,0,0,804,805,6,30,-1,0,805,857,3,268,134,0,806,808,5,79,0,0,807,809, + 5,140,0,0,808,807,1,0,0,0,808,809,1,0,0,0,809,810,1,0,0,0,810,812,5,2, + 0,0,811,813,5,140,0,0,812,811,1,0,0,0,812,813,1,0,0,0,813,814,1,0,0,0, + 814,816,3,54,27,0,815,817,5,140,0,0,816,815,1,0,0,0,816,817,1,0,0,0,817, + 818,1,0,0,0,818,819,5,3,0,0,819,857,1,0,0,0,820,822,3,268,134,0,821,823, + 5,140,0,0,822,821,1,0,0,0,822,823,1,0,0,0,823,824,1,0,0,0,824,826,5,2, + 0,0,825,827,5,140,0,0,826,825,1,0,0,0,826,827,1,0,0,0,827,828,1,0,0,0, + 828,830,3,54,27,0,829,831,5,140,0,0,830,829,1,0,0,0,830,831,1,0,0,0,831, + 832,1,0,0,0,832,833,5,3,0,0,833,857,1,0,0,0,834,836,3,268,134,0,835,837, + 5,140,0,0,836,835,1,0,0,0,836,837,1,0,0,0,837,838,1,0,0,0,838,840,5,2, + 0,0,839,841,5,140,0,0,840,839,1,0,0,0,840,841,1,0,0,0,841,842,1,0,0,0, + 842,844,3,60,30,0,843,845,5,140,0,0,844,843,1,0,0,0,844,845,1,0,0,0,845, + 846,1,0,0,0,846,848,5,4,0,0,847,849,5,140,0,0,848,847,1,0,0,0,848,849, + 1,0,0,0,849,850,1,0,0,0,850,852,3,60,30,0,851,853,5,140,0,0,852,851,1, + 0,0,0,852,853,1,0,0,0,853,854,1,0,0,0,854,855,5,3,0,0,855,857,1,0,0,0, + 856,804,1,0,0,0,856,806,1,0,0,0,856,820,1,0,0,0,856,834,1,0,0,0,857,862, + 1,0,0,0,858,859,10,4,0,0,859,861,3,62,31,0,860,858,1,0,0,0,861,864,1, + 0,0,0,862,860,1,0,0,0,862,863,1,0,0,0,863,61,1,0,0,0,864,862,1,0,0,0, + 865,869,3,64,32,0,866,868,3,64,32,0,867,866,1,0,0,0,868,871,1,0,0,0,869, + 867,1,0,0,0,869,870,1,0,0,0,870,63,1,0,0,0,871,869,1,0,0,0,872,874,5, + 7,0,0,873,875,3,262,131,0,874,873,1,0,0,0,874,875,1,0,0,0,875,876,1,0, + 0,0,876,877,5,8,0,0,877,65,1,0,0,0,878,881,3,68,34,0,879,881,3,70,35, + 0,880,878,1,0,0,0,880,879,1,0,0,0,881,67,1,0,0,0,882,883,5,68,0,0,883, + 69,1,0,0,0,884,885,5,69,0,0,885,71,1,0,0,0,886,887,5,70,0,0,887,888,5, + 140,0,0,888,901,5,71,0,0,889,890,5,70,0,0,890,891,5,140,0,0,891,892,5, + 71,0,0,892,893,5,140,0,0,893,894,5,72,0,0,894,895,5,140,0,0,895,901,5, + 73,0,0,896,901,5,75,0,0,897,901,5,76,0,0,898,901,5,77,0,0,899,901,5,78, + 0,0,900,886,1,0,0,0,900,889,1,0,0,0,900,896,1,0,0,0,900,897,1,0,0,0,900, + 898,1,0,0,0,900,899,1,0,0,0,901,73,1,0,0,0,902,903,3,76,38,0,903,75,1, + 0,0,0,904,911,3,80,40,0,905,907,5,140,0,0,906,905,1,0,0,0,906,907,1,0, + 0,0,907,908,1,0,0,0,908,910,3,78,39,0,909,906,1,0,0,0,910,913,1,0,0,0, + 911,909,1,0,0,0,911,912,1,0,0,0,912,926,1,0,0,0,913,911,1,0,0,0,914,916, + 3,114,57,0,915,917,5,140,0,0,916,915,1,0,0,0,916,917,1,0,0,0,917,919, + 1,0,0,0,918,914,1,0,0,0,919,920,1,0,0,0,920,918,1,0,0,0,920,921,1,0,0, + 0,921,922,1,0,0,0,922,923,3,80,40,0,923,924,6,38,-1,0,924,926,1,0,0,0, + 925,904,1,0,0,0,925,918,1,0,0,0,926,77,1,0,0,0,927,928,5,79,0,0,928,929, + 5,140,0,0,929,931,5,80,0,0,930,932,5,140,0,0,931,930,1,0,0,0,931,932, + 1,0,0,0,932,933,1,0,0,0,933,940,3,80,40,0,934,936,5,79,0,0,935,937,5, + 140,0,0,936,935,1,0,0,0,936,937,1,0,0,0,937,938,1,0,0,0,938,940,3,80, + 40,0,939,927,1,0,0,0,939,934,1,0,0,0,940,79,1,0,0,0,941,944,3,82,41,0, + 942,944,3,84,42,0,943,941,1,0,0,0,943,942,1,0,0,0,944,81,1,0,0,0,945, + 947,3,90,45,0,946,948,5,140,0,0,947,946,1,0,0,0,947,948,1,0,0,0,948,950, + 1,0,0,0,949,945,1,0,0,0,950,953,1,0,0,0,951,949,1,0,0,0,951,952,1,0,0, + 0,952,954,1,0,0,0,953,951,1,0,0,0,954,991,3,114,57,0,955,957,3,90,45, + 0,956,958,5,140,0,0,957,956,1,0,0,0,957,958,1,0,0,0,958,960,1,0,0,0,959, + 955,1,0,0,0,960,963,1,0,0,0,961,959,1,0,0,0,961,962,1,0,0,0,962,964,1, + 0,0,0,963,961,1,0,0,0,964,971,3,88,44,0,965,967,5,140,0,0,966,965,1,0, + 0,0,966,967,1,0,0,0,967,968,1,0,0,0,968,970,3,88,44,0,969,966,1,0,0,0, + 970,973,1,0,0,0,971,969,1,0,0,0,971,972,1,0,0,0,972,978,1,0,0,0,973,971, + 1,0,0,0,974,976,5,140,0,0,975,974,1,0,0,0,975,976,1,0,0,0,976,977,1,0, + 0,0,977,979,3,114,57,0,978,975,1,0,0,0,978,979,1,0,0,0,979,991,1,0,0, + 0,980,982,3,90,45,0,981,983,5,140,0,0,982,981,1,0,0,0,982,983,1,0,0,0, + 983,985,1,0,0,0,984,980,1,0,0,0,985,986,1,0,0,0,986,984,1,0,0,0,986,987, + 1,0,0,0,987,988,1,0,0,0,988,989,6,41,-1,0,989,991,1,0,0,0,990,951,1,0, + 0,0,990,961,1,0,0,0,990,984,1,0,0,0,991,83,1,0,0,0,992,994,3,86,43,0, + 993,995,5,140,0,0,994,993,1,0,0,0,994,995,1,0,0,0,995,997,1,0,0,0,996, + 992,1,0,0,0,997,998,1,0,0,0,998,996,1,0,0,0,998,999,1,0,0,0,999,1000, + 1,0,0,0,1000,1001,3,82,41,0,1001,85,1,0,0,0,1002,1004,3,90,45,0,1003, + 1005,5,140,0,0,1004,1003,1,0,0,0,1004,1005,1,0,0,0,1005,1007,1,0,0,0, + 1006,1002,1,0,0,0,1007,1010,1,0,0,0,1008,1006,1,0,0,0,1008,1009,1,0,0, + 0,1009,1017,1,0,0,0,1010,1008,1,0,0,0,1011,1013,3,88,44,0,1012,1014,5, + 140,0,0,1013,1012,1,0,0,0,1013,1014,1,0,0,0,1014,1016,1,0,0,0,1015,1011, + 1,0,0,0,1016,1019,1,0,0,0,1017,1015,1,0,0,0,1017,1018,1,0,0,0,1018,1020, + 1,0,0,0,1019,1017,1,0,0,0,1020,1021,3,112,56,0,1021,87,1,0,0,0,1022,1027, + 3,100,50,0,1023,1027,3,102,51,0,1024,1027,3,106,53,0,1025,1027,3,110, + 55,0,1026,1022,1,0,0,0,1026,1023,1,0,0,0,1026,1024,1,0,0,0,1026,1025, + 1,0,0,0,1027,89,1,0,0,0,1028,1033,3,96,48,0,1029,1033,3,98,49,0,1030, + 1033,3,94,47,0,1031,1033,3,92,46,0,1032,1028,1,0,0,0,1032,1029,1,0,0, + 0,1032,1030,1,0,0,0,1032,1031,1,0,0,0,1033,91,1,0,0,0,1034,1052,5,81, + 0,0,1035,1036,5,140,0,0,1036,1037,5,91,0,0,1037,1038,5,140,0,0,1038,1040, + 5,82,0,0,1039,1041,5,140,0,0,1040,1039,1,0,0,0,1040,1041,1,0,0,0,1041, + 1042,1,0,0,0,1042,1044,5,2,0,0,1043,1045,5,140,0,0,1044,1043,1,0,0,0, + 1044,1045,1,0,0,0,1045,1046,1,0,0,0,1046,1048,3,54,27,0,1047,1049,5,140, + 0,0,1048,1047,1,0,0,0,1048,1049,1,0,0,0,1049,1050,1,0,0,0,1050,1051,5, + 3,0,0,1051,1053,1,0,0,0,1052,1035,1,0,0,0,1052,1053,1,0,0,0,1053,1054, + 1,0,0,0,1054,1055,5,140,0,0,1055,1056,5,52,0,0,1056,1057,5,140,0,0,1057, + 1071,3,22,11,0,1058,1060,5,140,0,0,1059,1058,1,0,0,0,1059,1060,1,0,0, + 0,1060,1061,1,0,0,0,1061,1063,5,2,0,0,1062,1064,5,140,0,0,1063,1062,1, + 0,0,0,1063,1064,1,0,0,0,1064,1065,1,0,0,0,1065,1067,3,24,12,0,1066,1068, + 5,140,0,0,1067,1066,1,0,0,0,1067,1068,1,0,0,0,1068,1069,1,0,0,0,1069, + 1070,5,3,0,0,1070,1072,1,0,0,0,1071,1059,1,0,0,0,1071,1072,1,0,0,0,1072, + 1077,1,0,0,0,1073,1075,5,140,0,0,1074,1073,1,0,0,0,1074,1075,1,0,0,0, + 1075,1076,1,0,0,0,1076,1078,3,130,65,0,1077,1074,1,0,0,0,1077,1078,1, + 0,0,0,1078,93,1,0,0,0,1079,1080,5,47,0,0,1080,1081,5,140,0,0,1081,1086, + 3,238,119,0,1082,1084,5,140,0,0,1083,1082,1,0,0,0,1083,1084,1,0,0,0,1084, + 1085,1,0,0,0,1085,1087,3,130,65,0,1086,1083,1,0,0,0,1086,1087,1,0,0,0, + 1087,95,1,0,0,0,1088,1089,5,83,0,0,1089,1091,5,140,0,0,1090,1088,1,0, + 0,0,1090,1091,1,0,0,0,1091,1092,1,0,0,0,1092,1094,5,84,0,0,1093,1095, + 5,140,0,0,1094,1093,1,0,0,0,1094,1095,1,0,0,0,1095,1096,1,0,0,0,1096, + 1101,3,132,66,0,1097,1099,5,140,0,0,1098,1097,1,0,0,0,1098,1099,1,0,0, + 0,1099,1100,1,0,0,0,1100,1102,3,130,65,0,1101,1098,1,0,0,0,1101,1102, + 1,0,0,0,1102,97,1,0,0,0,1103,1105,5,85,0,0,1104,1106,5,140,0,0,1105,1104, + 1,0,0,0,1105,1106,1,0,0,0,1106,1107,1,0,0,0,1107,1108,3,172,86,0,1108, + 1109,5,140,0,0,1109,1110,5,95,0,0,1110,1111,5,140,0,0,1111,1112,3,252, + 126,0,1112,99,1,0,0,0,1113,1115,5,86,0,0,1114,1116,5,140,0,0,1115,1114, + 1,0,0,0,1115,1116,1,0,0,0,1116,1117,1,0,0,0,1117,1118,3,132,66,0,1118, + 101,1,0,0,0,1119,1121,5,87,0,0,1120,1122,5,140,0,0,1121,1120,1,0,0,0, + 1121,1122,1,0,0,0,1122,1123,1,0,0,0,1123,1128,3,132,66,0,1124,1125,5, + 140,0,0,1125,1127,3,104,52,0,1126,1124,1,0,0,0,1127,1130,1,0,0,0,1128, + 1126,1,0,0,0,1128,1129,1,0,0,0,1129,103,1,0,0,0,1130,1128,1,0,0,0,1131, + 1132,5,88,0,0,1132,1133,5,140,0,0,1133,1134,5,84,0,0,1134,1135,5,140, + 0,0,1135,1142,3,106,53,0,1136,1137,5,88,0,0,1137,1138,5,140,0,0,1138, + 1139,5,86,0,0,1139,1140,5,140,0,0,1140,1142,3,106,53,0,1141,1131,1,0, + 0,0,1141,1136,1,0,0,0,1142,105,1,0,0,0,1143,1145,5,89,0,0,1144,1146,5, + 140,0,0,1145,1144,1,0,0,0,1145,1146,1,0,0,0,1146,1147,1,0,0,0,1147,1158, + 3,108,54,0,1148,1150,5,140,0,0,1149,1148,1,0,0,0,1149,1150,1,0,0,0,1150, + 1151,1,0,0,0,1151,1153,5,4,0,0,1152,1154,5,140,0,0,1153,1152,1,0,0,0, + 1153,1154,1,0,0,0,1154,1155,1,0,0,0,1155,1157,3,108,54,0,1156,1149,1, + 0,0,0,1157,1160,1,0,0,0,1158,1156,1,0,0,0,1158,1159,1,0,0,0,1159,107, + 1,0,0,0,1160,1158,1,0,0,0,1161,1163,3,258,129,0,1162,1164,5,140,0,0,1163, + 1162,1,0,0,0,1163,1164,1,0,0,0,1164,1165,1,0,0,0,1165,1167,5,5,0,0,1166, + 1168,5,140,0,0,1167,1166,1,0,0,0,1167,1168,1,0,0,0,1168,1169,1,0,0,0, + 1169,1170,3,172,86,0,1170,109,1,0,0,0,1171,1173,5,90,0,0,1172,1174,5, + 140,0,0,1173,1172,1,0,0,0,1173,1174,1,0,0,0,1174,1175,1,0,0,0,1175,1186, + 3,172,86,0,1176,1178,5,140,0,0,1177,1176,1,0,0,0,1177,1178,1,0,0,0,1178, + 1179,1,0,0,0,1179,1181,5,4,0,0,1180,1182,5,140,0,0,1181,1180,1,0,0,0, + 1181,1182,1,0,0,0,1182,1183,1,0,0,0,1183,1185,3,172,86,0,1184,1177,1, + 0,0,0,1185,1188,1,0,0,0,1186,1184,1,0,0,0,1186,1187,1,0,0,0,1187,111, + 1,0,0,0,1188,1186,1,0,0,0,1189,1190,5,91,0,0,1190,1195,3,116,58,0,1191, + 1193,5,140,0,0,1192,1191,1,0,0,0,1192,1193,1,0,0,0,1193,1194,1,0,0,0, + 1194,1196,3,130,65,0,1195,1192,1,0,0,0,1195,1196,1,0,0,0,1196,113,1,0, + 0,0,1197,1198,5,92,0,0,1198,1199,3,116,58,0,1199,115,1,0,0,0,1200,1202, + 5,140,0,0,1201,1200,1,0,0,0,1201,1202,1,0,0,0,1202,1203,1,0,0,0,1203, + 1205,5,93,0,0,1204,1201,1,0,0,0,1204,1205,1,0,0,0,1205,1206,1,0,0,0,1206, + 1207,5,140,0,0,1207,1210,3,118,59,0,1208,1209,5,140,0,0,1209,1211,3,122, + 61,0,1210,1208,1,0,0,0,1210,1211,1,0,0,0,1211,1214,1,0,0,0,1212,1213, + 5,140,0,0,1213,1215,3,124,62,0,1214,1212,1,0,0,0,1214,1215,1,0,0,0,1215, + 1218,1,0,0,0,1216,1217,5,140,0,0,1217,1219,3,126,63,0,1218,1216,1,0,0, + 0,1218,1219,1,0,0,0,1219,117,1,0,0,0,1220,1231,5,94,0,0,1221,1223,5,140, + 0,0,1222,1221,1,0,0,0,1222,1223,1,0,0,0,1223,1224,1,0,0,0,1224,1226,5, + 4,0,0,1225,1227,5,140,0,0,1226,1225,1,0,0,0,1226,1227,1,0,0,0,1227,1228, + 1,0,0,0,1228,1230,3,120,60,0,1229,1222,1,0,0,0,1230,1233,1,0,0,0,1231, + 1229,1,0,0,0,1231,1232,1,0,0,0,1232,1249,1,0,0,0,1233,1231,1,0,0,0,1234, + 1245,3,120,60,0,1235,1237,5,140,0,0,1236,1235,1,0,0,0,1236,1237,1,0,0, + 0,1237,1238,1,0,0,0,1238,1240,5,4,0,0,1239,1241,5,140,0,0,1240,1239,1, + 0,0,0,1240,1241,1,0,0,0,1241,1242,1,0,0,0,1242,1244,3,120,60,0,1243,1236, + 1,0,0,0,1244,1247,1,0,0,0,1245,1243,1,0,0,0,1245,1246,1,0,0,0,1246,1249, + 1,0,0,0,1247,1245,1,0,0,0,1248,1220,1,0,0,0,1248,1234,1,0,0,0,1249,119, + 1,0,0,0,1250,1251,3,172,86,0,1251,1252,5,140,0,0,1252,1253,5,95,0,0,1253, + 1254,5,140,0,0,1254,1255,3,252,126,0,1255,1258,1,0,0,0,1256,1258,3,172, + 86,0,1257,1250,1,0,0,0,1257,1256,1,0,0,0,1258,121,1,0,0,0,1259,1260,5, + 96,0,0,1260,1261,5,140,0,0,1261,1262,5,97,0,0,1262,1263,5,140,0,0,1263, + 1271,3,128,64,0,1264,1266,5,4,0,0,1265,1267,5,140,0,0,1266,1265,1,0,0, + 0,1266,1267,1,0,0,0,1267,1268,1,0,0,0,1268,1270,3,128,64,0,1269,1264, + 1,0,0,0,1270,1273,1,0,0,0,1271,1269,1,0,0,0,1271,1272,1,0,0,0,1272,123, + 1,0,0,0,1273,1271,1,0,0,0,1274,1275,5,98,0,0,1275,1276,5,140,0,0,1276, + 1277,3,172,86,0,1277,125,1,0,0,0,1278,1279,5,99,0,0,1279,1280,5,140,0, + 0,1280,1281,3,172,86,0,1281,127,1,0,0,0,1282,1287,3,172,86,0,1283,1285, + 5,140,0,0,1284,1283,1,0,0,0,1284,1285,1,0,0,0,1285,1286,1,0,0,0,1286, + 1288,7,0,0,0,1287,1284,1,0,0,0,1287,1288,1,0,0,0,1288,129,1,0,0,0,1289, + 1290,5,104,0,0,1290,1291,5,140,0,0,1291,1292,3,172,86,0,1292,131,1,0, + 0,0,1293,1304,3,134,67,0,1294,1296,5,140,0,0,1295,1294,1,0,0,0,1295,1296, + 1,0,0,0,1296,1297,1,0,0,0,1297,1299,5,4,0,0,1298,1300,5,140,0,0,1299, + 1298,1,0,0,0,1299,1300,1,0,0,0,1300,1301,1,0,0,0,1301,1303,3,134,67,0, + 1302,1295,1,0,0,0,1303,1306,1,0,0,0,1304,1302,1,0,0,0,1304,1305,1,0,0, + 0,1305,133,1,0,0,0,1306,1304,1,0,0,0,1307,1309,3,252,126,0,1308,1310, + 5,140,0,0,1309,1308,1,0,0,0,1309,1310,1,0,0,0,1310,1311,1,0,0,0,1311, + 1313,5,5,0,0,1312,1314,5,140,0,0,1313,1312,1,0,0,0,1313,1314,1,0,0,0, + 1314,1315,1,0,0,0,1315,1316,3,136,68,0,1316,1319,1,0,0,0,1317,1319,3, + 136,68,0,1318,1307,1,0,0,0,1318,1317,1,0,0,0,1319,135,1,0,0,0,1320,1321, + 3,138,69,0,1321,137,1,0,0,0,1322,1329,3,140,70,0,1323,1325,5,140,0,0, + 1324,1323,1,0,0,0,1324,1325,1,0,0,0,1325,1326,1,0,0,0,1326,1328,3,142, + 71,0,1327,1324,1,0,0,0,1328,1331,1,0,0,0,1329,1327,1,0,0,0,1329,1330, + 1,0,0,0,1330,1337,1,0,0,0,1331,1329,1,0,0,0,1332,1333,5,2,0,0,1333,1334, + 3,138,69,0,1334,1335,5,3,0,0,1335,1337,1,0,0,0,1336,1322,1,0,0,0,1336, + 1332,1,0,0,0,1337,139,1,0,0,0,1338,1340,5,2,0,0,1339,1341,5,140,0,0,1340, + 1339,1,0,0,0,1340,1341,1,0,0,0,1341,1346,1,0,0,0,1342,1344,3,252,126, + 0,1343,1345,5,140,0,0,1344,1343,1,0,0,0,1344,1345,1,0,0,0,1345,1347,1, + 0,0,0,1346,1342,1,0,0,0,1346,1347,1,0,0,0,1347,1352,1,0,0,0,1348,1350, + 3,152,76,0,1349,1351,5,140,0,0,1350,1349,1,0,0,0,1350,1351,1,0,0,0,1351, + 1353,1,0,0,0,1352,1348,1,0,0,0,1352,1353,1,0,0,0,1353,1358,1,0,0,0,1354, + 1356,3,148,74,0,1355,1357,5,140,0,0,1356,1355,1,0,0,0,1356,1357,1,0,0, + 0,1357,1359,1,0,0,0,1358,1354,1,0,0,0,1358,1359,1,0,0,0,1359,1360,1,0, + 0,0,1360,1361,5,3,0,0,1361,141,1,0,0,0,1362,1364,3,144,72,0,1363,1365, + 5,140,0,0,1364,1363,1,0,0,0,1364,1365,1,0,0,0,1365,1366,1,0,0,0,1366, + 1367,3,140,70,0,1367,143,1,0,0,0,1368,1370,3,272,136,0,1369,1371,5,140, + 0,0,1370,1369,1,0,0,0,1370,1371,1,0,0,0,1371,1372,1,0,0,0,1372,1374,3, + 276,138,0,1373,1375,5,140,0,0,1374,1373,1,0,0,0,1374,1375,1,0,0,0,1375, + 1377,1,0,0,0,1376,1378,3,146,73,0,1377,1376,1,0,0,0,1377,1378,1,0,0,0, + 1378,1380,1,0,0,0,1379,1381,5,140,0,0,1380,1379,1,0,0,0,1380,1381,1,0, + 0,0,1381,1382,1,0,0,0,1382,1383,3,276,138,0,1383,1413,1,0,0,0,1384,1386, + 3,276,138,0,1385,1387,5,140,0,0,1386,1385,1,0,0,0,1386,1387,1,0,0,0,1387, + 1389,1,0,0,0,1388,1390,3,146,73,0,1389,1388,1,0,0,0,1389,1390,1,0,0,0, + 1390,1392,1,0,0,0,1391,1393,5,140,0,0,1392,1391,1,0,0,0,1392,1393,1,0, + 0,0,1393,1394,1,0,0,0,1394,1396,3,276,138,0,1395,1397,5,140,0,0,1396, + 1395,1,0,0,0,1396,1397,1,0,0,0,1397,1398,1,0,0,0,1398,1399,3,274,137, + 0,1399,1413,1,0,0,0,1400,1402,3,276,138,0,1401,1403,5,140,0,0,1402,1401, + 1,0,0,0,1402,1403,1,0,0,0,1403,1405,1,0,0,0,1404,1406,3,146,73,0,1405, + 1404,1,0,0,0,1405,1406,1,0,0,0,1406,1408,1,0,0,0,1407,1409,5,140,0,0, + 1408,1407,1,0,0,0,1408,1409,1,0,0,0,1409,1410,1,0,0,0,1410,1411,3,276, + 138,0,1411,1413,1,0,0,0,1412,1368,1,0,0,0,1412,1384,1,0,0,0,1412,1400, + 1,0,0,0,1413,145,1,0,0,0,1414,1416,5,7,0,0,1415,1417,5,140,0,0,1416,1415, + 1,0,0,0,1416,1417,1,0,0,0,1417,1422,1,0,0,0,1418,1420,3,252,126,0,1419, + 1421,5,140,0,0,1420,1419,1,0,0,0,1420,1421,1,0,0,0,1421,1423,1,0,0,0, + 1422,1418,1,0,0,0,1422,1423,1,0,0,0,1423,1428,1,0,0,0,1424,1426,3,150, + 75,0,1425,1427,5,140,0,0,1426,1425,1,0,0,0,1426,1427,1,0,0,0,1427,1429, + 1,0,0,0,1428,1424,1,0,0,0,1428,1429,1,0,0,0,1429,1434,1,0,0,0,1430,1432, + 3,156,78,0,1431,1433,5,140,0,0,1432,1431,1,0,0,0,1432,1433,1,0,0,0,1433, + 1435,1,0,0,0,1434,1430,1,0,0,0,1434,1435,1,0,0,0,1435,1440,1,0,0,0,1436, + 1438,3,148,74,0,1437,1439,5,140,0,0,1438,1437,1,0,0,0,1438,1439,1,0,0, + 0,1439,1441,1,0,0,0,1440,1436,1,0,0,0,1440,1441,1,0,0,0,1441,1442,1,0, + 0,0,1442,1443,5,8,0,0,1443,147,1,0,0,0,1444,1446,5,9,0,0,1445,1447,5, + 140,0,0,1446,1445,1,0,0,0,1446,1447,1,0,0,0,1447,1481,1,0,0,0,1448,1450, + 3,260,130,0,1449,1451,5,140,0,0,1450,1449,1,0,0,0,1450,1451,1,0,0,0,1451, + 1452,1,0,0,0,1452,1454,5,6,0,0,1453,1455,5,140,0,0,1454,1453,1,0,0,0, + 1454,1455,1,0,0,0,1455,1456,1,0,0,0,1456,1458,3,172,86,0,1457,1459,5, + 140,0,0,1458,1457,1,0,0,0,1458,1459,1,0,0,0,1459,1478,1,0,0,0,1460,1462, + 5,4,0,0,1461,1463,5,140,0,0,1462,1461,1,0,0,0,1462,1463,1,0,0,0,1463, + 1464,1,0,0,0,1464,1466,3,260,130,0,1465,1467,5,140,0,0,1466,1465,1,0, + 0,0,1466,1467,1,0,0,0,1467,1468,1,0,0,0,1468,1470,5,6,0,0,1469,1471,5, + 140,0,0,1470,1469,1,0,0,0,1470,1471,1,0,0,0,1471,1472,1,0,0,0,1472,1474, + 3,172,86,0,1473,1475,5,140,0,0,1474,1473,1,0,0,0,1474,1475,1,0,0,0,1475, + 1477,1,0,0,0,1476,1460,1,0,0,0,1477,1480,1,0,0,0,1478,1476,1,0,0,0,1478, + 1479,1,0,0,0,1479,1482,1,0,0,0,1480,1478,1,0,0,0,1481,1448,1,0,0,0,1481, + 1482,1,0,0,0,1482,1483,1,0,0,0,1483,1484,5,10,0,0,1484,149,1,0,0,0,1485, + 1487,5,6,0,0,1486,1488,5,140,0,0,1487,1486,1,0,0,0,1487,1488,1,0,0,0, + 1488,1489,1,0,0,0,1489,1503,3,170,85,0,1490,1492,5,140,0,0,1491,1490, + 1,0,0,0,1491,1492,1,0,0,0,1492,1493,1,0,0,0,1493,1495,5,11,0,0,1494,1496, + 5,6,0,0,1495,1494,1,0,0,0,1495,1496,1,0,0,0,1496,1498,1,0,0,0,1497,1499, + 5,140,0,0,1498,1497,1,0,0,0,1498,1499,1,0,0,0,1499,1500,1,0,0,0,1500, + 1502,3,170,85,0,1501,1491,1,0,0,0,1502,1505,1,0,0,0,1503,1501,1,0,0,0, + 1503,1504,1,0,0,0,1504,151,1,0,0,0,1505,1503,1,0,0,0,1506,1513,3,154, + 77,0,1507,1509,5,140,0,0,1508,1507,1,0,0,0,1508,1509,1,0,0,0,1509,1510, + 1,0,0,0,1510,1512,3,154,77,0,1511,1508,1,0,0,0,1512,1515,1,0,0,0,1513, + 1511,1,0,0,0,1513,1514,1,0,0,0,1514,153,1,0,0,0,1515,1513,1,0,0,0,1516, + 1518,5,6,0,0,1517,1519,5,140,0,0,1518,1517,1,0,0,0,1518,1519,1,0,0,0, + 1519,1520,1,0,0,0,1520,1521,3,168,84,0,1521,155,1,0,0,0,1522,1524,5,94, + 0,0,1523,1525,5,140,0,0,1524,1523,1,0,0,0,1524,1525,1,0,0,0,1525,1530, + 1,0,0,0,1526,1531,5,105,0,0,1527,1528,5,80,0,0,1528,1529,5,140,0,0,1529, + 1531,5,105,0,0,1530,1526,1,0,0,0,1530,1527,1,0,0,0,1530,1531,1,0,0,0, + 1531,1533,1,0,0,0,1532,1534,5,140,0,0,1533,1532,1,0,0,0,1533,1534,1,0, + 0,0,1534,1549,1,0,0,0,1535,1537,3,164,82,0,1536,1535,1,0,0,0,1536,1537, + 1,0,0,0,1537,1539,1,0,0,0,1538,1540,5,140,0,0,1539,1538,1,0,0,0,1539, + 1540,1,0,0,0,1540,1541,1,0,0,0,1541,1543,5,12,0,0,1542,1544,5,140,0,0, + 1543,1542,1,0,0,0,1543,1544,1,0,0,0,1544,1546,1,0,0,0,1545,1547,3,166, + 83,0,1546,1545,1,0,0,0,1546,1547,1,0,0,0,1547,1550,1,0,0,0,1548,1550, + 3,262,131,0,1549,1536,1,0,0,0,1549,1548,1,0,0,0,1549,1550,1,0,0,0,1550, + 1555,1,0,0,0,1551,1553,5,140,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,1552,1,0,0,0,1555,1556,1, + 0,0,0,1556,157,1,0,0,0,1557,1559,5,2,0,0,1558,1560,5,140,0,0,1559,1558, + 1,0,0,0,1559,1560,1,0,0,0,1560,1561,1,0,0,0,1561,1563,3,252,126,0,1562, + 1564,5,140,0,0,1563,1562,1,0,0,0,1563,1564,1,0,0,0,1564,1565,1,0,0,0, + 1565,1567,5,4,0,0,1566,1568,5,140,0,0,1567,1566,1,0,0,0,1567,1568,1,0, + 0,0,1568,1569,1,0,0,0,1569,1578,3,252,126,0,1570,1572,5,140,0,0,1571, + 1570,1,0,0,0,1571,1572,1,0,0,0,1572,1573,1,0,0,0,1573,1575,5,11,0,0,1574, + 1576,5,140,0,0,1575,1574,1,0,0,0,1575,1576,1,0,0,0,1576,1577,1,0,0,0, + 1577,1579,3,130,65,0,1578,1571,1,0,0,0,1578,1579,1,0,0,0,1579,1599,1, + 0,0,0,1580,1582,5,140,0,0,1581,1580,1,0,0,0,1581,1582,1,0,0,0,1582,1583, + 1,0,0,0,1583,1585,5,11,0,0,1584,1586,5,140,0,0,1585,1584,1,0,0,0,1585, + 1586,1,0,0,0,1586,1587,1,0,0,0,1587,1589,3,162,81,0,1588,1590,5,140,0, + 0,1589,1588,1,0,0,0,1589,1590,1,0,0,0,1590,1591,1,0,0,0,1591,1593,5,4, + 0,0,1592,1594,5,140,0,0,1593,1592,1,0,0,0,1593,1594,1,0,0,0,1594,1595, + 1,0,0,0,1595,1597,3,160,80,0,1596,1598,5,140,0,0,1597,1596,1,0,0,0,1597, + 1598,1,0,0,0,1598,1600,1,0,0,0,1599,1581,1,0,0,0,1599,1600,1,0,0,0,1600, + 1601,1,0,0,0,1601,1602,5,3,0,0,1602,159,1,0,0,0,1603,1605,5,9,0,0,1604, + 1606,5,140,0,0,1605,1604,1,0,0,0,1605,1606,1,0,0,0,1606,1608,1,0,0,0, + 1607,1609,3,118,59,0,1608,1607,1,0,0,0,1608,1609,1,0,0,0,1609,1611,1, + 0,0,0,1610,1612,5,140,0,0,1611,1610,1,0,0,0,1611,1612,1,0,0,0,1612,1613, + 1,0,0,0,1613,1614,5,10,0,0,1614,161,1,0,0,0,1615,1617,5,9,0,0,1616,1618, + 5,140,0,0,1617,1616,1,0,0,0,1617,1618,1,0,0,0,1618,1620,1,0,0,0,1619, + 1621,3,118,59,0,1620,1619,1,0,0,0,1620,1621,1,0,0,0,1621,1623,1,0,0,0, + 1622,1624,5,140,0,0,1623,1622,1,0,0,0,1623,1624,1,0,0,0,1624,1625,1,0, + 0,0,1625,1626,5,10,0,0,1626,163,1,0,0,0,1627,1628,5,128,0,0,1628,165, + 1,0,0,0,1629,1630,5,128,0,0,1630,167,1,0,0,0,1631,1632,3,266,133,0,1632, + 169,1,0,0,0,1633,1634,3,266,133,0,1634,171,1,0,0,0,1635,1636,3,174,87, + 0,1636,173,1,0,0,0,1637,1644,3,176,88,0,1638,1639,5,140,0,0,1639,1640, + 5,106,0,0,1640,1641,5,140,0,0,1641,1643,3,176,88,0,1642,1638,1,0,0,0, + 1643,1646,1,0,0,0,1644,1642,1,0,0,0,1644,1645,1,0,0,0,1645,175,1,0,0, + 0,1646,1644,1,0,0,0,1647,1654,3,178,89,0,1648,1649,5,140,0,0,1649,1650, + 5,107,0,0,1650,1651,5,140,0,0,1651,1653,3,178,89,0,1652,1648,1,0,0,0, + 1653,1656,1,0,0,0,1654,1652,1,0,0,0,1654,1655,1,0,0,0,1655,177,1,0,0, + 0,1656,1654,1,0,0,0,1657,1664,3,180,90,0,1658,1659,5,140,0,0,1659,1660, + 5,108,0,0,1660,1661,5,140,0,0,1661,1663,3,180,90,0,1662,1658,1,0,0,0, + 1663,1666,1,0,0,0,1664,1662,1,0,0,0,1664,1665,1,0,0,0,1665,179,1,0,0, + 0,1666,1664,1,0,0,0,1667,1669,5,109,0,0,1668,1670,5,140,0,0,1669,1668, + 1,0,0,0,1669,1670,1,0,0,0,1670,1672,1,0,0,0,1671,1667,1,0,0,0,1671,1672, + 1,0,0,0,1672,1673,1,0,0,0,1673,1674,3,182,91,0,1674,181,1,0,0,0,1675, + 1685,3,186,93,0,1676,1678,5,140,0,0,1677,1676,1,0,0,0,1677,1678,1,0,0, + 0,1678,1679,1,0,0,0,1679,1681,3,184,92,0,1680,1682,5,140,0,0,1681,1680, + 1,0,0,0,1681,1682,1,0,0,0,1682,1683,1,0,0,0,1683,1684,3,186,93,0,1684, + 1686,1,0,0,0,1685,1677,1,0,0,0,1685,1686,1,0,0,0,1686,1724,1,0,0,0,1687, + 1689,3,186,93,0,1688,1690,5,140,0,0,1689,1688,1,0,0,0,1689,1690,1,0,0, + 0,1690,1691,1,0,0,0,1691,1693,5,110,0,0,1692,1694,5,140,0,0,1693,1692, + 1,0,0,0,1693,1694,1,0,0,0,1694,1695,1,0,0,0,1695,1696,3,186,93,0,1696, + 1697,1,0,0,0,1697,1698,6,91,-1,0,1698,1724,1,0,0,0,1699,1701,3,186,93, + 0,1700,1702,5,140,0,0,1701,1700,1,0,0,0,1701,1702,1,0,0,0,1702,1703,1, + 0,0,0,1703,1705,3,184,92,0,1704,1706,5,140,0,0,1705,1704,1,0,0,0,1705, + 1706,1,0,0,0,1706,1707,1,0,0,0,1707,1717,3,186,93,0,1708,1710,5,140,0, + 0,1709,1708,1,0,0,0,1709,1710,1,0,0,0,1710,1711,1,0,0,0,1711,1713,3,184, + 92,0,1712,1714,5,140,0,0,1713,1712,1,0,0,0,1713,1714,1,0,0,0,1714,1715, + 1,0,0,0,1715,1716,3,186,93,0,1716,1718,1,0,0,0,1717,1709,1,0,0,0,1718, + 1719,1,0,0,0,1719,1717,1,0,0,0,1719,1720,1,0,0,0,1720,1721,1,0,0,0,1721, + 1722,6,91,-1,0,1722,1724,1,0,0,0,1723,1675,1,0,0,0,1723,1687,1,0,0,0, + 1723,1699,1,0,0,0,1724,183,1,0,0,0,1725,1726,7,1,0,0,1726,185,1,0,0,0, + 1727,1738,3,188,94,0,1728,1730,5,140,0,0,1729,1728,1,0,0,0,1729,1730, + 1,0,0,0,1730,1731,1,0,0,0,1731,1733,5,11,0,0,1732,1734,5,140,0,0,1733, + 1732,1,0,0,0,1733,1734,1,0,0,0,1734,1735,1,0,0,0,1735,1737,3,188,94,0, + 1736,1729,1,0,0,0,1737,1740,1,0,0,0,1738,1736,1,0,0,0,1738,1739,1,0,0, + 0,1739,187,1,0,0,0,1740,1738,1,0,0,0,1741,1752,3,190,95,0,1742,1744,5, + 140,0,0,1743,1742,1,0,0,0,1743,1744,1,0,0,0,1744,1745,1,0,0,0,1745,1747, + 5,18,0,0,1746,1748,5,140,0,0,1747,1746,1,0,0,0,1747,1748,1,0,0,0,1748, + 1749,1,0,0,0,1749,1751,3,190,95,0,1750,1743,1,0,0,0,1751,1754,1,0,0,0, + 1752,1750,1,0,0,0,1752,1753,1,0,0,0,1753,189,1,0,0,0,1754,1752,1,0,0, + 0,1755,1767,3,194,97,0,1756,1758,5,140,0,0,1757,1756,1,0,0,0,1757,1758, + 1,0,0,0,1758,1759,1,0,0,0,1759,1761,3,192,96,0,1760,1762,5,140,0,0,1761, + 1760,1,0,0,0,1761,1762,1,0,0,0,1762,1763,1,0,0,0,1763,1764,3,194,97,0, + 1764,1766,1,0,0,0,1765,1757,1,0,0,0,1766,1769,1,0,0,0,1767,1765,1,0,0, + 0,1767,1768,1,0,0,0,1768,191,1,0,0,0,1769,1767,1,0,0,0,1770,1771,7,2, + 0,0,1771,193,1,0,0,0,1772,1784,3,198,99,0,1773,1775,5,140,0,0,1774,1773, + 1,0,0,0,1774,1775,1,0,0,0,1775,1776,1,0,0,0,1776,1778,3,196,98,0,1777, + 1779,5,140,0,0,1778,1777,1,0,0,0,1778,1779,1,0,0,0,1779,1780,1,0,0,0, + 1780,1781,3,198,99,0,1781,1783,1,0,0,0,1782,1774,1,0,0,0,1783,1786,1, + 0,0,0,1784,1782,1,0,0,0,1784,1785,1,0,0,0,1785,195,1,0,0,0,1786,1784, + 1,0,0,0,1787,1788,7,3,0,0,1788,197,1,0,0,0,1789,1801,3,202,101,0,1790, + 1792,5,140,0,0,1791,1790,1,0,0,0,1791,1792,1,0,0,0,1792,1793,1,0,0,0, + 1793,1795,3,200,100,0,1794,1796,5,140,0,0,1795,1794,1,0,0,0,1795,1796, + 1,0,0,0,1796,1797,1,0,0,0,1797,1798,3,202,101,0,1798,1800,1,0,0,0,1799, + 1791,1,0,0,0,1800,1803,1,0,0,0,1801,1799,1,0,0,0,1801,1802,1,0,0,0,1802, + 199,1,0,0,0,1803,1801,1,0,0,0,1804,1805,7,4,0,0,1805,201,1,0,0,0,1806, + 1817,3,204,102,0,1807,1809,5,140,0,0,1808,1807,1,0,0,0,1808,1809,1,0, + 0,0,1809,1810,1,0,0,0,1810,1812,5,24,0,0,1811,1813,5,140,0,0,1812,1811, + 1,0,0,0,1812,1813,1,0,0,0,1813,1814,1,0,0,0,1814,1816,3,204,102,0,1815, + 1808,1,0,0,0,1816,1819,1,0,0,0,1817,1815,1,0,0,0,1817,1818,1,0,0,0,1818, + 203,1,0,0,0,1819,1817,1,0,0,0,1820,1822,5,111,0,0,1821,1823,5,140,0,0, + 1822,1821,1,0,0,0,1822,1823,1,0,0,0,1823,1825,1,0,0,0,1824,1820,1,0,0, + 0,1824,1825,1,0,0,0,1825,1826,1,0,0,0,1826,1831,3,206,103,0,1827,1829, + 5,140,0,0,1828,1827,1,0,0,0,1828,1829,1,0,0,0,1829,1830,1,0,0,0,1830, + 1832,5,112,0,0,1831,1828,1,0,0,0,1831,1832,1,0,0,0,1832,205,1,0,0,0,1833, + 1841,3,220,110,0,1834,1842,3,214,107,0,1835,1837,3,208,104,0,1836,1835, + 1,0,0,0,1837,1838,1,0,0,0,1838,1836,1,0,0,0,1838,1839,1,0,0,0,1839,1842, + 1,0,0,0,1840,1842,3,218,109,0,1841,1834,1,0,0,0,1841,1836,1,0,0,0,1841, + 1840,1,0,0,0,1841,1842,1,0,0,0,1842,207,1,0,0,0,1843,1846,3,210,105,0, + 1844,1846,3,212,106,0,1845,1843,1,0,0,0,1845,1844,1,0,0,0,1846,209,1, + 0,0,0,1847,1848,5,7,0,0,1848,1849,3,172,86,0,1849,1850,5,8,0,0,1850,211, + 1,0,0,0,1851,1853,5,7,0,0,1852,1854,3,172,86,0,1853,1852,1,0,0,0,1853, + 1854,1,0,0,0,1854,1855,1,0,0,0,1855,1857,5,6,0,0,1856,1858,3,172,86,0, + 1857,1856,1,0,0,0,1857,1858,1,0,0,0,1858,1859,1,0,0,0,1859,1860,5,8,0, + 0,1860,213,1,0,0,0,1861,1873,3,216,108,0,1862,1863,5,140,0,0,1863,1864, + 5,113,0,0,1864,1865,5,140,0,0,1865,1873,5,91,0,0,1866,1867,5,140,0,0, + 1867,1868,5,114,0,0,1868,1869,5,140,0,0,1869,1873,5,91,0,0,1870,1871, + 5,140,0,0,1871,1873,5,115,0,0,1872,1861,1,0,0,0,1872,1862,1,0,0,0,1872, + 1866,1,0,0,0,1872,1870,1,0,0,0,1873,1875,1,0,0,0,1874,1876,5,140,0,0, + 1875,1874,1,0,0,0,1875,1876,1,0,0,0,1876,1877,1,0,0,0,1877,1878,3,220, + 110,0,1878,215,1,0,0,0,1879,1881,5,140,0,0,1880,1879,1,0,0,0,1880,1881, + 1,0,0,0,1881,1882,1,0,0,0,1882,1883,5,25,0,0,1883,217,1,0,0,0,1884,1885, + 5,140,0,0,1885,1886,5,116,0,0,1886,1887,5,140,0,0,1887,1895,5,117,0,0, + 1888,1889,5,140,0,0,1889,1890,5,116,0,0,1890,1891,5,140,0,0,1891,1892, + 5,109,0,0,1892,1893,5,140,0,0,1893,1895,5,117,0,0,1894,1884,1,0,0,0,1894, + 1888,1,0,0,0,1895,219,1,0,0,0,1896,1903,3,222,111,0,1897,1899,5,140,0, + 0,1898,1897,1,0,0,0,1898,1899,1,0,0,0,1899,1900,1,0,0,0,1900,1902,3,246, + 123,0,1901,1898,1,0,0,0,1902,1905,1,0,0,0,1903,1901,1,0,0,0,1903,1904, + 1,0,0,0,1904,221,1,0,0,0,1905,1903,1,0,0,0,1906,1914,3,224,112,0,1907, + 1914,3,256,128,0,1908,1914,3,248,124,0,1909,1914,3,236,118,0,1910,1914, + 3,238,119,0,1911,1914,3,244,122,0,1912,1914,3,252,126,0,1913,1906,1,0, + 0,0,1913,1907,1,0,0,0,1913,1908,1,0,0,0,1913,1909,1,0,0,0,1913,1910,1, + 0,0,0,1913,1911,1,0,0,0,1913,1912,1,0,0,0,1914,223,1,0,0,0,1915,1922, + 3,254,127,0,1916,1922,5,126,0,0,1917,1922,3,226,113,0,1918,1922,5,117, + 0,0,1919,1922,3,228,114,0,1920,1922,3,232,116,0,1921,1915,1,0,0,0,1921, + 1916,1,0,0,0,1921,1917,1,0,0,0,1921,1918,1,0,0,0,1921,1919,1,0,0,0,1921, + 1920,1,0,0,0,1922,225,1,0,0,0,1923,1924,7,5,0,0,1924,227,1,0,0,0,1925, + 1927,5,7,0,0,1926,1928,5,140,0,0,1927,1926,1,0,0,0,1927,1928,1,0,0,0, + 1928,1942,1,0,0,0,1929,1931,3,172,86,0,1930,1932,5,140,0,0,1931,1930, + 1,0,0,0,1931,1932,1,0,0,0,1932,1939,1,0,0,0,1933,1935,3,230,115,0,1934, + 1936,5,140,0,0,1935,1934,1,0,0,0,1935,1936,1,0,0,0,1936,1938,1,0,0,0, + 1937,1933,1,0,0,0,1938,1941,1,0,0,0,1939,1937,1,0,0,0,1939,1940,1,0,0, + 0,1940,1943,1,0,0,0,1941,1939,1,0,0,0,1942,1929,1,0,0,0,1942,1943,1,0, + 0,0,1943,1944,1,0,0,0,1944,1945,5,8,0,0,1945,229,1,0,0,0,1946,1948,5, + 4,0,0,1947,1949,5,140,0,0,1948,1947,1,0,0,0,1948,1949,1,0,0,0,1949,1951, + 1,0,0,0,1950,1952,3,172,86,0,1951,1950,1,0,0,0,1951,1952,1,0,0,0,1952, + 231,1,0,0,0,1953,1955,5,9,0,0,1954,1956,5,140,0,0,1955,1954,1,0,0,0,1955, + 1956,1,0,0,0,1956,1957,1,0,0,0,1957,1959,3,234,117,0,1958,1960,5,140, + 0,0,1959,1958,1,0,0,0,1959,1960,1,0,0,0,1960,1971,1,0,0,0,1961,1963,5, + 4,0,0,1962,1964,5,140,0,0,1963,1962,1,0,0,0,1963,1964,1,0,0,0,1964,1965, + 1,0,0,0,1965,1967,3,234,117,0,1966,1968,5,140,0,0,1967,1966,1,0,0,0,1967, + 1968,1,0,0,0,1968,1970,1,0,0,0,1969,1961,1,0,0,0,1970,1973,1,0,0,0,1971, + 1969,1,0,0,0,1971,1972,1,0,0,0,1972,1974,1,0,0,0,1973,1971,1,0,0,0,1974, + 1975,5,10,0,0,1975,233,1,0,0,0,1976,1979,3,268,134,0,1977,1979,5,126, + 0,0,1978,1976,1,0,0,0,1978,1977,1,0,0,0,1979,1981,1,0,0,0,1980,1982,5, + 140,0,0,1981,1980,1,0,0,0,1981,1982,1,0,0,0,1982,1983,1,0,0,0,1983,1985, + 5,6,0,0,1984,1986,5,140,0,0,1985,1984,1,0,0,0,1985,1986,1,0,0,0,1986, + 1987,1,0,0,0,1987,1988,3,172,86,0,1988,235,1,0,0,0,1989,1991,5,2,0,0, + 1990,1992,5,140,0,0,1991,1990,1,0,0,0,1991,1992,1,0,0,0,1992,1993,1,0, + 0,0,1993,1995,3,172,86,0,1994,1996,5,140,0,0,1995,1994,1,0,0,0,1995,1996, + 1,0,0,0,1996,1997,1,0,0,0,1997,1998,5,3,0,0,1998,237,1,0,0,0,1999,2001, + 3,240,120,0,2000,2002,5,140,0,0,2001,2000,1,0,0,0,2001,2002,1,0,0,0,2002, + 2003,1,0,0,0,2003,2005,5,2,0,0,2004,2006,5,140,0,0,2005,2004,1,0,0,0, + 2005,2006,1,0,0,0,2006,2007,1,0,0,0,2007,2009,5,94,0,0,2008,2010,5,140, + 0,0,2009,2008,1,0,0,0,2009,2010,1,0,0,0,2010,2011,1,0,0,0,2011,2012,5, + 3,0,0,2012,2049,1,0,0,0,2013,2015,3,240,120,0,2014,2016,5,140,0,0,2015, + 2014,1,0,0,0,2015,2016,1,0,0,0,2016,2017,1,0,0,0,2017,2019,5,2,0,0,2018, + 2020,5,140,0,0,2019,2018,1,0,0,0,2019,2020,1,0,0,0,2020,2025,1,0,0,0, + 2021,2023,5,93,0,0,2022,2024,5,140,0,0,2023,2022,1,0,0,0,2023,2024,1, + 0,0,0,2024,2026,1,0,0,0,2025,2021,1,0,0,0,2025,2026,1,0,0,0,2026,2044, + 1,0,0,0,2027,2029,3,242,121,0,2028,2030,5,140,0,0,2029,2028,1,0,0,0,2029, + 2030,1,0,0,0,2030,2041,1,0,0,0,2031,2033,5,4,0,0,2032,2034,5,140,0,0, + 2033,2032,1,0,0,0,2033,2034,1,0,0,0,2034,2035,1,0,0,0,2035,2037,3,242, + 121,0,2036,2038,5,140,0,0,2037,2036,1,0,0,0,2037,2038,1,0,0,0,2038,2040, + 1,0,0,0,2039,2031,1,0,0,0,2040,2043,1,0,0,0,2041,2039,1,0,0,0,2041,2042, + 1,0,0,0,2042,2045,1,0,0,0,2043,2041,1,0,0,0,2044,2027,1,0,0,0,2044,2045, + 1,0,0,0,2045,2046,1,0,0,0,2046,2047,5,3,0,0,2047,2049,1,0,0,0,2048,1999, + 1,0,0,0,2048,2013,1,0,0,0,2049,239,1,0,0,0,2050,2051,3,268,134,0,2051, + 241,1,0,0,0,2052,2054,3,268,134,0,2053,2055,5,140,0,0,2054,2053,1,0,0, + 0,2054,2055,1,0,0,0,2055,2056,1,0,0,0,2056,2057,5,6,0,0,2057,2059,5,5, + 0,0,2058,2060,5,140,0,0,2059,2058,1,0,0,0,2059,2060,1,0,0,0,2060,2062, + 1,0,0,0,2061,2052,1,0,0,0,2061,2062,1,0,0,0,2062,2063,1,0,0,0,2063,2064, + 3,172,86,0,2064,243,1,0,0,0,2065,2067,5,120,0,0,2066,2068,5,140,0,0,2067, + 2066,1,0,0,0,2067,2068,1,0,0,0,2068,2069,1,0,0,0,2069,2071,5,9,0,0,2070, + 2072,5,140,0,0,2071,2070,1,0,0,0,2071,2072,1,0,0,0,2072,2073,1,0,0,0, + 2073,2075,5,84,0,0,2074,2076,5,140,0,0,2075,2074,1,0,0,0,2075,2076,1, + 0,0,0,2076,2077,1,0,0,0,2077,2082,3,132,66,0,2078,2080,5,140,0,0,2079, + 2078,1,0,0,0,2079,2080,1,0,0,0,2080,2081,1,0,0,0,2081,2083,3,130,65,0, + 2082,2079,1,0,0,0,2082,2083,1,0,0,0,2083,2085,1,0,0,0,2084,2086,5,140, + 0,0,2085,2084,1,0,0,0,2085,2086,1,0,0,0,2086,2087,1,0,0,0,2087,2088,5, + 10,0,0,2088,245,1,0,0,0,2089,2091,5,26,0,0,2090,2092,5,140,0,0,2091,2090, + 1,0,0,0,2091,2092,1,0,0,0,2092,2095,1,0,0,0,2093,2096,3,260,130,0,2094, + 2096,5,94,0,0,2095,2093,1,0,0,0,2095,2094,1,0,0,0,2096,247,1,0,0,0,2097, + 2102,5,121,0,0,2098,2100,5,140,0,0,2099,2098,1,0,0,0,2099,2100,1,0,0, + 0,2100,2101,1,0,0,0,2101,2103,3,250,125,0,2102,2099,1,0,0,0,2103,2104, + 1,0,0,0,2104,2102,1,0,0,0,2104,2105,1,0,0,0,2105,2120,1,0,0,0,2106,2108, + 5,121,0,0,2107,2109,5,140,0,0,2108,2107,1,0,0,0,2108,2109,1,0,0,0,2109, + 2110,1,0,0,0,2110,2115,3,172,86,0,2111,2113,5,140,0,0,2112,2111,1,0,0, + 0,2112,2113,1,0,0,0,2113,2114,1,0,0,0,2114,2116,3,250,125,0,2115,2112, + 1,0,0,0,2116,2117,1,0,0,0,2117,2115,1,0,0,0,2117,2118,1,0,0,0,2118,2120, + 1,0,0,0,2119,2097,1,0,0,0,2119,2106,1,0,0,0,2120,2129,1,0,0,0,2121,2123, + 5,140,0,0,2122,2121,1,0,0,0,2122,2123,1,0,0,0,2123,2124,1,0,0,0,2124, + 2126,5,122,0,0,2125,2127,5,140,0,0,2126,2125,1,0,0,0,2126,2127,1,0,0, + 0,2127,2128,1,0,0,0,2128,2130,3,172,86,0,2129,2122,1,0,0,0,2129,2130, + 1,0,0,0,2130,2132,1,0,0,0,2131,2133,5,140,0,0,2132,2131,1,0,0,0,2132, + 2133,1,0,0,0,2133,2134,1,0,0,0,2134,2135,5,123,0,0,2135,249,1,0,0,0,2136, + 2138,5,124,0,0,2137,2139,5,140,0,0,2138,2137,1,0,0,0,2138,2139,1,0,0, + 0,2139,2140,1,0,0,0,2140,2142,3,172,86,0,2141,2143,5,140,0,0,2142,2141, + 1,0,0,0,2142,2143,1,0,0,0,2143,2144,1,0,0,0,2144,2146,5,125,0,0,2145, + 2147,5,140,0,0,2146,2145,1,0,0,0,2146,2147,1,0,0,0,2147,2148,1,0,0,0, + 2148,2149,3,172,86,0,2149,251,1,0,0,0,2150,2151,3,268,134,0,2151,253, + 1,0,0,0,2152,2155,3,264,132,0,2153,2155,3,262,131,0,2154,2152,1,0,0,0, + 2154,2153,1,0,0,0,2155,255,1,0,0,0,2156,2159,5,27,0,0,2157,2160,3,268, + 134,0,2158,2160,5,128,0,0,2159,2157,1,0,0,0,2159,2158,1,0,0,0,2160,257, + 1,0,0,0,2161,2163,3,222,111,0,2162,2164,5,140,0,0,2163,2162,1,0,0,0,2163, + 2164,1,0,0,0,2164,2165,1,0,0,0,2165,2166,3,246,123,0,2166,259,1,0,0,0, + 2167,2168,3,266,133,0,2168,261,1,0,0,0,2169,2170,5,128,0,0,2170,263,1, + 0,0,0,2171,2172,5,135,0,0,2172,265,1,0,0,0,2173,2174,3,268,134,0,2174, + 267,1,0,0,0,2175,2181,5,136,0,0,2176,2177,5,139,0,0,2177,2181,6,134,-1, + 0,2178,2181,5,129,0,0,2179,2181,3,270,135,0,2180,2175,1,0,0,0,2180,2176, + 1,0,0,0,2180,2178,1,0,0,0,2180,2179,1,0,0,0,2181,269,1,0,0,0,2182,2183, + 5,48,0,0,2183,271,1,0,0,0,2184,2185,7,6,0,0,2185,273,1,0,0,0,2186,2187, + 7,7,0,0,2187,275,1,0,0,0,2188,2189,7,8,0,0,2189,277,1,0,0,0,381,279,282, + 285,289,292,295,308,314,318,322,326,329,335,339,343,347,351,355,360,371, + 375,379,384,397,401,409,413,417,421,427,431,453,457,460,463,466,469,473, + 478,482,492,496,501,506,511,517,521,525,530,537,541,545,548,552,556,561, + 566,570,580,590,594,598,602,607,619,623,627,631,635,637,641,645,647,661, + 665,669,673,678,681,685,689,691,695,699,701,739,750,772,776,781,792,796, + 800,808,812,816,822,826,830,836,840,844,848,852,856,862,869,874,880,900, + 906,911,916,920,925,931,936,939,943,947,951,957,961,966,971,975,978,982, + 986,990,994,998,1004,1008,1013,1017,1026,1032,1040,1044,1048,1052,1059, + 1063,1067,1071,1074,1077,1083,1086,1090,1094,1098,1101,1105,1115,1121, + 1128,1141,1145,1149,1153,1158,1163,1167,1173,1177,1181,1186,1192,1195, + 1201,1204,1210,1214,1218,1222,1226,1231,1236,1240,1245,1248,1257,1266, + 1271,1284,1287,1295,1299,1304,1309,1313,1318,1324,1329,1336,1340,1344, + 1346,1350,1352,1356,1358,1364,1370,1374,1377,1380,1386,1389,1392,1396, + 1402,1405,1408,1412,1416,1420,1422,1426,1428,1432,1434,1438,1440,1446, + 1450,1454,1458,1462,1466,1470,1474,1478,1481,1487,1491,1495,1498,1503, + 1508,1513,1518,1524,1530,1533,1536,1539,1543,1546,1549,1552,1555,1559, + 1563,1567,1571,1575,1578,1581,1585,1589,1593,1597,1599,1605,1608,1611, + 1617,1620,1623,1644,1654,1664,1669,1671,1677,1681,1685,1689,1693,1701, + 1705,1709,1713,1719,1723,1729,1733,1738,1743,1747,1752,1757,1761,1767, + 1774,1778,1784,1791,1795,1801,1808,1812,1817,1822,1824,1828,1831,1838, + 1841,1845,1853,1857,1872,1875,1880,1894,1898,1903,1913,1921,1927,1931, + 1935,1939,1942,1948,1951,1955,1959,1963,1967,1971,1978,1981,1985,1991, + 1995,2001,2005,2009,2015,2019,2023,2025,2029,2033,2037,2041,2044,2048, + 2054,2059,2061,2067,2071,2075,2079,2082,2085,2091,2095,2099,2104,2108, + 2112,2117,2119,2122,2126,2129,2132,2138,2142,2146,2154,2159,2163,2180 }; staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); @@ -1059,12 +1073,12 @@ CypherParser::OC_CypherContext* CypherParser::oC_Cypher() { }); try { enterOuterAlt(_localctx, 1); - setState(277); + setState(279); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 0, _ctx)) { case 1: { - setState(276); + setState(278); match(CypherParser::SP); break; } @@ -1072,41 +1086,41 @@ CypherParser::OC_CypherContext* CypherParser::oC_Cypher() { default: break; } - setState(280); + setState(282); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::EXPLAIN || _la == CypherParser::PROFILE) { - setState(279); + setState(281); oC_AnyCypherOption(); } - setState(283); + setState(285); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(282); + setState(284); match(CypherParser::SP); } - setState(285); + setState(287); oC_Statement(); - setState(290); + setState(292); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 4, _ctx)) { case 1: { - setState(287); + setState(289); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(286); + setState(288); match(CypherParser::SP); } - setState(289); + setState(291); match(CypherParser::T__0); break; } @@ -1114,15 +1128,15 @@ CypherParser::OC_CypherContext* CypherParser::oC_Cypher() { default: break; } - setState(293); + setState(295); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(292); + setState(294); match(CypherParser::SP); } - setState(295); + setState(297); match(CypherParser::EOF); } @@ -1195,68 +1209,68 @@ CypherParser::OC_StatementContext* CypherParser::oC_Statement() { exitRule(); }); try { - setState(306); + setState(308); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict(_input, 6, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(297); + setState(299); oC_Query(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(298); + setState(300); kU_DDL(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(299); + setState(301); kU_CopyFrom(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(300); + setState(302); kU_CopyFromByColumn(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(301); + setState(303); kU_CopyTO(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(302); + setState(304); kU_StandaloneCall(); break; } case 7: { enterOuterAlt(_localctx, 7); - setState(303); + setState(305); kU_CreateMacro(); break; } case 8: { enterOuterAlt(_localctx, 8); - setState(304); + setState(306); kU_CommentOn(); break; } case 9: { enterOuterAlt(_localctx, 9); - setState(305); + setState(307); kU_Transaction(); break; } @@ -1309,6 +1323,10 @@ CypherParser::KU_ParsingOptionsContext* CypherParser::KU_CopyFromContext::kU_Par return getRuleContext(0); } +CypherParser::KU_ColumnNamesContext* CypherParser::KU_CopyFromContext::kU_ColumnNames() { + return getRuleContext(0); +} + size_t CypherParser::KU_CopyFromContext::getRuleIndex() const { return CypherParser::RuleKU_CopyFrom; @@ -1329,54 +1347,106 @@ CypherParser::KU_CopyFromContext* CypherParser::kU_CopyFrom() { }); try { enterOuterAlt(_localctx, 1); - setState(308); - match(CypherParser::COPY); - setState(309); - match(CypherParser::SP); setState(310); - oC_SchemaName(); + match(CypherParser::COPY); setState(311); match(CypherParser::SP); setState(312); + oC_SchemaName(); + setState(329); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { + case 1: { + setState(314); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(313); + match(CypherParser::SP); + } + setState(316); + match(CypherParser::T__1); + setState(318); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(317); + match(CypherParser::SP); + } + setState(320); + kU_ColumnNames(); + setState(322); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(321); + match(CypherParser::SP); + } + setState(324); + match(CypherParser::T__2); + setState(326); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(325); + match(CypherParser::SP); + } + break; + } + + case 2: { + setState(328); + match(CypherParser::SP); + break; + } + + default: + break; + } + setState(331); match(CypherParser::FROM); - setState(313); + setState(332); match(CypherParser::SP); - setState(314); + setState(333); kU_FilePaths(); - setState(328); + setState(347); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 15, _ctx)) { case 1: { - setState(316); + setState(335); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(315); + setState(334); match(CypherParser::SP); } - setState(318); + setState(337); match(CypherParser::T__1); - setState(320); + setState(339); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(319); + setState(338); match(CypherParser::SP); } - setState(322); + setState(341); kU_ParsingOptions(); - setState(324); + setState(343); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(323); + setState(342); match(CypherParser::SP); } - setState(326); + setState(345); match(CypherParser::T__2); break; } @@ -1395,6 +1465,92 @@ CypherParser::KU_CopyFromContext* CypherParser::kU_CopyFrom() { return _localctx; } +//----------------- KU_ColumnNamesContext ------------------------------------------------------------------ + +CypherParser::KU_ColumnNamesContext::KU_ColumnNamesContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector CypherParser::KU_ColumnNamesContext::oC_SchemaName() { + return getRuleContexts(); +} + +CypherParser::OC_SchemaNameContext* CypherParser::KU_ColumnNamesContext::oC_SchemaName(size_t i) { + return getRuleContext(i); +} + +std::vector CypherParser::KU_ColumnNamesContext::SP() { + return getTokens(CypherParser::SP); +} + +tree::TerminalNode* CypherParser::KU_ColumnNamesContext::SP(size_t i) { + return getToken(CypherParser::SP, i); +} + + +size_t CypherParser::KU_ColumnNamesContext::getRuleIndex() const { + return CypherParser::RuleKU_ColumnNames; +} + + +CypherParser::KU_ColumnNamesContext* CypherParser::kU_ColumnNames() { + KU_ColumnNamesContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 6, CypherParser::RuleKU_ColumnNames); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + size_t alt; + enterOuterAlt(_localctx, 1); + setState(349); + oC_SchemaName(); + setState(360); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 18, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(351); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(350); + match(CypherParser::SP); + } + setState(353); + match(CypherParser::T__3); + setState(355); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == CypherParser::SP) { + setState(354); + match(CypherParser::SP); + } + setState(357); + oC_SchemaName(); + } + setState(362); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 18, _ctx); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + //----------------- KU_CopyFromByColumnContext ------------------------------------------------------------------ CypherParser::KU_CopyFromByColumnContext::KU_CopyFromByColumnContext(ParserRuleContext *parent, size_t invokingState) @@ -1445,7 +1601,7 @@ size_t CypherParser::KU_CopyFromByColumnContext::getRuleIndex() const { CypherParser::KU_CopyFromByColumnContext* CypherParser::kU_CopyFromByColumn() { KU_CopyFromByColumnContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 6, CypherParser::RuleKU_CopyFromByColumn); + enterRule(_localctx, 8, CypherParser::RuleKU_CopyFromByColumn); size_t _la = 0; #if __cplusplus > 201703L @@ -1457,67 +1613,67 @@ CypherParser::KU_CopyFromByColumnContext* CypherParser::kU_CopyFromByColumn() { }); try { enterOuterAlt(_localctx, 1); - setState(330); + setState(363); match(CypherParser::COPY); - setState(331); + setState(364); match(CypherParser::SP); - setState(332); + setState(365); oC_SchemaName(); - setState(333); + setState(366); match(CypherParser::SP); - setState(334); + setState(367); match(CypherParser::FROM); - setState(335); + setState(368); match(CypherParser::SP); - setState(336); + setState(369); match(CypherParser::T__1); - setState(338); + setState(371); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(337); + setState(370); match(CypherParser::SP); } - setState(340); + setState(373); match(CypherParser::StringLiteral); - setState(351); + setState(384); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3 || _la == CypherParser::SP) { - setState(342); + setState(375); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(341); + setState(374); match(CypherParser::SP); } - setState(344); + setState(377); match(CypherParser::T__3); - setState(346); + setState(379); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(345); + setState(378); match(CypherParser::SP); } - setState(348); + setState(381); match(CypherParser::StringLiteral); - setState(353); + setState(386); _errHandler->sync(this); _la = _input->LA(1); } - setState(354); + setState(387); match(CypherParser::T__2); - setState(355); + setState(388); match(CypherParser::SP); - setState(356); + setState(389); match(CypherParser::BY); - setState(357); + setState(390); match(CypherParser::SP); - setState(358); + setState(391); match(CypherParser::COLUMN); } @@ -1572,7 +1728,7 @@ size_t CypherParser::KU_CopyTOContext::getRuleIndex() const { CypherParser::KU_CopyTOContext* CypherParser::kU_CopyTO() { KU_CopyTOContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 8, CypherParser::RuleKU_CopyTO); + enterRule(_localctx, 10, CypherParser::RuleKU_CopyTO); size_t _la = 0; #if __cplusplus > 201703L @@ -1584,74 +1740,74 @@ CypherParser::KU_CopyTOContext* CypherParser::kU_CopyTO() { }); try { enterOuterAlt(_localctx, 1); - setState(360); + setState(393); match(CypherParser::COPY); - setState(361); + setState(394); match(CypherParser::SP); - setState(362); + setState(395); match(CypherParser::T__1); - setState(364); + setState(397); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(363); + setState(396); match(CypherParser::SP); } - setState(366); + setState(399); oC_Query(); - setState(368); + setState(401); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(367); + setState(400); match(CypherParser::SP); } - setState(370); + setState(403); match(CypherParser::T__2); - setState(371); + setState(404); match(CypherParser::SP); - setState(372); + setState(405); match(CypherParser::TO); - setState(373); + setState(406); match(CypherParser::SP); - setState(374); + setState(407); match(CypherParser::StringLiteral); - setState(388); + setState(421); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 20, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 28, _ctx)) { case 1: { - setState(376); + setState(409); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(375); + setState(408); match(CypherParser::SP); } - setState(378); + setState(411); match(CypherParser::T__1); - setState(380); + setState(413); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(379); + setState(412); match(CypherParser::SP); } - setState(382); + setState(415); kU_ParsingOptions(); - setState(384); + setState(417); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(383); + setState(416); match(CypherParser::SP); } - setState(386); + setState(419); match(CypherParser::T__2); break; } @@ -1704,7 +1860,7 @@ size_t CypherParser::KU_StandaloneCallContext::getRuleIndex() const { CypherParser::KU_StandaloneCallContext* CypherParser::kU_StandaloneCall() { KU_StandaloneCallContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 10, CypherParser::RuleKU_StandaloneCall); + enterRule(_localctx, 12, CypherParser::RuleKU_StandaloneCall); size_t _la = 0; #if __cplusplus > 201703L @@ -1716,31 +1872,31 @@ CypherParser::KU_StandaloneCallContext* CypherParser::kU_StandaloneCall() { }); try { enterOuterAlt(_localctx, 1); - setState(390); + setState(423); match(CypherParser::CALL); - setState(391); + setState(424); match(CypherParser::SP); - setState(392); + setState(425); oC_SymbolicName(); - setState(394); + setState(427); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(393); + setState(426); match(CypherParser::SP); } - setState(396); + setState(429); match(CypherParser::T__4); - setState(398); + setState(431); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(397); + setState(430); match(CypherParser::SP); } - setState(400); + setState(433); oC_Literal(); } @@ -1799,7 +1955,7 @@ size_t CypherParser::KU_CommentOnContext::getRuleIndex() const { CypherParser::KU_CommentOnContext* CypherParser::kU_CommentOn() { KU_CommentOnContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 12, CypherParser::RuleKU_CommentOn); + enterRule(_localctx, 14, CypherParser::RuleKU_CommentOn); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1810,27 +1966,27 @@ CypherParser::KU_CommentOnContext* CypherParser::kU_CommentOn() { }); try { enterOuterAlt(_localctx, 1); - setState(402); + setState(435); match(CypherParser::COMMENT); - setState(403); + setState(436); match(CypherParser::SP); - setState(404); + setState(437); match(CypherParser::ON); - setState(405); + setState(438); match(CypherParser::SP); - setState(406); + setState(439); match(CypherParser::TABLE); - setState(407); + setState(440); match(CypherParser::SP); - setState(408); + setState(441); oC_SchemaName(); - setState(409); + setState(442); match(CypherParser::SP); - setState(410); + setState(443); match(CypherParser::IS); - setState(411); + setState(444); match(CypherParser::SP); - setState(412); + setState(445); match(CypherParser::StringLiteral); } @@ -1897,7 +2053,7 @@ size_t CypherParser::KU_CreateMacroContext::getRuleIndex() const { CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { KU_CreateMacroContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 14, CypherParser::RuleKU_CreateMacro); + enterRule(_localctx, 16, CypherParser::RuleKU_CreateMacro); size_t _la = 0; #if __cplusplus > 201703L @@ -1910,32 +2066,32 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(414); + setState(447); match(CypherParser::CREATE); - setState(415); + setState(448); match(CypherParser::SP); - setState(416); + setState(449); match(CypherParser::MACRO); - setState(417); + setState(450); match(CypherParser::SP); - setState(418); + setState(451); oC_FunctionName(); - setState(420); + setState(453); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(419); + setState(452); match(CypherParser::SP); } - setState(422); + setState(455); match(CypherParser::T__1); - setState(424); + setState(457); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 24, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 32, _ctx)) { case 1: { - setState(423); + setState(456); match(CypherParser::SP); break; } @@ -1943,12 +2099,12 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { default: break; } - setState(427); + setState(460); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 25, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 33, _ctx)) { case 1: { - setState(426); + setState(459); kU_PositionalArgs(); break; } @@ -1956,12 +2112,12 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { default: break; } - setState(430); + setState(463); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 26, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 34, _ctx)) { case 1: { - setState(429); + setState(462); match(CypherParser::SP); break; } @@ -1969,62 +2125,62 @@ CypherParser::KU_CreateMacroContext* CypherParser::kU_CreateMacro() { default: break; } - setState(433); + setState(466); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COMMENT || ((((_la - 129) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 129)) & 1153) != 0)) { - setState(432); + setState(465); kU_DefaultArg(); } - setState(445); + setState(478); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 38, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(436); + setState(469); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(435); + setState(468); match(CypherParser::SP); } - setState(438); + setState(471); match(CypherParser::T__3); - setState(440); + setState(473); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(439); + setState(472); match(CypherParser::SP); } - setState(442); + setState(475); kU_DefaultArg(); } - setState(447); + setState(480); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 30, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 38, _ctx); } - setState(449); + setState(482); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(448); + setState(481); match(CypherParser::SP); } - setState(451); + setState(484); match(CypherParser::T__2); - setState(452); + setState(485); match(CypherParser::SP); - setState(453); + setState(486); match(CypherParser::AS); - setState(454); + setState(487); match(CypherParser::SP); - setState(455); + setState(488); oC_Expression(); } @@ -2067,7 +2223,7 @@ size_t CypherParser::KU_PositionalArgsContext::getRuleIndex() const { CypherParser::KU_PositionalArgsContext* CypherParser::kU_PositionalArgs() { KU_PositionalArgsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 16, CypherParser::RuleKU_PositionalArgs); + enterRule(_localctx, 18, CypherParser::RuleKU_PositionalArgs); size_t _la = 0; #if __cplusplus > 201703L @@ -2080,37 +2236,37 @@ CypherParser::KU_PositionalArgsContext* CypherParser::kU_PositionalArgs() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(457); + setState(490); oC_SymbolicName(); - setState(468); + setState(501); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 42, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(459); + setState(492); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(458); + setState(491); match(CypherParser::SP); } - setState(461); + setState(494); match(CypherParser::T__3); - setState(463); + setState(496); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(462); + setState(495); match(CypherParser::SP); } - setState(465); + setState(498); oC_SymbolicName(); } - setState(470); + setState(503); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 34, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 42, _ctx); } } @@ -2153,7 +2309,7 @@ size_t CypherParser::KU_DefaultArgContext::getRuleIndex() const { CypherParser::KU_DefaultArgContext* CypherParser::kU_DefaultArg() { KU_DefaultArgContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 18, CypherParser::RuleKU_DefaultArg); + enterRule(_localctx, 20, CypherParser::RuleKU_DefaultArg); size_t _la = 0; #if __cplusplus > 201703L @@ -2165,29 +2321,29 @@ CypherParser::KU_DefaultArgContext* CypherParser::kU_DefaultArg() { }); try { enterOuterAlt(_localctx, 1); - setState(471); + setState(504); oC_SymbolicName(); - setState(473); + setState(506); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(472); + setState(505); match(CypherParser::SP); } - setState(475); + setState(508); match(CypherParser::T__5); - setState(476); + setState(509); match(CypherParser::T__4); - setState(478); + setState(511); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(477); + setState(510); match(CypherParser::SP); } - setState(480); + setState(513); oC_Literal(); } @@ -2234,7 +2390,7 @@ size_t CypherParser::KU_FilePathsContext::getRuleIndex() const { CypherParser::KU_FilePathsContext* CypherParser::kU_FilePaths() { KU_FilePathsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 20, CypherParser::RuleKU_FilePaths); + enterRule(_localctx, 22, CypherParser::RuleKU_FilePaths); size_t _la = 0; #if __cplusplus > 201703L @@ -2245,96 +2401,96 @@ CypherParser::KU_FilePathsContext* CypherParser::kU_FilePaths() { exitRule(); }); try { - setState(515); + setState(548); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::T__6: { enterOuterAlt(_localctx, 1); - setState(482); + setState(515); match(CypherParser::T__6); - setState(484); + setState(517); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(483); + setState(516); match(CypherParser::SP); } - setState(486); + setState(519); match(CypherParser::StringLiteral); - setState(497); + setState(530); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3 || _la == CypherParser::SP) { - setState(488); + setState(521); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(487); + setState(520); match(CypherParser::SP); } - setState(490); + setState(523); match(CypherParser::T__3); - setState(492); + setState(525); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(491); + setState(524); match(CypherParser::SP); } - setState(494); + setState(527); match(CypherParser::StringLiteral); - setState(499); + setState(532); _errHandler->sync(this); _la = _input->LA(1); } - setState(500); + setState(533); match(CypherParser::T__7); break; } case CypherParser::StringLiteral: { enterOuterAlt(_localctx, 2); - setState(501); + setState(534); match(CypherParser::StringLiteral); break; } case CypherParser::GLOB: { enterOuterAlt(_localctx, 3); - setState(502); + setState(535); match(CypherParser::GLOB); - setState(504); + setState(537); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(503); + setState(536); match(CypherParser::SP); } - setState(506); + setState(539); match(CypherParser::T__1); - setState(508); + setState(541); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(507); + setState(540); match(CypherParser::SP); } - setState(510); + setState(543); match(CypherParser::StringLiteral); - setState(512); + setState(545); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(511); + setState(544); match(CypherParser::SP); } - setState(514); + setState(547); match(CypherParser::T__2); break; } @@ -2383,7 +2539,7 @@ size_t CypherParser::KU_ParsingOptionsContext::getRuleIndex() const { CypherParser::KU_ParsingOptionsContext* CypherParser::kU_ParsingOptions() { KU_ParsingOptionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 22, CypherParser::RuleKU_ParsingOptions); + enterRule(_localctx, 24, CypherParser::RuleKU_ParsingOptions); size_t _la = 0; #if __cplusplus > 201703L @@ -2396,37 +2552,37 @@ CypherParser::KU_ParsingOptionsContext* CypherParser::kU_ParsingOptions() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(517); + setState(550); kU_ParsingOption(); - setState(528); + setState(561); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 47, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 55, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(519); + setState(552); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(518); + setState(551); match(CypherParser::SP); } - setState(521); + setState(554); match(CypherParser::T__3); - setState(523); + setState(556); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(522); + setState(555); match(CypherParser::SP); } - setState(525); + setState(558); kU_ParsingOption(); } - setState(530); + setState(563); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 47, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 55, _ctx); } } @@ -2469,7 +2625,7 @@ size_t CypherParser::KU_ParsingOptionContext::getRuleIndex() const { CypherParser::KU_ParsingOptionContext* CypherParser::kU_ParsingOption() { KU_ParsingOptionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 24, CypherParser::RuleKU_ParsingOption); + enterRule(_localctx, 26, CypherParser::RuleKU_ParsingOption); size_t _la = 0; #if __cplusplus > 201703L @@ -2481,27 +2637,27 @@ CypherParser::KU_ParsingOptionContext* CypherParser::kU_ParsingOption() { }); try { enterOuterAlt(_localctx, 1); - setState(531); + setState(564); oC_SymbolicName(); - setState(533); + setState(566); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(532); + setState(565); match(CypherParser::SP); } - setState(535); + setState(568); match(CypherParser::T__4); - setState(537); + setState(570); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(536); + setState(569); match(CypherParser::SP); } - setState(539); + setState(572); oC_Literal(); } @@ -2552,7 +2708,7 @@ size_t CypherParser::KU_DDLContext::getRuleIndex() const { CypherParser::KU_DDLContext* CypherParser::kU_DDL() { KU_DDLContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 26, CypherParser::RuleKU_DDL); + enterRule(_localctx, 28, CypherParser::RuleKU_DDL); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2562,47 +2718,47 @@ CypherParser::KU_DDLContext* CypherParser::kU_DDL() { exitRule(); }); try { - setState(547); + setState(580); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 50, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 58, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(541); + setState(574); kU_CreateNodeTable(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(542); + setState(575); kU_CreateRelTable(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(543); + setState(576); kU_CreateRelTableGroup(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(544); + setState(577); kU_CreateRdfGraph(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(545); + setState(578); kU_DropTable(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(546); + setState(579); kU_AlterTable(); break; } @@ -2667,7 +2823,7 @@ size_t CypherParser::KU_CreateNodeTableContext::getRuleIndex() const { CypherParser::KU_CreateNodeTableContext* CypherParser::kU_CreateNodeTable() { KU_CreateNodeTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 28, CypherParser::RuleKU_CreateNodeTable); + enterRule(_localctx, 30, CypherParser::RuleKU_CreateNodeTable); size_t _la = 0; #if __cplusplus > 201703L @@ -2679,70 +2835,70 @@ CypherParser::KU_CreateNodeTableContext* CypherParser::kU_CreateNodeTable() { }); try { enterOuterAlt(_localctx, 1); - setState(549); + setState(582); match(CypherParser::CREATE); - setState(550); + setState(583); match(CypherParser::SP); - setState(551); + setState(584); match(CypherParser::NODE); - setState(552); + setState(585); match(CypherParser::SP); - setState(553); + setState(586); match(CypherParser::TABLE); - setState(554); + setState(587); match(CypherParser::SP); - setState(555); + setState(588); oC_SchemaName(); - setState(557); + setState(590); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(556); + setState(589); match(CypherParser::SP); } - setState(559); + setState(592); match(CypherParser::T__1); - setState(561); + setState(594); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(560); + setState(593); match(CypherParser::SP); } - setState(563); + setState(596); kU_PropertyDefinitions(); - setState(565); + setState(598); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(564); + setState(597); match(CypherParser::SP); } - setState(567); + setState(600); match(CypherParser::T__3); - setState(569); + setState(602); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(568); + setState(601); match(CypherParser::SP); } - setState(571); + setState(604); kU_CreateNodeConstraint(); - setState(574); + setState(607); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(573); + setState(606); match(CypherParser::SP); } - setState(576); + setState(609); match(CypherParser::T__2); } @@ -2805,7 +2961,7 @@ size_t CypherParser::KU_CreateRelTableContext::getRuleIndex() const { CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { KU_CreateRelTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 30, CypherParser::RuleKU_CreateRelTable); + enterRule(_localctx, 32, CypherParser::RuleKU_CreateRelTable); size_t _la = 0; #if __cplusplus > 201703L @@ -2817,71 +2973,71 @@ CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { }); try { enterOuterAlt(_localctx, 1); - setState(578); + setState(611); match(CypherParser::CREATE); - setState(579); + setState(612); match(CypherParser::SP); - setState(580); + setState(613); match(CypherParser::REL); - setState(581); + setState(614); match(CypherParser::SP); - setState(582); + setState(615); match(CypherParser::TABLE); - setState(583); + setState(616); match(CypherParser::SP); - setState(584); + setState(617); oC_SchemaName(); - setState(586); + setState(619); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(585); + setState(618); match(CypherParser::SP); } - setState(588); + setState(621); match(CypherParser::T__1); - setState(590); + setState(623); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(589); + setState(622); match(CypherParser::SP); } - setState(592); + setState(625); kU_RelTableConnection(); - setState(594); + setState(627); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(593); + setState(626); match(CypherParser::SP); } - setState(604); + setState(637); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 61, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 69, _ctx)) { case 1: { - setState(596); + setState(629); match(CypherParser::T__3); - setState(598); + setState(631); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(597); + setState(630); match(CypherParser::SP); } - setState(600); + setState(633); kU_PropertyDefinitions(); - setState(602); + setState(635); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(601); + setState(634); match(CypherParser::SP); } break; @@ -2890,33 +3046,33 @@ CypherParser::KU_CreateRelTableContext* CypherParser::kU_CreateRelTable() { default: break; } - setState(614); + setState(647); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__3) { - setState(606); + setState(639); match(CypherParser::T__3); - setState(608); + setState(641); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(607); + setState(640); match(CypherParser::SP); } - setState(610); + setState(643); oC_SymbolicName(); - setState(612); + setState(645); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(611); + setState(644); match(CypherParser::SP); } } - setState(616); + setState(649); match(CypherParser::T__2); } @@ -2987,7 +3143,7 @@ size_t CypherParser::KU_CreateRelTableGroupContext::getRuleIndex() const { CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGroup() { KU_CreateRelTableGroupContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 32, CypherParser::RuleKU_CreateRelTableGroup); + enterRule(_localctx, 34, CypherParser::RuleKU_CreateRelTableGroup); size_t _la = 0; #if __cplusplus > 201703L @@ -3000,69 +3156,69 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou try { size_t alt; enterOuterAlt(_localctx, 1); - setState(618); + setState(651); match(CypherParser::CREATE); - setState(619); + setState(652); match(CypherParser::SP); - setState(620); + setState(653); match(CypherParser::REL); - setState(621); + setState(654); match(CypherParser::SP); - setState(622); + setState(655); match(CypherParser::TABLE); - setState(623); + setState(656); match(CypherParser::SP); - setState(624); + setState(657); match(CypherParser::GROUP); - setState(625); + setState(658); match(CypherParser::SP); - setState(626); + setState(659); oC_SchemaName(); - setState(628); + setState(661); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(627); + setState(660); match(CypherParser::SP); } - setState(630); + setState(663); match(CypherParser::T__1); - setState(632); + setState(665); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(631); + setState(664); match(CypherParser::SP); } - setState(634); + setState(667); kU_RelTableConnection(); - setState(636); + setState(669); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(635); + setState(668); match(CypherParser::SP); } - setState(643); + setState(676); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(638); + setState(671); match(CypherParser::T__3); - setState(640); + setState(673); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(639); + setState(672); match(CypherParser::SP); } - setState(642); + setState(675); kU_RelTableConnection(); break; } @@ -3070,41 +3226,41 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou default: throw NoViableAltException(this); } - setState(645); + setState(678); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 69, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 77, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); - setState(648); + setState(681); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(647); + setState(680); match(CypherParser::SP); } - setState(658); + setState(691); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 73, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 81, _ctx)) { case 1: { - setState(650); + setState(683); match(CypherParser::T__3); - setState(652); + setState(685); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(651); + setState(684); match(CypherParser::SP); } - setState(654); + setState(687); kU_PropertyDefinitions(); - setState(656); + setState(689); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(655); + setState(688); match(CypherParser::SP); } break; @@ -3113,33 +3269,33 @@ CypherParser::KU_CreateRelTableGroupContext* CypherParser::kU_CreateRelTableGrou default: break; } - setState(668); + setState(701); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__3) { - setState(660); + setState(693); match(CypherParser::T__3); - setState(662); + setState(695); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(661); + setState(694); match(CypherParser::SP); } - setState(664); + setState(697); oC_SymbolicName(); - setState(666); + setState(699); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(665); + setState(698); match(CypherParser::SP); } } - setState(670); + setState(703); match(CypherParser::T__2); } @@ -3190,7 +3346,7 @@ size_t CypherParser::KU_RelTableConnectionContext::getRuleIndex() const { CypherParser::KU_RelTableConnectionContext* CypherParser::kU_RelTableConnection() { KU_RelTableConnectionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 34, CypherParser::RuleKU_RelTableConnection); + enterRule(_localctx, 36, CypherParser::RuleKU_RelTableConnection); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3201,19 +3357,19 @@ CypherParser::KU_RelTableConnectionContext* CypherParser::kU_RelTableConnection( }); try { enterOuterAlt(_localctx, 1); - setState(672); + setState(705); match(CypherParser::FROM); - setState(673); + setState(706); match(CypherParser::SP); - setState(674); + setState(707); oC_SchemaName(); - setState(675); + setState(708); match(CypherParser::SP); - setState(676); + setState(709); match(CypherParser::TO); - setState(677); + setState(710); match(CypherParser::SP); - setState(678); + setState(711); oC_SchemaName(); } @@ -3264,7 +3420,7 @@ size_t CypherParser::KU_CreateRdfGraphContext::getRuleIndex() const { CypherParser::KU_CreateRdfGraphContext* CypherParser::kU_CreateRdfGraph() { KU_CreateRdfGraphContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 36, CypherParser::RuleKU_CreateRdfGraph); + enterRule(_localctx, 38, CypherParser::RuleKU_CreateRdfGraph); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3275,19 +3431,19 @@ CypherParser::KU_CreateRdfGraphContext* CypherParser::kU_CreateRdfGraph() { }); try { enterOuterAlt(_localctx, 1); - setState(680); + setState(713); match(CypherParser::CREATE); - setState(681); + setState(714); match(CypherParser::SP); - setState(682); + setState(715); match(CypherParser::RDF); - setState(683); + setState(716); match(CypherParser::SP); - setState(684); + setState(717); match(CypherParser::GRAPH); - setState(685); + setState(718); match(CypherParser::SP); - setState(686); + setState(719); oC_SchemaName(); } @@ -3334,7 +3490,7 @@ size_t CypherParser::KU_DropTableContext::getRuleIndex() const { CypherParser::KU_DropTableContext* CypherParser::kU_DropTable() { KU_DropTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 38, CypherParser::RuleKU_DropTable); + enterRule(_localctx, 40, CypherParser::RuleKU_DropTable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3345,15 +3501,15 @@ CypherParser::KU_DropTableContext* CypherParser::kU_DropTable() { }); try { enterOuterAlt(_localctx, 1); - setState(688); + setState(721); match(CypherParser::DROP); - setState(689); + setState(722); match(CypherParser::SP); - setState(690); + setState(723); match(CypherParser::TABLE); - setState(691); + setState(724); match(CypherParser::SP); - setState(692); + setState(725); oC_SchemaName(); } @@ -3404,7 +3560,7 @@ size_t CypherParser::KU_AlterTableContext::getRuleIndex() const { CypherParser::KU_AlterTableContext* CypherParser::kU_AlterTable() { KU_AlterTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 40, CypherParser::RuleKU_AlterTable); + enterRule(_localctx, 42, CypherParser::RuleKU_AlterTable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3415,19 +3571,19 @@ CypherParser::KU_AlterTableContext* CypherParser::kU_AlterTable() { }); try { enterOuterAlt(_localctx, 1); - setState(694); + setState(727); match(CypherParser::ALTER); - setState(695); + setState(728); match(CypherParser::SP); - setState(696); + setState(729); match(CypherParser::TABLE); - setState(697); + setState(730); match(CypherParser::SP); - setState(698); + setState(731); oC_SchemaName(); - setState(699); + setState(732); match(CypherParser::SP); - setState(700); + setState(733); kU_AlterOptions(); } @@ -3470,7 +3626,7 @@ size_t CypherParser::KU_AlterOptionsContext::getRuleIndex() const { CypherParser::KU_AlterOptionsContext* CypherParser::kU_AlterOptions() { KU_AlterOptionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 42, CypherParser::RuleKU_AlterOptions); + enterRule(_localctx, 44, CypherParser::RuleKU_AlterOptions); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3480,33 +3636,33 @@ CypherParser::KU_AlterOptionsContext* CypherParser::kU_AlterOptions() { exitRule(); }); try { - setState(706); + setState(739); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 77, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 85, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(702); + setState(735); kU_AddProperty(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(703); + setState(736); kU_DropProperty(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(704); + setState(737); kU_RenameTable(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(705); + setState(738); kU_RenameProperty(); break; } @@ -3567,7 +3723,7 @@ size_t CypherParser::KU_AddPropertyContext::getRuleIndex() const { CypherParser::KU_AddPropertyContext* CypherParser::kU_AddProperty() { KU_AddPropertyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 44, CypherParser::RuleKU_AddProperty); + enterRule(_localctx, 46, CypherParser::RuleKU_AddProperty); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3578,28 +3734,28 @@ CypherParser::KU_AddPropertyContext* CypherParser::kU_AddProperty() { }); try { enterOuterAlt(_localctx, 1); - setState(708); + setState(741); match(CypherParser::ADD); - setState(709); + setState(742); match(CypherParser::SP); - setState(710); + setState(743); oC_PropertyKeyName(); - setState(711); + setState(744); match(CypherParser::SP); - setState(712); + setState(745); kU_DataType(0); - setState(717); + setState(750); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 78, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 86, _ctx)) { case 1: { - setState(713); + setState(746); match(CypherParser::SP); - setState(714); + setState(747); match(CypherParser::DEFAULT); - setState(715); + setState(748); match(CypherParser::SP); - setState(716); + setState(749); oC_Expression(); break; } @@ -3644,7 +3800,7 @@ size_t CypherParser::KU_DropPropertyContext::getRuleIndex() const { CypherParser::KU_DropPropertyContext* CypherParser::kU_DropProperty() { KU_DropPropertyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 46, CypherParser::RuleKU_DropProperty); + enterRule(_localctx, 48, CypherParser::RuleKU_DropProperty); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3655,11 +3811,11 @@ CypherParser::KU_DropPropertyContext* CypherParser::kU_DropProperty() { }); try { enterOuterAlt(_localctx, 1); - setState(719); + setState(752); match(CypherParser::DROP); - setState(720); + setState(753); match(CypherParser::SP); - setState(721); + setState(754); oC_PropertyKeyName(); } @@ -3706,7 +3862,7 @@ size_t CypherParser::KU_RenameTableContext::getRuleIndex() const { CypherParser::KU_RenameTableContext* CypherParser::kU_RenameTable() { KU_RenameTableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 48, CypherParser::RuleKU_RenameTable); + enterRule(_localctx, 50, CypherParser::RuleKU_RenameTable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3717,15 +3873,15 @@ CypherParser::KU_RenameTableContext* CypherParser::kU_RenameTable() { }); try { enterOuterAlt(_localctx, 1); - setState(723); + setState(756); match(CypherParser::RENAME); - setState(724); + setState(757); match(CypherParser::SP); - setState(725); + setState(758); match(CypherParser::TO); - setState(726); + setState(759); match(CypherParser::SP); - setState(727); + setState(760); oC_SchemaName(); } @@ -3776,7 +3932,7 @@ size_t CypherParser::KU_RenamePropertyContext::getRuleIndex() const { CypherParser::KU_RenamePropertyContext* CypherParser::kU_RenameProperty() { KU_RenamePropertyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 50, CypherParser::RuleKU_RenameProperty); + enterRule(_localctx, 52, CypherParser::RuleKU_RenameProperty); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3787,19 +3943,19 @@ CypherParser::KU_RenamePropertyContext* CypherParser::kU_RenameProperty() { }); try { enterOuterAlt(_localctx, 1); - setState(729); + setState(762); match(CypherParser::RENAME); - setState(730); + setState(763); match(CypherParser::SP); - setState(731); + setState(764); oC_PropertyKeyName(); - setState(732); + setState(765); match(CypherParser::SP); - setState(733); + setState(766); match(CypherParser::TO); - setState(734); + setState(767); match(CypherParser::SP); - setState(735); + setState(768); oC_PropertyKeyName(); } @@ -3842,7 +3998,7 @@ size_t CypherParser::KU_PropertyDefinitionsContext::getRuleIndex() const { CypherParser::KU_PropertyDefinitionsContext* CypherParser::kU_PropertyDefinitions() { KU_PropertyDefinitionsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 52, CypherParser::RuleKU_PropertyDefinitions); + enterRule(_localctx, 54, CypherParser::RuleKU_PropertyDefinitions); size_t _la = 0; #if __cplusplus > 201703L @@ -3855,37 +4011,37 @@ CypherParser::KU_PropertyDefinitionsContext* CypherParser::kU_PropertyDefinition try { size_t alt; enterOuterAlt(_localctx, 1); - setState(737); + setState(770); kU_PropertyDefinition(); - setState(748); + setState(781); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 81, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 89, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(739); + setState(772); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(738); + setState(771); match(CypherParser::SP); } - setState(741); + setState(774); match(CypherParser::T__3); - setState(743); + setState(776); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(742); + setState(775); match(CypherParser::SP); } - setState(745); + setState(778); kU_PropertyDefinition(); } - setState(750); + setState(783); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 81, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 89, _ctx); } } @@ -3924,7 +4080,7 @@ size_t CypherParser::KU_PropertyDefinitionContext::getRuleIndex() const { CypherParser::KU_PropertyDefinitionContext* CypherParser::kU_PropertyDefinition() { KU_PropertyDefinitionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 54, CypherParser::RuleKU_PropertyDefinition); + enterRule(_localctx, 56, CypherParser::RuleKU_PropertyDefinition); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -3935,11 +4091,11 @@ CypherParser::KU_PropertyDefinitionContext* CypherParser::kU_PropertyDefinition( }); try { enterOuterAlt(_localctx, 1); - setState(751); + setState(784); oC_PropertyKeyName(); - setState(752); + setState(785); match(CypherParser::SP); - setState(753); + setState(786); kU_DataType(0); } @@ -3986,7 +4142,7 @@ size_t CypherParser::KU_CreateNodeConstraintContext::getRuleIndex() const { CypherParser::KU_CreateNodeConstraintContext* CypherParser::kU_CreateNodeConstraint() { KU_CreateNodeConstraintContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 56, CypherParser::RuleKU_CreateNodeConstraint); + enterRule(_localctx, 58, CypherParser::RuleKU_CreateNodeConstraint); size_t _la = 0; #if __cplusplus > 201703L @@ -3998,41 +4154,41 @@ CypherParser::KU_CreateNodeConstraintContext* CypherParser::kU_CreateNodeConstra }); try { enterOuterAlt(_localctx, 1); - setState(755); + setState(788); match(CypherParser::PRIMARY); - setState(756); + setState(789); match(CypherParser::SP); - setState(757); + setState(790); match(CypherParser::KEY); - setState(759); + setState(792); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(758); + setState(791); match(CypherParser::SP); } - setState(761); + setState(794); match(CypherParser::T__1); - setState(763); + setState(796); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(762); + setState(795); match(CypherParser::SP); } - setState(765); + setState(798); oC_PropertyKeyName(); - setState(767); + setState(800); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(766); + setState(799); match(CypherParser::SP); } - setState(769); + setState(802); match(CypherParser::T__2); } @@ -4100,8 +4256,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 = 58; - enterRecursionRule(_localctx, 58, CypherParser::RuleKU_DataType, precedence); + size_t startState = 60; + enterRecursionRule(_localctx, 60, CypherParser::RuleKU_DataType, precedence); size_t _la = 0; @@ -4115,139 +4271,139 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(823); + setState(856); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 96, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 104, _ctx)) { case 1: { - setState(772); + setState(805); oC_SymbolicName(); break; } case 2: { - setState(773); + setState(806); match(CypherParser::UNION); - setState(775); + setState(808); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(774); + setState(807); match(CypherParser::SP); } - setState(777); + setState(810); match(CypherParser::T__1); - setState(779); + setState(812); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(778); + setState(811); match(CypherParser::SP); } - setState(781); + setState(814); kU_PropertyDefinitions(); - setState(783); + setState(816); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(782); + setState(815); match(CypherParser::SP); } - setState(785); + setState(818); match(CypherParser::T__2); break; } case 3: { - setState(787); + setState(820); oC_SymbolicName(); - setState(789); + setState(822); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(788); + setState(821); match(CypherParser::SP); } - setState(791); + setState(824); match(CypherParser::T__1); - setState(793); + setState(826); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(792); + setState(825); match(CypherParser::SP); } - setState(795); + setState(828); kU_PropertyDefinitions(); - setState(797); + setState(830); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(796); + setState(829); match(CypherParser::SP); } - setState(799); + setState(832); match(CypherParser::T__2); break; } case 4: { - setState(801); + setState(834); oC_SymbolicName(); - setState(803); + setState(836); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(802); + setState(835); match(CypherParser::SP); } - setState(805); + setState(838); match(CypherParser::T__1); - setState(807); + setState(840); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(806); + setState(839); match(CypherParser::SP); } - setState(809); + setState(842); kU_DataType(0); - setState(811); + setState(844); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(810); + setState(843); match(CypherParser::SP); } - setState(813); + setState(846); match(CypherParser::T__3); - setState(815); + setState(848); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(814); + setState(847); match(CypherParser::SP); } - setState(817); + setState(850); kU_DataType(0); - setState(819); + setState(852); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(818); + setState(851); match(CypherParser::SP); } - setState(821); + setState(854); match(CypherParser::T__2); break; } @@ -4256,9 +4412,9 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { break; } _ctx->stop = _input->LT(-1); - setState(829); + setState(862); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 97, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 105, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { if (!_parseListeners.empty()) @@ -4266,15 +4422,15 @@ CypherParser::KU_DataTypeContext* CypherParser::kU_DataType(int precedence) { previousContext = _localctx; _localctx = _tracker.createInstance(parentContext, parentState); pushNewRecursionContext(_localctx, startState, RuleKU_DataType); - setState(825); + setState(858); if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)"); - setState(826); + setState(859); kU_ListIdentifiers(); } - setState(831); + setState(864); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 97, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 105, _ctx); } } catch (RecognitionException &e) { @@ -4307,7 +4463,7 @@ size_t CypherParser::KU_ListIdentifiersContext::getRuleIndex() const { CypherParser::KU_ListIdentifiersContext* CypherParser::kU_ListIdentifiers() { KU_ListIdentifiersContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 60, CypherParser::RuleKU_ListIdentifiers); + enterRule(_localctx, 62, CypherParser::RuleKU_ListIdentifiers); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4319,19 +4475,19 @@ CypherParser::KU_ListIdentifiersContext* CypherParser::kU_ListIdentifiers() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(832); + setState(865); kU_ListIdentifier(); - setState(836); + setState(869); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 98, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 106, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(833); + setState(866); kU_ListIdentifier(); } - setState(838); + setState(871); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 98, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 106, _ctx); } } @@ -4362,7 +4518,7 @@ size_t CypherParser::KU_ListIdentifierContext::getRuleIndex() const { CypherParser::KU_ListIdentifierContext* CypherParser::kU_ListIdentifier() { KU_ListIdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 62, CypherParser::RuleKU_ListIdentifier); + enterRule(_localctx, 64, CypherParser::RuleKU_ListIdentifier); size_t _la = 0; #if __cplusplus > 201703L @@ -4374,17 +4530,17 @@ CypherParser::KU_ListIdentifierContext* CypherParser::kU_ListIdentifier() { }); try { enterOuterAlt(_localctx, 1); - setState(839); + setState(872); match(CypherParser::T__6); - setState(841); + setState(874); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DecimalInteger) { - setState(840); + setState(873); oC_IntegerLiteral(); } - setState(843); + setState(876); match(CypherParser::T__7); } @@ -4419,7 +4575,7 @@ size_t CypherParser::OC_AnyCypherOptionContext::getRuleIndex() const { CypherParser::OC_AnyCypherOptionContext* CypherParser::oC_AnyCypherOption() { OC_AnyCypherOptionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 64, CypherParser::RuleOC_AnyCypherOption); + enterRule(_localctx, 66, CypherParser::RuleOC_AnyCypherOption); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4429,19 +4585,19 @@ CypherParser::OC_AnyCypherOptionContext* CypherParser::oC_AnyCypherOption() { exitRule(); }); try { - setState(847); + setState(880); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::EXPLAIN: { enterOuterAlt(_localctx, 1); - setState(845); + setState(878); oC_Explain(); break; } case CypherParser::PROFILE: { enterOuterAlt(_localctx, 2); - setState(846); + setState(879); oC_Profile(); break; } @@ -4478,7 +4634,7 @@ size_t CypherParser::OC_ExplainContext::getRuleIndex() const { CypherParser::OC_ExplainContext* CypherParser::oC_Explain() { OC_ExplainContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 66, CypherParser::RuleOC_Explain); + enterRule(_localctx, 68, CypherParser::RuleOC_Explain); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4489,7 +4645,7 @@ CypherParser::OC_ExplainContext* CypherParser::oC_Explain() { }); try { enterOuterAlt(_localctx, 1); - setState(849); + setState(882); match(CypherParser::EXPLAIN); } @@ -4520,7 +4676,7 @@ size_t CypherParser::OC_ProfileContext::getRuleIndex() const { CypherParser::OC_ProfileContext* CypherParser::oC_Profile() { OC_ProfileContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 68, CypherParser::RuleOC_Profile); + enterRule(_localctx, 70, CypherParser::RuleOC_Profile); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4531,7 +4687,7 @@ CypherParser::OC_ProfileContext* CypherParser::oC_Profile() { }); try { enterOuterAlt(_localctx, 1); - setState(851); + setState(884); match(CypherParser::PROFILE); } @@ -4598,7 +4754,7 @@ size_t CypherParser::KU_TransactionContext::getRuleIndex() const { CypherParser::KU_TransactionContext* CypherParser::kU_Transaction() { KU_TransactionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 70, CypherParser::RuleKU_Transaction); + enterRule(_localctx, 72, CypherParser::RuleKU_Transaction); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4608,63 +4764,63 @@ CypherParser::KU_TransactionContext* CypherParser::kU_Transaction() { exitRule(); }); try { - setState(867); + setState(900); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 101, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 109, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(853); + setState(886); match(CypherParser::BEGIN); - setState(854); + setState(887); match(CypherParser::SP); - setState(855); + setState(888); match(CypherParser::TRANSACTION); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(856); + setState(889); match(CypherParser::BEGIN); - setState(857); + setState(890); match(CypherParser::SP); - setState(858); + setState(891); match(CypherParser::TRANSACTION); - setState(859); + setState(892); match(CypherParser::SP); - setState(860); + setState(893); match(CypherParser::READ); - setState(861); + setState(894); match(CypherParser::SP); - setState(862); + setState(895); match(CypherParser::ONLY); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(863); + setState(896); match(CypherParser::COMMIT); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(864); + setState(897); match(CypherParser::COMMIT_SKIP_CHECKPOINT); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(865); + setState(898); match(CypherParser::ROLLBACK); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(866); + setState(899); match(CypherParser::ROLLBACK_SKIP_CHECKPOINT); break; } @@ -4701,7 +4857,7 @@ size_t CypherParser::OC_QueryContext::getRuleIndex() const { CypherParser::OC_QueryContext* CypherParser::oC_Query() { OC_QueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 72, CypherParser::RuleOC_Query); + enterRule(_localctx, 74, CypherParser::RuleOC_Query); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4712,7 +4868,7 @@ CypherParser::OC_QueryContext* CypherParser::oC_Query() { }); try { enterOuterAlt(_localctx, 1); - setState(869); + setState(902); oC_RegularQuery(); } @@ -4767,7 +4923,7 @@ size_t CypherParser::OC_RegularQueryContext::getRuleIndex() const { CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() { OC_RegularQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 74, CypherParser::RuleOC_RegularQuery); + enterRule(_localctx, 76, CypherParser::RuleOC_RegularQuery); size_t _la = 0; #if __cplusplus > 201703L @@ -4779,52 +4935,52 @@ CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() { }); try { size_t alt; - setState(892); + setState(925); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 106, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 114, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(871); + setState(904); oC_SingleQuery(); - setState(878); + setState(911); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 103, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 111, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(873); + setState(906); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(872); + setState(905); match(CypherParser::SP); } - setState(875); + setState(908); oC_Union(); } - setState(880); + setState(913); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 103, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 111, _ctx); } break; } case 2: { enterOuterAlt(_localctx, 2); - setState(885); + setState(918); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(881); + setState(914); oC_Return(); - setState(883); + setState(916); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(882); + setState(915); match(CypherParser::SP); } break; @@ -4833,11 +4989,11 @@ CypherParser::OC_RegularQueryContext* CypherParser::oC_RegularQuery() { default: throw NoViableAltException(this); } - setState(887); + setState(920); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 105, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 113, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); - setState(889); + setState(922); oC_SingleQuery(); notifyReturnNotAtEnd(_localctx->start); break; @@ -4891,7 +5047,7 @@ size_t CypherParser::OC_UnionContext::getRuleIndex() const { CypherParser::OC_UnionContext* CypherParser::oC_Union() { OC_UnionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 76, CypherParser::RuleOC_Union); + enterRule(_localctx, 78, CypherParser::RuleOC_Union); size_t _la = 0; #if __cplusplus > 201703L @@ -4902,43 +5058,43 @@ CypherParser::OC_UnionContext* CypherParser::oC_Union() { exitRule(); }); try { - setState(906); + setState(939); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 109, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 117, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(894); + setState(927); match(CypherParser::UNION); - setState(895); + setState(928); match(CypherParser::SP); - setState(896); + setState(929); match(CypherParser::ALL); - setState(898); + setState(931); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(897); + setState(930); match(CypherParser::SP); } - setState(900); + setState(933); oC_SingleQuery(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(901); + setState(934); match(CypherParser::UNION); - setState(903); + setState(936); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(902); + setState(935); match(CypherParser::SP); } - setState(905); + setState(938); oC_SingleQuery(); break; } @@ -4979,7 +5135,7 @@ size_t CypherParser::OC_SingleQueryContext::getRuleIndex() const { CypherParser::OC_SingleQueryContext* CypherParser::oC_SingleQuery() { OC_SingleQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 78, CypherParser::RuleOC_SingleQuery); + enterRule(_localctx, 80, CypherParser::RuleOC_SingleQuery); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -4989,19 +5145,19 @@ CypherParser::OC_SingleQueryContext* CypherParser::oC_SingleQuery() { exitRule(); }); try { - setState(910); + setState(943); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 110, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 118, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(908); + setState(941); oC_SinglePartQuery(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(909); + setState(942); oC_MultiPartQuery(); break; } @@ -5062,7 +5218,7 @@ size_t CypherParser::OC_SinglePartQueryContext::getRuleIndex() const { CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { OC_SinglePartQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 80, CypherParser::RuleOC_SinglePartQuery); + enterRule(_localctx, 82, CypherParser::RuleOC_SinglePartQuery); size_t _la = 0; #if __cplusplus > 201703L @@ -5074,92 +5230,92 @@ CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { }); try { size_t alt; - setState(957); + setState(990); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 121, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 129, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(918); + setState(951); _errHandler->sync(this); _la = _input->LA(1); while (((((_la - 47) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 47)) & 498216206337) != 0)) { - setState(912); + setState(945); oC_ReadingClause(); - setState(914); + setState(947); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(913); + setState(946); match(CypherParser::SP); } - setState(920); + setState(953); _errHandler->sync(this); _la = _input->LA(1); } - setState(921); + setState(954); oC_Return(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(928); + setState(961); _errHandler->sync(this); _la = _input->LA(1); while (((((_la - 47) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 47)) & 498216206337) != 0)) { - setState(922); + setState(955); oC_ReadingClause(); - setState(924); + setState(957); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(923); + setState(956); match(CypherParser::SP); } - setState(930); + setState(963); _errHandler->sync(this); _la = _input->LA(1); } - setState(931); + setState(964); oC_UpdatingClause(); - setState(938); + setState(971); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 116, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 124, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(933); + setState(966); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(932); + setState(965); match(CypherParser::SP); } - setState(935); + setState(968); oC_UpdatingClause(); } - setState(940); + setState(973); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 116, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 124, _ctx); } - setState(945); + setState(978); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 118, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 126, _ctx)) { case 1: { - setState(942); + setState(975); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(941); + setState(974); match(CypherParser::SP); } - setState(944); + setState(977); oC_Return(); break; } @@ -5172,18 +5328,18 @@ CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { case 3: { enterOuterAlt(_localctx, 3); - setState(951); + setState(984); _errHandler->sync(this); _la = _input->LA(1); do { - setState(947); + setState(980); oC_ReadingClause(); - setState(949); + setState(982); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 119, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 127, _ctx)) { case 1: { - setState(948); + setState(981); match(CypherParser::SP); break; } @@ -5191,7 +5347,7 @@ CypherParser::OC_SinglePartQueryContext* CypherParser::oC_SinglePartQuery() { default: break; } - setState(953); + setState(986); _errHandler->sync(this); _la = _input->LA(1); } while (((((_la - 47) & ~ 0x3fULL) == 0) && @@ -5248,7 +5404,7 @@ size_t CypherParser::OC_MultiPartQueryContext::getRuleIndex() const { CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() { OC_MultiPartQueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 82, CypherParser::RuleOC_MultiPartQuery); + enterRule(_localctx, 84, CypherParser::RuleOC_MultiPartQuery); size_t _la = 0; #if __cplusplus > 201703L @@ -5261,20 +5417,20 @@ CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(963); + setState(996); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(959); + setState(992); kU_QueryPart(); - setState(961); + setState(994); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(960); + setState(993); match(CypherParser::SP); } break; @@ -5283,11 +5439,11 @@ CypherParser::OC_MultiPartQueryContext* CypherParser::oC_MultiPartQuery() { default: throw NoViableAltException(this); } - setState(965); + setState(998); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 123, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 131, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); - setState(967); + setState(1000); oC_SinglePartQuery(); } @@ -5342,7 +5498,7 @@ size_t CypherParser::KU_QueryPartContext::getRuleIndex() const { CypherParser::KU_QueryPartContext* CypherParser::kU_QueryPart() { KU_QueryPartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 84, CypherParser::RuleKU_QueryPart); + enterRule(_localctx, 86, CypherParser::RuleKU_QueryPart); size_t _la = 0; #if __cplusplus > 201703L @@ -5354,45 +5510,45 @@ CypherParser::KU_QueryPartContext* CypherParser::kU_QueryPart() { }); try { enterOuterAlt(_localctx, 1); - setState(975); + setState(1008); _errHandler->sync(this); _la = _input->LA(1); while (((((_la - 47) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 47)) & 498216206337) != 0)) { - setState(969); + setState(1002); oC_ReadingClause(); - setState(971); + setState(1004); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(970); + setState(1003); match(CypherParser::SP); } - setState(977); + setState(1010); _errHandler->sync(this); _la = _input->LA(1); } - setState(984); + setState(1017); _errHandler->sync(this); _la = _input->LA(1); while (((((_la - 86) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 86)) & 27) != 0)) { - setState(978); + setState(1011); oC_UpdatingClause(); - setState(980); + setState(1013); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(979); + setState(1012); match(CypherParser::SP); } - setState(986); + setState(1019); _errHandler->sync(this); _la = _input->LA(1); } - setState(987); + setState(1020); oC_With(); } @@ -5435,7 +5591,7 @@ size_t CypherParser::OC_UpdatingClauseContext::getRuleIndex() const { CypherParser::OC_UpdatingClauseContext* CypherParser::oC_UpdatingClause() { OC_UpdatingClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 86, CypherParser::RuleOC_UpdatingClause); + enterRule(_localctx, 88, CypherParser::RuleOC_UpdatingClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5445,33 +5601,33 @@ CypherParser::OC_UpdatingClauseContext* CypherParser::oC_UpdatingClause() { exitRule(); }); try { - setState(993); + setState(1026); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::CREATE: { enterOuterAlt(_localctx, 1); - setState(989); + setState(1022); oC_Create(); break; } case CypherParser::MERGE: { enterOuterAlt(_localctx, 2); - setState(990); + setState(1023); oC_Merge(); break; } case CypherParser::SET: { enterOuterAlt(_localctx, 3); - setState(991); + setState(1024); oC_Set(); break; } case CypherParser::DELETE: { enterOuterAlt(_localctx, 4); - setState(992); + setState(1025); oC_Delete(); break; } @@ -5520,7 +5676,7 @@ size_t CypherParser::OC_ReadingClauseContext::getRuleIndex() const { CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() { OC_ReadingClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 88, CypherParser::RuleOC_ReadingClause); + enterRule(_localctx, 90, CypherParser::RuleOC_ReadingClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -5530,34 +5686,34 @@ CypherParser::OC_ReadingClauseContext* CypherParser::oC_ReadingClause() { exitRule(); }); try { - setState(999); + setState(1032); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::OPTIONAL: case CypherParser::MATCH: { enterOuterAlt(_localctx, 1); - setState(995); + setState(1028); oC_Match(); break; } case CypherParser::UNWIND: { enterOuterAlt(_localctx, 2); - setState(996); + setState(1029); oC_Unwind(); break; } case CypherParser::CALL: { enterOuterAlt(_localctx, 3); - setState(997); + setState(1030); kU_InQueryCall(); break; } case CypherParser::LOAD: { enterOuterAlt(_localctx, 4); - setState(998); + setState(1031); kU_LoadFrom(); break; } @@ -5630,7 +5786,7 @@ size_t CypherParser::KU_LoadFromContext::getRuleIndex() const { CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { KU_LoadFromContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 90, CypherParser::RuleKU_LoadFrom); + enterRule(_localctx, 92, CypherParser::RuleKU_LoadFrom); size_t _la = 0; #if __cplusplus > 201703L @@ -5642,50 +5798,50 @@ CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { }); try { enterOuterAlt(_localctx, 1); - setState(1001); + setState(1034); match(CypherParser::LOAD); - setState(1019); + setState(1052); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 133, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 141, _ctx)) { case 1: { - setState(1002); + setState(1035); match(CypherParser::SP); - setState(1003); + setState(1036); match(CypherParser::WITH); - setState(1004); + setState(1037); match(CypherParser::SP); - setState(1005); + setState(1038); match(CypherParser::HEADERS); - setState(1007); + setState(1040); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1006); + setState(1039); match(CypherParser::SP); } - setState(1009); + setState(1042); match(CypherParser::T__1); - setState(1011); + setState(1044); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1010); + setState(1043); match(CypherParser::SP); } - setState(1013); + setState(1046); kU_PropertyDefinitions(); - setState(1015); + setState(1048); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1014); + setState(1047); match(CypherParser::SP); } - setState(1017); + setState(1050); match(CypherParser::T__2); break; } @@ -5693,48 +5849,48 @@ CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { default: break; } - setState(1021); + setState(1054); match(CypherParser::SP); - setState(1022); + setState(1055); match(CypherParser::FROM); - setState(1023); + setState(1056); match(CypherParser::SP); - setState(1024); + setState(1057); kU_FilePaths(); - setState(1038); + setState(1071); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 137, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 145, _ctx)) { case 1: { - setState(1026); + setState(1059); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1025); + setState(1058); match(CypherParser::SP); } - setState(1028); + setState(1061); match(CypherParser::T__1); - setState(1030); + setState(1063); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1029); + setState(1062); match(CypherParser::SP); } - setState(1032); + setState(1065); kU_ParsingOptions(); - setState(1034); + setState(1067); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1033); + setState(1066); match(CypherParser::SP); } - setState(1036); + setState(1069); match(CypherParser::T__2); break; } @@ -5742,20 +5898,20 @@ CypherParser::KU_LoadFromContext* CypherParser::kU_LoadFrom() { default: break; } - setState(1044); + setState(1077); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 139, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 147, _ctx)) { case 1: { - setState(1041); + setState(1074); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1040); + setState(1073); match(CypherParser::SP); } - setState(1043); + setState(1076); oC_Where(); break; } @@ -5808,7 +5964,7 @@ size_t CypherParser::KU_InQueryCallContext::getRuleIndex() const { CypherParser::KU_InQueryCallContext* CypherParser::kU_InQueryCall() { KU_InQueryCallContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 92, CypherParser::RuleKU_InQueryCall); + enterRule(_localctx, 94, CypherParser::RuleKU_InQueryCall); size_t _la = 0; #if __cplusplus > 201703L @@ -5820,26 +5976,26 @@ CypherParser::KU_InQueryCallContext* CypherParser::kU_InQueryCall() { }); try { enterOuterAlt(_localctx, 1); - setState(1046); + setState(1079); match(CypherParser::CALL); - setState(1047); + setState(1080); match(CypherParser::SP); - setState(1048); + setState(1081); oC_FunctionInvocation(); - setState(1053); + setState(1086); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 141, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 149, _ctx)) { case 1: { - setState(1050); + setState(1083); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1049); + setState(1082); match(CypherParser::SP); } - setState(1052); + setState(1085); oC_Where(); break; } @@ -5896,7 +6052,7 @@ size_t CypherParser::OC_MatchContext::getRuleIndex() const { CypherParser::OC_MatchContext* CypherParser::oC_Match() { OC_MatchContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 94, CypherParser::RuleOC_Match); + enterRule(_localctx, 96, CypherParser::RuleOC_Match); size_t _la = 0; #if __cplusplus > 201703L @@ -5908,42 +6064,42 @@ CypherParser::OC_MatchContext* CypherParser::oC_Match() { }); try { enterOuterAlt(_localctx, 1); - setState(1057); + setState(1090); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::OPTIONAL) { - setState(1055); + setState(1088); match(CypherParser::OPTIONAL); - setState(1056); + setState(1089); match(CypherParser::SP); } - setState(1059); + setState(1092); match(CypherParser::MATCH); - setState(1061); + setState(1094); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1060); + setState(1093); match(CypherParser::SP); } - setState(1063); + setState(1096); oC_Pattern(); - setState(1068); + setState(1101); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 145, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 153, _ctx)) { case 1: { - setState(1065); + setState(1098); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1064); + setState(1097); match(CypherParser::SP); } - setState(1067); + setState(1100); oC_Where(); break; } @@ -6000,7 +6156,7 @@ size_t CypherParser::OC_UnwindContext::getRuleIndex() const { CypherParser::OC_UnwindContext* CypherParser::oC_Unwind() { OC_UnwindContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 96, CypherParser::RuleOC_Unwind); + enterRule(_localctx, 98, CypherParser::RuleOC_Unwind); size_t _la = 0; #if __cplusplus > 201703L @@ -6012,25 +6168,25 @@ CypherParser::OC_UnwindContext* CypherParser::oC_Unwind() { }); try { enterOuterAlt(_localctx, 1); - setState(1070); + setState(1103); match(CypherParser::UNWIND); - setState(1072); + setState(1105); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1071); + setState(1104); match(CypherParser::SP); } - setState(1074); + setState(1107); oC_Expression(); - setState(1075); + setState(1108); match(CypherParser::SP); - setState(1076); + setState(1109); match(CypherParser::AS); - setState(1077); + setState(1110); match(CypherParser::SP); - setState(1078); + setState(1111); oC_Variable(); } @@ -6069,7 +6225,7 @@ size_t CypherParser::OC_CreateContext::getRuleIndex() const { CypherParser::OC_CreateContext* CypherParser::oC_Create() { OC_CreateContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 98, CypherParser::RuleOC_Create); + enterRule(_localctx, 100, CypherParser::RuleOC_Create); size_t _la = 0; #if __cplusplus > 201703L @@ -6081,17 +6237,17 @@ CypherParser::OC_CreateContext* CypherParser::oC_Create() { }); try { enterOuterAlt(_localctx, 1); - setState(1080); + setState(1113); match(CypherParser::CREATE); - setState(1082); + setState(1115); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1081); + setState(1114); match(CypherParser::SP); } - setState(1084); + setState(1117); oC_Pattern(); } @@ -6142,7 +6298,7 @@ size_t CypherParser::OC_MergeContext::getRuleIndex() const { CypherParser::OC_MergeContext* CypherParser::oC_Merge() { OC_MergeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 100, CypherParser::RuleOC_Merge); + enterRule(_localctx, 102, CypherParser::RuleOC_Merge); size_t _la = 0; #if __cplusplus > 201703L @@ -6155,31 +6311,31 @@ CypherParser::OC_MergeContext* CypherParser::oC_Merge() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1086); + setState(1119); match(CypherParser::MERGE); - setState(1088); + setState(1121); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1087); + setState(1120); match(CypherParser::SP); } - setState(1090); + setState(1123); oC_Pattern(); - setState(1095); + setState(1128); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 149, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 157, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1091); + setState(1124); match(CypherParser::SP); - setState(1092); + setState(1125); oC_MergeAction(); } - setState(1097); + setState(1130); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 149, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 157, _ctx); } } @@ -6230,7 +6386,7 @@ size_t CypherParser::OC_MergeActionContext::getRuleIndex() const { CypherParser::OC_MergeActionContext* CypherParser::oC_MergeAction() { OC_MergeActionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 102, CypherParser::RuleOC_MergeAction); + enterRule(_localctx, 104, CypherParser::RuleOC_MergeAction); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6240,35 +6396,35 @@ CypherParser::OC_MergeActionContext* CypherParser::oC_MergeAction() { exitRule(); }); try { - setState(1108); + setState(1141); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 150, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 158, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1098); + setState(1131); match(CypherParser::ON); - setState(1099); + setState(1132); match(CypherParser::SP); - setState(1100); + setState(1133); match(CypherParser::MATCH); - setState(1101); + setState(1134); match(CypherParser::SP); - setState(1102); + setState(1135); oC_Set(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1103); + setState(1136); match(CypherParser::ON); - setState(1104); + setState(1137); match(CypherParser::SP); - setState(1105); + setState(1138); match(CypherParser::CREATE); - setState(1106); + setState(1139); match(CypherParser::SP); - setState(1107); + setState(1140); oC_Set(); break; } @@ -6321,7 +6477,7 @@ size_t CypherParser::OC_SetContext::getRuleIndex() const { CypherParser::OC_SetContext* CypherParser::oC_Set() { OC_SetContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 104, CypherParser::RuleOC_Set); + enterRule(_localctx, 106, CypherParser::RuleOC_Set); size_t _la = 0; #if __cplusplus > 201703L @@ -6334,47 +6490,47 @@ CypherParser::OC_SetContext* CypherParser::oC_Set() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1110); + setState(1143); match(CypherParser::SET); - setState(1112); + setState(1145); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1111); + setState(1144); match(CypherParser::SP); } - setState(1114); + setState(1147); oC_SetItem(); - setState(1125); + setState(1158); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 154, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 162, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1116); + setState(1149); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1115); + setState(1148); match(CypherParser::SP); } - setState(1118); + setState(1151); match(CypherParser::T__3); - setState(1120); + setState(1153); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1119); + setState(1152); match(CypherParser::SP); } - setState(1122); + setState(1155); oC_SetItem(); } - setState(1127); + setState(1160); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 154, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 162, _ctx); } } @@ -6417,7 +6573,7 @@ size_t CypherParser::OC_SetItemContext::getRuleIndex() const { CypherParser::OC_SetItemContext* CypherParser::oC_SetItem() { OC_SetItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 106, CypherParser::RuleOC_SetItem); + enterRule(_localctx, 108, CypherParser::RuleOC_SetItem); size_t _la = 0; #if __cplusplus > 201703L @@ -6429,27 +6585,27 @@ CypherParser::OC_SetItemContext* CypherParser::oC_SetItem() { }); try { enterOuterAlt(_localctx, 1); - setState(1128); + setState(1161); oC_PropertyExpression(); - setState(1130); + setState(1163); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1129); + setState(1162); match(CypherParser::SP); } - setState(1132); + setState(1165); match(CypherParser::T__4); - setState(1134); + setState(1167); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1133); + setState(1166); match(CypherParser::SP); } - setState(1136); + setState(1169); oC_Expression(); } @@ -6496,7 +6652,7 @@ size_t CypherParser::OC_DeleteContext::getRuleIndex() const { CypherParser::OC_DeleteContext* CypherParser::oC_Delete() { OC_DeleteContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 108, CypherParser::RuleOC_Delete); + enterRule(_localctx, 110, CypherParser::RuleOC_Delete); size_t _la = 0; #if __cplusplus > 201703L @@ -6509,47 +6665,47 @@ CypherParser::OC_DeleteContext* CypherParser::oC_Delete() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1138); + setState(1171); match(CypherParser::DELETE); - setState(1140); + setState(1173); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1139); + setState(1172); match(CypherParser::SP); } - setState(1142); + setState(1175); oC_Expression(); - setState(1153); + setState(1186); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 160, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 168, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1144); + setState(1177); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1143); + setState(1176); match(CypherParser::SP); } - setState(1146); + setState(1179); match(CypherParser::T__3); - setState(1148); + setState(1181); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1147); + setState(1180); match(CypherParser::SP); } - setState(1150); + setState(1183); oC_Expression(); } - setState(1155); + setState(1188); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 160, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 168, _ctx); } } @@ -6592,7 +6748,7 @@ size_t CypherParser::OC_WithContext::getRuleIndex() const { CypherParser::OC_WithContext* CypherParser::oC_With() { OC_WithContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 110, CypherParser::RuleOC_With); + enterRule(_localctx, 112, CypherParser::RuleOC_With); size_t _la = 0; #if __cplusplus > 201703L @@ -6604,24 +6760,24 @@ CypherParser::OC_WithContext* CypherParser::oC_With() { }); try { enterOuterAlt(_localctx, 1); - setState(1156); + setState(1189); match(CypherParser::WITH); - setState(1157); + setState(1190); oC_ProjectionBody(); - setState(1162); + setState(1195); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 162, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 170, _ctx)) { case 1: { - setState(1159); + setState(1192); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1158); + setState(1191); match(CypherParser::SP); } - setState(1161); + setState(1194); oC_Where(); break; } @@ -6662,7 +6818,7 @@ size_t CypherParser::OC_ReturnContext::getRuleIndex() const { CypherParser::OC_ReturnContext* CypherParser::oC_Return() { OC_ReturnContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 112, CypherParser::RuleOC_Return); + enterRule(_localctx, 114, CypherParser::RuleOC_Return); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -6673,9 +6829,9 @@ CypherParser::OC_ReturnContext* CypherParser::oC_Return() { }); try { enterOuterAlt(_localctx, 1); - setState(1164); + setState(1197); match(CypherParser::RETURN); - setState(1165); + setState(1198); oC_ProjectionBody(); } @@ -6730,7 +6886,7 @@ size_t CypherParser::OC_ProjectionBodyContext::getRuleIndex() const { CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { OC_ProjectionBodyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 114, CypherParser::RuleOC_ProjectionBody); + enterRule(_localctx, 116, CypherParser::RuleOC_ProjectionBody); size_t _la = 0; #if __cplusplus > 201703L @@ -6742,20 +6898,20 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { }); try { enterOuterAlt(_localctx, 1); - setState(1171); + setState(1204); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 164, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 172, _ctx)) { case 1: { - setState(1168); + setState(1201); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1167); + setState(1200); match(CypherParser::SP); } - setState(1170); + setState(1203); match(CypherParser::DISTINCT); break; } @@ -6763,18 +6919,18 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { default: break; } - setState(1173); + setState(1206); match(CypherParser::SP); - setState(1174); + setState(1207); oC_ProjectionItems(); - setState(1177); + setState(1210); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 165, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 173, _ctx)) { case 1: { - setState(1175); + setState(1208); match(CypherParser::SP); - setState(1176); + setState(1209); oC_Order(); break; } @@ -6782,14 +6938,14 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { default: break; } - setState(1181); + setState(1214); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 166, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 174, _ctx)) { case 1: { - setState(1179); + setState(1212); match(CypherParser::SP); - setState(1180); + setState(1213); oC_Skip(); break; } @@ -6797,14 +6953,14 @@ CypherParser::OC_ProjectionBodyContext* CypherParser::oC_ProjectionBody() { default: break; } - setState(1185); + setState(1218); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 167, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 175, _ctx)) { case 1: { - setState(1183); + setState(1216); match(CypherParser::SP); - setState(1184); + setState(1217); oC_Limit(); break; } @@ -6857,7 +7013,7 @@ size_t CypherParser::OC_ProjectionItemsContext::getRuleIndex() const { CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() { OC_ProjectionItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 116, CypherParser::RuleOC_ProjectionItems); + enterRule(_localctx, 118, CypherParser::RuleOC_ProjectionItems); size_t _la = 0; #if __cplusplus > 201703L @@ -6869,42 +7025,42 @@ CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() { }); try { size_t alt; - setState(1215); + setState(1248); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::STAR: { enterOuterAlt(_localctx, 1); - setState(1187); + setState(1220); match(CypherParser::STAR); - setState(1198); + setState(1231); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 170, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 178, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1189); + setState(1222); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1188); + setState(1221); match(CypherParser::SP); } - setState(1191); + setState(1224); match(CypherParser::T__3); - setState(1193); + setState(1226); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1192); + setState(1225); match(CypherParser::SP); } - setState(1195); + setState(1228); oC_ProjectionItem(); } - setState(1200); + setState(1233); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 170, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 178, _ctx); } break; } @@ -6928,37 +7084,37 @@ CypherParser::OC_ProjectionItemsContext* CypherParser::oC_ProjectionItems() { case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 2); - setState(1201); + setState(1234); oC_ProjectionItem(); - setState(1212); + setState(1245); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 173, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 181, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1203); + setState(1236); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1202); + setState(1235); match(CypherParser::SP); } - setState(1205); + setState(1238); match(CypherParser::T__3); - setState(1207); + setState(1240); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1206); + setState(1239); match(CypherParser::SP); } - setState(1209); + setState(1242); oC_ProjectionItem(); } - setState(1214); + setState(1247); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 173, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 181, _ctx); } break; } @@ -7011,7 +7167,7 @@ size_t CypherParser::OC_ProjectionItemContext::getRuleIndex() const { CypherParser::OC_ProjectionItemContext* CypherParser::oC_ProjectionItem() { OC_ProjectionItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 118, CypherParser::RuleOC_ProjectionItem); + enterRule(_localctx, 120, CypherParser::RuleOC_ProjectionItem); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7021,27 +7177,27 @@ CypherParser::OC_ProjectionItemContext* CypherParser::oC_ProjectionItem() { exitRule(); }); try { - setState(1224); + setState(1257); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 175, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 183, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1217); + setState(1250); oC_Expression(); - setState(1218); + setState(1251); match(CypherParser::SP); - setState(1219); + setState(1252); match(CypherParser::AS); - setState(1220); + setState(1253); match(CypherParser::SP); - setState(1221); + setState(1254); oC_Variable(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1223); + setState(1256); oC_Expression(); break; } @@ -7098,7 +7254,7 @@ size_t CypherParser::OC_OrderContext::getRuleIndex() const { CypherParser::OC_OrderContext* CypherParser::oC_Order() { OC_OrderContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 120, CypherParser::RuleOC_Order); + enterRule(_localctx, 122, CypherParser::RuleOC_Order); size_t _la = 0; #if __cplusplus > 201703L @@ -7110,33 +7266,33 @@ CypherParser::OC_OrderContext* CypherParser::oC_Order() { }); try { enterOuterAlt(_localctx, 1); - setState(1226); + setState(1259); match(CypherParser::ORDER); - setState(1227); + setState(1260); match(CypherParser::SP); - setState(1228); + setState(1261); match(CypherParser::BY); - setState(1229); + setState(1262); match(CypherParser::SP); - setState(1230); + setState(1263); oC_SortItem(); - setState(1238); + setState(1271); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3) { - setState(1231); + setState(1264); match(CypherParser::T__3); - setState(1233); + setState(1266); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1232); + setState(1265); match(CypherParser::SP); } - setState(1235); + setState(1268); oC_SortItem(); - setState(1240); + setState(1273); _errHandler->sync(this); _la = _input->LA(1); } @@ -7177,7 +7333,7 @@ size_t CypherParser::OC_SkipContext::getRuleIndex() const { CypherParser::OC_SkipContext* CypherParser::oC_Skip() { OC_SkipContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 122, CypherParser::RuleOC_Skip); + enterRule(_localctx, 124, CypherParser::RuleOC_Skip); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7188,11 +7344,11 @@ CypherParser::OC_SkipContext* CypherParser::oC_Skip() { }); try { enterOuterAlt(_localctx, 1); - setState(1241); + setState(1274); match(CypherParser::L_SKIP); - setState(1242); + setState(1275); match(CypherParser::SP); - setState(1243); + setState(1276); oC_Expression(); } @@ -7231,7 +7387,7 @@ size_t CypherParser::OC_LimitContext::getRuleIndex() const { CypherParser::OC_LimitContext* CypherParser::oC_Limit() { OC_LimitContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 124, CypherParser::RuleOC_Limit); + enterRule(_localctx, 126, CypherParser::RuleOC_Limit); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7242,11 +7398,11 @@ CypherParser::OC_LimitContext* CypherParser::oC_Limit() { }); try { enterOuterAlt(_localctx, 1); - setState(1245); + setState(1278); match(CypherParser::LIMIT); - setState(1246); + setState(1279); match(CypherParser::SP); - setState(1247); + setState(1280); oC_Expression(); } @@ -7297,7 +7453,7 @@ size_t CypherParser::OC_SortItemContext::getRuleIndex() const { CypherParser::OC_SortItemContext* CypherParser::oC_SortItem() { OC_SortItemContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 126, CypherParser::RuleOC_SortItem); + enterRule(_localctx, 128, CypherParser::RuleOC_SortItem); size_t _la = 0; #if __cplusplus > 201703L @@ -7309,22 +7465,22 @@ CypherParser::OC_SortItemContext* CypherParser::oC_SortItem() { }); try { enterOuterAlt(_localctx, 1); - setState(1249); + setState(1282); oC_Expression(); - setState(1254); + setState(1287); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 179, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 187, _ctx)) { case 1: { - setState(1251); + setState(1284); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1250); + setState(1283); match(CypherParser::SP); } - setState(1253); + setState(1286); _la = _input->LA(1); if (!(((((_la - 100) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 100)) & 15) != 0))) { @@ -7377,7 +7533,7 @@ size_t CypherParser::OC_WhereContext::getRuleIndex() const { CypherParser::OC_WhereContext* CypherParser::oC_Where() { OC_WhereContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 128, CypherParser::RuleOC_Where); + enterRule(_localctx, 130, CypherParser::RuleOC_Where); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7388,11 +7544,11 @@ CypherParser::OC_WhereContext* CypherParser::oC_Where() { }); try { enterOuterAlt(_localctx, 1); - setState(1256); + setState(1289); match(CypherParser::WHERE); - setState(1257); + setState(1290); match(CypherParser::SP); - setState(1258); + setState(1291); oC_Expression(); } @@ -7435,7 +7591,7 @@ size_t CypherParser::OC_PatternContext::getRuleIndex() const { CypherParser::OC_PatternContext* CypherParser::oC_Pattern() { OC_PatternContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 130, CypherParser::RuleOC_Pattern); + enterRule(_localctx, 132, CypherParser::RuleOC_Pattern); size_t _la = 0; #if __cplusplus > 201703L @@ -7448,37 +7604,37 @@ CypherParser::OC_PatternContext* CypherParser::oC_Pattern() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1260); + setState(1293); oC_PatternPart(); - setState(1271); + setState(1304); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 182, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 190, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1262); + setState(1295); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1261); + setState(1294); match(CypherParser::SP); } - setState(1264); + setState(1297); match(CypherParser::T__3); - setState(1266); + setState(1299); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1265); + setState(1298); match(CypherParser::SP); } - setState(1268); + setState(1301); oC_PatternPart(); } - setState(1273); + setState(1306); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 182, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 190, _ctx); } } @@ -7521,7 +7677,7 @@ size_t CypherParser::OC_PatternPartContext::getRuleIndex() const { CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() { OC_PatternPartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 132, CypherParser::RuleOC_PatternPart); + enterRule(_localctx, 134, CypherParser::RuleOC_PatternPart); size_t _la = 0; #if __cplusplus > 201703L @@ -7532,7 +7688,7 @@ CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() { exitRule(); }); try { - setState(1285); + setState(1318); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::COMMENT: @@ -7540,34 +7696,34 @@ CypherParser::OC_PatternPartContext* CypherParser::oC_PatternPart() { case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 1); - setState(1274); + setState(1307); oC_Variable(); - setState(1276); + setState(1309); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1275); + setState(1308); match(CypherParser::SP); } - setState(1278); + setState(1311); match(CypherParser::T__4); - setState(1280); + setState(1313); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1279); + setState(1312); match(CypherParser::SP); } - setState(1282); + setState(1315); oC_AnonymousPatternPart(); break; } case CypherParser::T__1: { enterOuterAlt(_localctx, 2); - setState(1284); + setState(1317); oC_AnonymousPatternPart(); break; } @@ -7604,7 +7760,7 @@ size_t CypherParser::OC_AnonymousPatternPartContext::getRuleIndex() const { CypherParser::OC_AnonymousPatternPartContext* CypherParser::oC_AnonymousPatternPart() { OC_AnonymousPatternPartContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 134, CypherParser::RuleOC_AnonymousPatternPart); + enterRule(_localctx, 136, CypherParser::RuleOC_AnonymousPatternPart); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -7615,7 +7771,7 @@ CypherParser::OC_AnonymousPatternPartContext* CypherParser::oC_AnonymousPatternP }); try { enterOuterAlt(_localctx, 1); - setState(1287); + setState(1320); oC_PatternElement(); } @@ -7666,7 +7822,7 @@ size_t CypherParser::OC_PatternElementContext::getRuleIndex() const { CypherParser::OC_PatternElementContext* CypherParser::oC_PatternElement() { OC_PatternElementContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 136, CypherParser::RuleOC_PatternElement); + enterRule(_localctx, 138, CypherParser::RuleOC_PatternElement); size_t _la = 0; #if __cplusplus > 201703L @@ -7678,43 +7834,43 @@ CypherParser::OC_PatternElementContext* CypherParser::oC_PatternElement() { }); try { size_t alt; - setState(1303); + setState(1336); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 188, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 196, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1289); + setState(1322); oC_NodePattern(); - setState(1296); + setState(1329); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 187, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 195, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1291); + setState(1324); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1290); + setState(1323); match(CypherParser::SP); } - setState(1293); + setState(1326); oC_PatternElementChain(); } - setState(1298); + setState(1331); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 187, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 195, _ctx); } break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1299); + setState(1332); match(CypherParser::T__1); - setState(1300); + setState(1333); oC_PatternElement(); - setState(1301); + setState(1334); match(CypherParser::T__2); break; } @@ -7767,7 +7923,7 @@ size_t CypherParser::OC_NodePatternContext::getRuleIndex() const { CypherParser::OC_NodePatternContext* CypherParser::oC_NodePattern() { OC_NodePatternContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 138, CypherParser::RuleOC_NodePattern); + enterRule(_localctx, 140, CypherParser::RuleOC_NodePattern); size_t _la = 0; #if __cplusplus > 201703L @@ -7779,66 +7935,66 @@ CypherParser::OC_NodePatternContext* CypherParser::oC_NodePattern() { }); try { enterOuterAlt(_localctx, 1); - setState(1305); + setState(1338); match(CypherParser::T__1); - setState(1307); + setState(1340); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1306); + setState(1339); match(CypherParser::SP); } - setState(1313); + setState(1346); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COMMENT || ((((_la - 129) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 129)) & 1153) != 0)) { - setState(1309); + setState(1342); oC_Variable(); - setState(1311); + setState(1344); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1310); + setState(1343); match(CypherParser::SP); } } - setState(1319); + setState(1352); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__5) { - setState(1315); + setState(1348); oC_NodeLabels(); - setState(1317); + setState(1350); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1316); + setState(1349); match(CypherParser::SP); } } - setState(1325); + setState(1358); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__8) { - setState(1321); + setState(1354); kU_Properties(); - setState(1323); + setState(1356); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1322); + setState(1355); match(CypherParser::SP); } } - setState(1327); + setState(1360); match(CypherParser::T__2); } @@ -7877,7 +8033,7 @@ size_t CypherParser::OC_PatternElementChainContext::getRuleIndex() const { CypherParser::OC_PatternElementChainContext* CypherParser::oC_PatternElementChain() { OC_PatternElementChainContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 140, CypherParser::RuleOC_PatternElementChain); + enterRule(_localctx, 142, CypherParser::RuleOC_PatternElementChain); size_t _la = 0; #if __cplusplus > 201703L @@ -7889,17 +8045,17 @@ CypherParser::OC_PatternElementChainContext* CypherParser::oC_PatternElementChai }); try { enterOuterAlt(_localctx, 1); - setState(1329); + setState(1362); oC_RelationshipPattern(); - setState(1331); + setState(1364); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1330); + setState(1363); match(CypherParser::SP); } - setState(1333); + setState(1366); oC_NodePattern(); } @@ -7954,7 +8110,7 @@ size_t CypherParser::OC_RelationshipPatternContext::getRuleIndex() const { CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPattern() { OC_RelationshipPatternContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 142, CypherParser::RuleOC_RelationshipPattern); + enterRule(_localctx, 144, CypherParser::RuleOC_RelationshipPattern); size_t _la = 0; #if __cplusplus > 201703L @@ -7965,29 +8121,29 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter exitRule(); }); try { - setState(1379); + setState(1412); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 208, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 216, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1335); + setState(1368); oC_LeftArrowHead(); - setState(1337); + setState(1370); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1336); + setState(1369); match(CypherParser::SP); } - setState(1339); + setState(1372); oC_Dash(); - setState(1341); + setState(1374); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 198, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 206, _ctx)) { case 1: { - setState(1340); + setState(1373); match(CypherParser::SP); break; } @@ -7995,37 +8151,37 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter default: break; } - setState(1344); + setState(1377); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__6) { - setState(1343); + setState(1376); oC_RelationshipDetail(); } - setState(1347); + setState(1380); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1346); + setState(1379); match(CypherParser::SP); } - setState(1349); + setState(1382); oC_Dash(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1351); + setState(1384); oC_Dash(); - setState(1353); + setState(1386); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 201, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 209, _ctx)) { case 1: { - setState(1352); + setState(1385); match(CypherParser::SP); break; } @@ -8033,47 +8189,47 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter default: break; } - setState(1356); + setState(1389); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__6) { - setState(1355); + setState(1388); oC_RelationshipDetail(); } - setState(1359); + setState(1392); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1358); + setState(1391); match(CypherParser::SP); } - setState(1361); + setState(1394); oC_Dash(); - setState(1363); + setState(1396); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1362); + setState(1395); match(CypherParser::SP); } - setState(1365); + setState(1398); oC_RightArrowHead(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(1367); + setState(1400); oC_Dash(); - setState(1369); + setState(1402); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 205, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 213, _ctx)) { case 1: { - setState(1368); + setState(1401); match(CypherParser::SP); break; } @@ -8081,23 +8237,23 @@ CypherParser::OC_RelationshipPatternContext* CypherParser::oC_RelationshipPatter default: break; } - setState(1372); + setState(1405); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__6) { - setState(1371); + setState(1404); oC_RelationshipDetail(); } - setState(1375); + setState(1408); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1374); + setState(1407); match(CypherParser::SP); } - setState(1377); + setState(1410); oC_Dash(); break; } @@ -8154,7 +8310,7 @@ size_t CypherParser::OC_RelationshipDetailContext::getRuleIndex() const { CypherParser::OC_RelationshipDetailContext* CypherParser::oC_RelationshipDetail() { OC_RelationshipDetailContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 144, CypherParser::RuleOC_RelationshipDetail); + enterRule(_localctx, 146, CypherParser::RuleOC_RelationshipDetail); size_t _la = 0; #if __cplusplus > 201703L @@ -8166,82 +8322,82 @@ CypherParser::OC_RelationshipDetailContext* CypherParser::oC_RelationshipDetail( }); try { enterOuterAlt(_localctx, 1); - setState(1381); + setState(1414); match(CypherParser::T__6); - setState(1383); + setState(1416); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1382); + setState(1415); match(CypherParser::SP); } - setState(1389); + setState(1422); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COMMENT || ((((_la - 129) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 129)) & 1153) != 0)) { - setState(1385); + setState(1418); oC_Variable(); - setState(1387); + setState(1420); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1386); + setState(1419); match(CypherParser::SP); } } - setState(1395); + setState(1428); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__5) { - setState(1391); + setState(1424); oC_RelationshipTypes(); - setState(1393); + setState(1426); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1392); + setState(1425); match(CypherParser::SP); } } - setState(1401); + setState(1434); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::STAR) { - setState(1397); + setState(1430); oC_RangeLiteral(); - setState(1399); + setState(1432); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1398); + setState(1431); match(CypherParser::SP); } } - setState(1407); + setState(1440); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__8) { - setState(1403); + setState(1436); kU_Properties(); - setState(1405); + setState(1438); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1404); + setState(1437); match(CypherParser::SP); } } - setState(1409); + setState(1442); match(CypherParser::T__7); } @@ -8292,7 +8448,7 @@ size_t CypherParser::KU_PropertiesContext::getRuleIndex() const { CypherParser::KU_PropertiesContext* CypherParser::kU_Properties() { KU_PropertiesContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 146, CypherParser::RuleKU_Properties); + enterRule(_localctx, 148, CypherParser::RuleKU_Properties); size_t _la = 0; #if __cplusplus > 201703L @@ -8304,102 +8460,102 @@ CypherParser::KU_PropertiesContext* CypherParser::kU_Properties() { }); try { enterOuterAlt(_localctx, 1); - setState(1411); + setState(1444); match(CypherParser::T__8); - setState(1413); + setState(1446); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1412); + setState(1445); match(CypherParser::SP); } - setState(1448); + setState(1481); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::COMMENT || ((((_la - 129) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 129)) & 1153) != 0)) { - setState(1415); + setState(1448); oC_PropertyKeyName(); - setState(1417); + setState(1450); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1416); + setState(1449); match(CypherParser::SP); } - setState(1419); + setState(1452); match(CypherParser::T__5); - setState(1421); + setState(1454); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1420); + setState(1453); match(CypherParser::SP); } - setState(1423); + setState(1456); oC_Expression(); - setState(1425); + setState(1458); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1424); + setState(1457); match(CypherParser::SP); } - setState(1445); + setState(1478); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3) { - setState(1427); + setState(1460); match(CypherParser::T__3); - setState(1429); + setState(1462); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1428); + setState(1461); match(CypherParser::SP); } - setState(1431); + setState(1464); oC_PropertyKeyName(); - setState(1433); + setState(1466); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1432); + setState(1465); match(CypherParser::SP); } - setState(1435); + setState(1468); match(CypherParser::T__5); - setState(1437); + setState(1470); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1436); + setState(1469); match(CypherParser::SP); } - setState(1439); + setState(1472); oC_Expression(); - setState(1441); + setState(1474); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1440); + setState(1473); match(CypherParser::SP); } - setState(1447); + setState(1480); _errHandler->sync(this); _la = _input->LA(1); } } - setState(1450); + setState(1483); match(CypherParser::T__9); } @@ -8442,7 +8598,7 @@ size_t CypherParser::OC_RelationshipTypesContext::getRuleIndex() const { CypherParser::OC_RelationshipTypesContext* CypherParser::oC_RelationshipTypes() { OC_RelationshipTypesContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 148, CypherParser::RuleOC_RelationshipTypes); + enterRule(_localctx, 150, CypherParser::RuleOC_RelationshipTypes); size_t _la = 0; #if __cplusplus > 201703L @@ -8455,55 +8611,55 @@ CypherParser::OC_RelationshipTypesContext* CypherParser::oC_RelationshipTypes() try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1452); + setState(1485); match(CypherParser::T__5); - setState(1454); + setState(1487); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1453); + setState(1486); match(CypherParser::SP); } - setState(1456); + setState(1489); oC_RelTypeName(); - setState(1470); + setState(1503); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 232, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 240, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1458); + setState(1491); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1457); + setState(1490); match(CypherParser::SP); } - setState(1460); + setState(1493); match(CypherParser::T__10); - setState(1462); + setState(1495); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__5) { - setState(1461); + setState(1494); match(CypherParser::T__5); } - setState(1465); + setState(1498); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1464); + setState(1497); match(CypherParser::SP); } - setState(1467); + setState(1500); oC_RelTypeName(); } - setState(1472); + setState(1505); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 232, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 240, _ctx); } } @@ -8546,7 +8702,7 @@ size_t CypherParser::OC_NodeLabelsContext::getRuleIndex() const { CypherParser::OC_NodeLabelsContext* CypherParser::oC_NodeLabels() { OC_NodeLabelsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 150, CypherParser::RuleOC_NodeLabels); + enterRule(_localctx, 152, CypherParser::RuleOC_NodeLabels); size_t _la = 0; #if __cplusplus > 201703L @@ -8559,27 +8715,27 @@ CypherParser::OC_NodeLabelsContext* CypherParser::oC_NodeLabels() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1473); + setState(1506); oC_NodeLabel(); - setState(1480); + setState(1513); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 234, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 242, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1475); + setState(1508); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1474); + setState(1507); match(CypherParser::SP); } - setState(1477); + setState(1510); oC_NodeLabel(); } - setState(1482); + setState(1515); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 234, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 242, _ctx); } } @@ -8614,7 +8770,7 @@ size_t CypherParser::OC_NodeLabelContext::getRuleIndex() const { CypherParser::OC_NodeLabelContext* CypherParser::oC_NodeLabel() { OC_NodeLabelContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 152, CypherParser::RuleOC_NodeLabel); + enterRule(_localctx, 154, CypherParser::RuleOC_NodeLabel); size_t _la = 0; #if __cplusplus > 201703L @@ -8626,17 +8782,17 @@ CypherParser::OC_NodeLabelContext* CypherParser::oC_NodeLabel() { }); try { enterOuterAlt(_localctx, 1); - setState(1483); + setState(1516); match(CypherParser::T__5); - setState(1485); + setState(1518); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1484); + setState(1517); match(CypherParser::SP); } - setState(1487); + setState(1520); oC_LabelName(); } @@ -8699,7 +8855,7 @@ size_t CypherParser::OC_RangeLiteralContext::getRuleIndex() const { CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { OC_RangeLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 154, CypherParser::RuleOC_RangeLiteral); + enterRule(_localctx, 156, CypherParser::RuleOC_RangeLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -8711,14 +8867,14 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(1489); + setState(1522); match(CypherParser::STAR); - setState(1491); + setState(1524); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 236, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 244, _ctx)) { case 1: { - setState(1490); + setState(1523); match(CypherParser::SP); break; } @@ -8726,21 +8882,21 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1497); + setState(1530); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::SHORTEST: { - setState(1493); + setState(1526); match(CypherParser::SHORTEST); break; } case CypherParser::ALL: { - setState(1494); + setState(1527); match(CypherParser::ALL); - setState(1495); + setState(1528); match(CypherParser::SP); - setState(1496); + setState(1529); match(CypherParser::SHORTEST); break; } @@ -8757,12 +8913,12 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1500); + setState(1533); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 238, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 246, _ctx)) { case 1: { - setState(1499); + setState(1532); match(CypherParser::SP); break; } @@ -8770,35 +8926,35 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1516); + setState(1549); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 243, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 251, _ctx)) { case 1: { - setState(1503); + setState(1536); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DecimalInteger) { - setState(1502); + setState(1535); oC_LowerBound(); } - setState(1506); + setState(1539); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1505); + setState(1538); match(CypherParser::SP); } - setState(1508); + setState(1541); match(CypherParser::T__11); - setState(1510); + setState(1543); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 241, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 249, _ctx)) { case 1: { - setState(1509); + setState(1542); match(CypherParser::SP); break; } @@ -8806,19 +8962,19 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1513); + setState(1546); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DecimalInteger) { - setState(1512); + setState(1545); oC_UpperBound(); } break; } case 2: { - setState(1515); + setState(1548); oC_IntegerLiteral(); break; } @@ -8826,20 +8982,20 @@ CypherParser::OC_RangeLiteralContext* CypherParser::oC_RangeLiteral() { default: break; } - setState(1522); + setState(1555); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 245, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 253, _ctx)) { case 1: { - setState(1519); + setState(1552); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1518); + setState(1551); match(CypherParser::SP); } - setState(1521); + setState(1554); kU_RecursiveRelationshipComprehension(); break; } @@ -8900,7 +9056,7 @@ size_t CypherParser::KU_RecursiveRelationshipComprehensionContext::getRuleIndex( CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_RecursiveRelationshipComprehension() { KU_RecursiveRelationshipComprehensionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 156, CypherParser::RuleKU_RecursiveRelationshipComprehension); + enterRule(_localctx, 158, CypherParser::RuleKU_RecursiveRelationshipComprehension); size_t _la = 0; #if __cplusplus > 201703L @@ -8912,62 +9068,62 @@ CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_Rec }); try { enterOuterAlt(_localctx, 1); - setState(1524); + setState(1557); match(CypherParser::T__1); - setState(1526); + setState(1559); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1525); + setState(1558); match(CypherParser::SP); } - setState(1528); + setState(1561); oC_Variable(); - setState(1530); + setState(1563); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1529); + setState(1562); match(CypherParser::SP); } - setState(1532); + setState(1565); match(CypherParser::T__3); - setState(1534); + setState(1567); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1533); + setState(1566); match(CypherParser::SP); } - setState(1536); + setState(1569); oC_Variable(); - setState(1545); + setState(1578); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 251, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 259, _ctx)) { case 1: { - setState(1538); + setState(1571); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1537); + setState(1570); match(CypherParser::SP); } - setState(1540); + setState(1573); match(CypherParser::T__10); - setState(1542); + setState(1575); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1541); + setState(1574); match(CypherParser::SP); } - setState(1544); + setState(1577); oC_Where(); break; } @@ -8975,61 +9131,61 @@ CypherParser::KU_RecursiveRelationshipComprehensionContext* CypherParser::kU_Rec default: break; } - setState(1566); + setState(1599); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::T__10 || _la == CypherParser::SP) { - setState(1548); + setState(1581); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1547); + setState(1580); match(CypherParser::SP); } - setState(1550); + setState(1583); match(CypherParser::T__10); - setState(1552); + setState(1585); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1551); + setState(1584); match(CypherParser::SP); } - setState(1554); + setState(1587); kU_IntermediateRelProjectionItems(); - setState(1556); + setState(1589); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1555); + setState(1588); match(CypherParser::SP); } - setState(1558); + setState(1591); match(CypherParser::T__3); - setState(1560); + setState(1593); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1559); + setState(1592); match(CypherParser::SP); } - setState(1562); + setState(1595); kU_IntermediateNodeProjectionItems(); - setState(1564); + setState(1597); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1563); + setState(1596); match(CypherParser::SP); } } - setState(1568); + setState(1601); match(CypherParser::T__2); } @@ -9068,7 +9224,7 @@ size_t CypherParser::KU_IntermediateNodeProjectionItemsContext::getRuleIndex() c CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_IntermediateNodeProjectionItems() { KU_IntermediateNodeProjectionItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 158, CypherParser::RuleKU_IntermediateNodeProjectionItems); + enterRule(_localctx, 160, CypherParser::RuleKU_IntermediateNodeProjectionItems); size_t _la = 0; #if __cplusplus > 201703L @@ -9080,14 +9236,14 @@ CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_Interm }); try { enterOuterAlt(_localctx, 1); - setState(1570); + setState(1603); match(CypherParser::T__8); - setState(1572); + setState(1605); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 258, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 266, _ctx)) { case 1: { - setState(1571); + setState(1604); match(CypherParser::SP); break; } @@ -9095,25 +9251,25 @@ CypherParser::KU_IntermediateNodeProjectionItemsContext* CypherParser::kU_Interm default: break; } - setState(1575); + setState(1608); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 94) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 94)) & 41837536641025) != 0)) { - setState(1574); + setState(1607); oC_ProjectionItems(); } - setState(1578); + setState(1611); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1577); + setState(1610); match(CypherParser::SP); } - setState(1580); + setState(1613); match(CypherParser::T__9); } @@ -9152,7 +9308,7 @@ size_t CypherParser::KU_IntermediateRelProjectionItemsContext::getRuleIndex() co CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_IntermediateRelProjectionItems() { KU_IntermediateRelProjectionItemsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 160, CypherParser::RuleKU_IntermediateRelProjectionItems); + enterRule(_localctx, 162, CypherParser::RuleKU_IntermediateRelProjectionItems); size_t _la = 0; #if __cplusplus > 201703L @@ -9164,14 +9320,14 @@ CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_Interme }); try { enterOuterAlt(_localctx, 1); - setState(1582); + setState(1615); match(CypherParser::T__8); - setState(1584); + setState(1617); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 261, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 269, _ctx)) { case 1: { - setState(1583); + setState(1616); match(CypherParser::SP); break; } @@ -9179,25 +9335,25 @@ CypherParser::KU_IntermediateRelProjectionItemsContext* CypherParser::kU_Interme default: break; } - setState(1587); + setState(1620); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 94) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 94)) & 41837536641025) != 0)) { - setState(1586); + setState(1619); oC_ProjectionItems(); } - setState(1590); + setState(1623); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1589); + setState(1622); match(CypherParser::SP); } - setState(1592); + setState(1625); match(CypherParser::T__9); } @@ -9228,7 +9384,7 @@ size_t CypherParser::OC_LowerBoundContext::getRuleIndex() const { CypherParser::OC_LowerBoundContext* CypherParser::oC_LowerBound() { OC_LowerBoundContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 162, CypherParser::RuleOC_LowerBound); + enterRule(_localctx, 164, CypherParser::RuleOC_LowerBound); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9239,7 +9395,7 @@ CypherParser::OC_LowerBoundContext* CypherParser::oC_LowerBound() { }); try { enterOuterAlt(_localctx, 1); - setState(1594); + setState(1627); match(CypherParser::DecimalInteger); } @@ -9270,7 +9426,7 @@ size_t CypherParser::OC_UpperBoundContext::getRuleIndex() const { CypherParser::OC_UpperBoundContext* CypherParser::oC_UpperBound() { OC_UpperBoundContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 164, CypherParser::RuleOC_UpperBound); + enterRule(_localctx, 166, CypherParser::RuleOC_UpperBound); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9281,7 +9437,7 @@ CypherParser::OC_UpperBoundContext* CypherParser::oC_UpperBound() { }); try { enterOuterAlt(_localctx, 1); - setState(1596); + setState(1629); match(CypherParser::DecimalInteger); } @@ -9312,7 +9468,7 @@ size_t CypherParser::OC_LabelNameContext::getRuleIndex() const { CypherParser::OC_LabelNameContext* CypherParser::oC_LabelName() { OC_LabelNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 166, CypherParser::RuleOC_LabelName); + enterRule(_localctx, 168, CypherParser::RuleOC_LabelName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9323,7 +9479,7 @@ CypherParser::OC_LabelNameContext* CypherParser::oC_LabelName() { }); try { enterOuterAlt(_localctx, 1); - setState(1598); + setState(1631); oC_SchemaName(); } @@ -9354,7 +9510,7 @@ size_t CypherParser::OC_RelTypeNameContext::getRuleIndex() const { CypherParser::OC_RelTypeNameContext* CypherParser::oC_RelTypeName() { OC_RelTypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 168, CypherParser::RuleOC_RelTypeName); + enterRule(_localctx, 170, CypherParser::RuleOC_RelTypeName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9365,7 +9521,7 @@ CypherParser::OC_RelTypeNameContext* CypherParser::oC_RelTypeName() { }); try { enterOuterAlt(_localctx, 1); - setState(1600); + setState(1633); oC_SchemaName(); } @@ -9396,7 +9552,7 @@ size_t CypherParser::OC_ExpressionContext::getRuleIndex() const { CypherParser::OC_ExpressionContext* CypherParser::oC_Expression() { OC_ExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 170, CypherParser::RuleOC_Expression); + enterRule(_localctx, 172, CypherParser::RuleOC_Expression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9407,7 +9563,7 @@ CypherParser::OC_ExpressionContext* CypherParser::oC_Expression() { }); try { enterOuterAlt(_localctx, 1); - setState(1602); + setState(1635); oC_OrExpression(); } @@ -9458,7 +9614,7 @@ size_t CypherParser::OC_OrExpressionContext::getRuleIndex() const { CypherParser::OC_OrExpressionContext* CypherParser::oC_OrExpression() { OC_OrExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 172, CypherParser::RuleOC_OrExpression); + enterRule(_localctx, 174, CypherParser::RuleOC_OrExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9470,25 +9626,25 @@ CypherParser::OC_OrExpressionContext* CypherParser::oC_OrExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1604); + setState(1637); oC_XorExpression(); - setState(1611); + setState(1644); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 264, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 272, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1605); + setState(1638); match(CypherParser::SP); - setState(1606); + setState(1639); match(CypherParser::OR); - setState(1607); + setState(1640); match(CypherParser::SP); - setState(1608); + setState(1641); oC_XorExpression(); } - setState(1613); + setState(1646); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 264, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 272, _ctx); } } @@ -9539,7 +9695,7 @@ size_t CypherParser::OC_XorExpressionContext::getRuleIndex() const { CypherParser::OC_XorExpressionContext* CypherParser::oC_XorExpression() { OC_XorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 174, CypherParser::RuleOC_XorExpression); + enterRule(_localctx, 176, CypherParser::RuleOC_XorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9551,25 +9707,25 @@ CypherParser::OC_XorExpressionContext* CypherParser::oC_XorExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1614); + setState(1647); oC_AndExpression(); - setState(1621); + setState(1654); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 265, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 273, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1615); + setState(1648); match(CypherParser::SP); - setState(1616); + setState(1649); match(CypherParser::XOR); - setState(1617); + setState(1650); match(CypherParser::SP); - setState(1618); + setState(1651); oC_AndExpression(); } - setState(1623); + setState(1656); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 265, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 273, _ctx); } } @@ -9620,7 +9776,7 @@ size_t CypherParser::OC_AndExpressionContext::getRuleIndex() const { CypherParser::OC_AndExpressionContext* CypherParser::oC_AndExpression() { OC_AndExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 176, CypherParser::RuleOC_AndExpression); + enterRule(_localctx, 178, CypherParser::RuleOC_AndExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -9632,25 +9788,25 @@ CypherParser::OC_AndExpressionContext* CypherParser::oC_AndExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1624); + setState(1657); oC_NotExpression(); - setState(1631); + setState(1664); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 266, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 274, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1625); + setState(1658); match(CypherParser::SP); - setState(1626); + setState(1659); match(CypherParser::AND); - setState(1627); + setState(1660); match(CypherParser::SP); - setState(1628); + setState(1661); oC_NotExpression(); } - setState(1633); + setState(1666); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 266, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 274, _ctx); } } @@ -9689,7 +9845,7 @@ size_t CypherParser::OC_NotExpressionContext::getRuleIndex() const { CypherParser::OC_NotExpressionContext* CypherParser::oC_NotExpression() { OC_NotExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 178, CypherParser::RuleOC_NotExpression); + enterRule(_localctx, 180, CypherParser::RuleOC_NotExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -9701,23 +9857,23 @@ CypherParser::OC_NotExpressionContext* CypherParser::oC_NotExpression() { }); try { enterOuterAlt(_localctx, 1); - setState(1638); + setState(1671); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::NOT) { - setState(1634); + setState(1667); match(CypherParser::NOT); - setState(1636); + setState(1669); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1635); + setState(1668); match(CypherParser::SP); } } - setState(1640); + setState(1673); oC_ComparisonExpression(); } @@ -9772,7 +9928,7 @@ size_t CypherParser::OC_ComparisonExpressionContext::getRuleIndex() const { CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpression() { OC_ComparisonExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 180, CypherParser::RuleOC_ComparisonExpression); + enterRule(_localctx, 182, CypherParser::RuleOC_ComparisonExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -9784,37 +9940,37 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress }); try { size_t alt; - setState(1690); + setState(1723); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 279, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 287, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1642); + setState(1675); kU_BitwiseOrOperatorExpression(); - setState(1652); + setState(1685); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 271, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 279, _ctx)) { case 1: { - setState(1644); + setState(1677); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1643); + setState(1676); match(CypherParser::SP); } - setState(1646); + setState(1679); kU_ComparisonOperator(); - setState(1648); + setState(1681); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1647); + setState(1680); match(CypherParser::SP); } - setState(1650); + setState(1683); kU_BitwiseOrOperatorExpression(); break; } @@ -9827,28 +9983,28 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress case 2: { enterOuterAlt(_localctx, 2); - setState(1654); + setState(1687); kU_BitwiseOrOperatorExpression(); - setState(1656); + setState(1689); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1655); + setState(1688); match(CypherParser::SP); } - setState(1658); + setState(1691); antlrcpp::downCast(_localctx)->invalid_not_equalToken = match(CypherParser::INVALID_NOT_EQUAL); - setState(1660); + setState(1693); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1659); + setState(1692); match(CypherParser::SP); } - setState(1662); + setState(1695); kU_BitwiseOrOperatorExpression(); notifyInvalidNotEqualOperator(antlrcpp::downCast(_localctx)->invalid_not_equalToken); break; @@ -9856,53 +10012,53 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress case 3: { enterOuterAlt(_localctx, 3); - setState(1666); + setState(1699); kU_BitwiseOrOperatorExpression(); - setState(1668); + setState(1701); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1667); + setState(1700); match(CypherParser::SP); } - setState(1670); + setState(1703); kU_ComparisonOperator(); - setState(1672); + setState(1705); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1671); + setState(1704); match(CypherParser::SP); } - setState(1674); + setState(1707); kU_BitwiseOrOperatorExpression(); - setState(1684); + setState(1717); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(1676); + setState(1709); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1675); + setState(1708); match(CypherParser::SP); } - setState(1678); + setState(1711); kU_ComparisonOperator(); - setState(1680); + setState(1713); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1679); + setState(1712); match(CypherParser::SP); } - setState(1682); + setState(1715); kU_BitwiseOrOperatorExpression(); break; } @@ -9910,9 +10066,9 @@ CypherParser::OC_ComparisonExpressionContext* CypherParser::oC_ComparisonExpress default: throw NoViableAltException(this); } - setState(1686); + setState(1719); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 278, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 286, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); notifyNonBinaryComparison(_localctx->start); break; @@ -9946,7 +10102,7 @@ size_t CypherParser::KU_ComparisonOperatorContext::getRuleIndex() const { CypherParser::KU_ComparisonOperatorContext* CypherParser::kU_ComparisonOperator() { KU_ComparisonOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 182, CypherParser::RuleKU_ComparisonOperator); + enterRule(_localctx, 184, CypherParser::RuleKU_ComparisonOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -9958,7 +10114,7 @@ CypherParser::KU_ComparisonOperatorContext* CypherParser::kU_ComparisonOperator( }); try { enterOuterAlt(_localctx, 1); - setState(1692); + setState(1725); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 253984) != 0))) { @@ -10009,7 +10165,7 @@ size_t CypherParser::KU_BitwiseOrOperatorExpressionContext::getRuleIndex() const CypherParser::KU_BitwiseOrOperatorExpressionContext* CypherParser::kU_BitwiseOrOperatorExpression() { KU_BitwiseOrOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 184, CypherParser::RuleKU_BitwiseOrOperatorExpression); + enterRule(_localctx, 186, CypherParser::RuleKU_BitwiseOrOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10022,37 +10178,37 @@ CypherParser::KU_BitwiseOrOperatorExpressionContext* CypherParser::kU_BitwiseOrO try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1694); + setState(1727); kU_BitwiseAndOperatorExpression(); - setState(1705); + setState(1738); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 282, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 290, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1696); + setState(1729); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1695); + setState(1728); match(CypherParser::SP); } - setState(1698); + setState(1731); match(CypherParser::T__10); - setState(1700); + setState(1733); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1699); + setState(1732); match(CypherParser::SP); } - setState(1702); + setState(1735); kU_BitwiseAndOperatorExpression(); } - setState(1707); + setState(1740); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 282, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 290, _ctx); } } @@ -10095,7 +10251,7 @@ size_t CypherParser::KU_BitwiseAndOperatorExpressionContext::getRuleIndex() cons CypherParser::KU_BitwiseAndOperatorExpressionContext* CypherParser::kU_BitwiseAndOperatorExpression() { KU_BitwiseAndOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 186, CypherParser::RuleKU_BitwiseAndOperatorExpression); + enterRule(_localctx, 188, CypherParser::RuleKU_BitwiseAndOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10108,37 +10264,37 @@ CypherParser::KU_BitwiseAndOperatorExpressionContext* CypherParser::kU_BitwiseAn try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1708); + setState(1741); kU_BitShiftOperatorExpression(); - setState(1719); + setState(1752); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 285, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 293, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1710); + setState(1743); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1709); + setState(1742); match(CypherParser::SP); } - setState(1712); + setState(1745); match(CypherParser::T__17); - setState(1714); + setState(1747); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1713); + setState(1746); match(CypherParser::SP); } - setState(1716); + setState(1749); kU_BitShiftOperatorExpression(); } - setState(1721); + setState(1754); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 285, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 293, _ctx); } } @@ -10189,7 +10345,7 @@ size_t CypherParser::KU_BitShiftOperatorExpressionContext::getRuleIndex() const CypherParser::KU_BitShiftOperatorExpressionContext* CypherParser::kU_BitShiftOperatorExpression() { KU_BitShiftOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 188, CypherParser::RuleKU_BitShiftOperatorExpression); + enterRule(_localctx, 190, CypherParser::RuleKU_BitShiftOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10202,37 +10358,37 @@ CypherParser::KU_BitShiftOperatorExpressionContext* CypherParser::kU_BitShiftOpe try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1722); + setState(1755); oC_AddOrSubtractExpression(); - setState(1734); + setState(1767); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 288, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 296, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1724); + setState(1757); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1723); + setState(1756); match(CypherParser::SP); } - setState(1726); + setState(1759); kU_BitShiftOperator(); - setState(1728); + setState(1761); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1727); + setState(1760); match(CypherParser::SP); } - setState(1730); + setState(1763); oC_AddOrSubtractExpression(); } - setState(1736); + setState(1769); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 288, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 296, _ctx); } } @@ -10259,7 +10415,7 @@ size_t CypherParser::KU_BitShiftOperatorContext::getRuleIndex() const { CypherParser::KU_BitShiftOperatorContext* CypherParser::kU_BitShiftOperator() { KU_BitShiftOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 190, CypherParser::RuleKU_BitShiftOperator); + enterRule(_localctx, 192, CypherParser::RuleKU_BitShiftOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -10271,7 +10427,7 @@ CypherParser::KU_BitShiftOperatorContext* CypherParser::kU_BitShiftOperator() { }); try { enterOuterAlt(_localctx, 1); - setState(1737); + setState(1770); _la = _input->LA(1); if (!(_la == CypherParser::T__18 @@ -10331,7 +10487,7 @@ size_t CypherParser::OC_AddOrSubtractExpressionContext::getRuleIndex() const { CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::oC_AddOrSubtractExpression() { OC_AddOrSubtractExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 192, CypherParser::RuleOC_AddOrSubtractExpression); + enterRule(_localctx, 194, CypherParser::RuleOC_AddOrSubtractExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10344,37 +10500,37 @@ CypherParser::OC_AddOrSubtractExpressionContext* CypherParser::oC_AddOrSubtractE try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1739); + setState(1772); oC_MultiplyDivideModuloExpression(); - setState(1751); + setState(1784); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 291, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 299, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1741); + setState(1774); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1740); + setState(1773); match(CypherParser::SP); } - setState(1743); + setState(1776); kU_AddOrSubtractOperator(); - setState(1745); + setState(1778); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1744); + setState(1777); match(CypherParser::SP); } - setState(1747); + setState(1780); oC_MultiplyDivideModuloExpression(); } - setState(1753); + setState(1786); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 291, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 299, _ctx); } } @@ -10405,7 +10561,7 @@ size_t CypherParser::KU_AddOrSubtractOperatorContext::getRuleIndex() const { CypherParser::KU_AddOrSubtractOperatorContext* CypherParser::kU_AddOrSubtractOperator() { KU_AddOrSubtractOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 194, CypherParser::RuleKU_AddOrSubtractOperator); + enterRule(_localctx, 196, CypherParser::RuleKU_AddOrSubtractOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -10417,7 +10573,7 @@ CypherParser::KU_AddOrSubtractOperatorContext* CypherParser::kU_AddOrSubtractOpe }); try { enterOuterAlt(_localctx, 1); - setState(1754); + setState(1787); _la = _input->LA(1); if (!(_la == CypherParser::T__20 || _la == CypherParser::MINUS)) { _errHandler->recoverInline(this); @@ -10475,7 +10631,7 @@ size_t CypherParser::OC_MultiplyDivideModuloExpressionContext::getRuleIndex() co CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::oC_MultiplyDivideModuloExpression() { OC_MultiplyDivideModuloExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 196, CypherParser::RuleOC_MultiplyDivideModuloExpression); + enterRule(_localctx, 198, CypherParser::RuleOC_MultiplyDivideModuloExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10488,37 +10644,37 @@ CypherParser::OC_MultiplyDivideModuloExpressionContext* CypherParser::oC_Multipl try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1756); + setState(1789); oC_PowerOfExpression(); - setState(1768); + setState(1801); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 294, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 302, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1758); + setState(1791); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1757); + setState(1790); match(CypherParser::SP); } - setState(1760); + setState(1793); kU_MultiplyDivideModuloOperator(); - setState(1762); + setState(1795); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1761); + setState(1794); match(CypherParser::SP); } - setState(1764); + setState(1797); oC_PowerOfExpression(); } - setState(1770); + setState(1803); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 294, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 302, _ctx); } } @@ -10549,7 +10705,7 @@ size_t CypherParser::KU_MultiplyDivideModuloOperatorContext::getRuleIndex() cons CypherParser::KU_MultiplyDivideModuloOperatorContext* CypherParser::kU_MultiplyDivideModuloOperator() { KU_MultiplyDivideModuloOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 198, CypherParser::RuleKU_MultiplyDivideModuloOperator); + enterRule(_localctx, 200, CypherParser::RuleKU_MultiplyDivideModuloOperator); size_t _la = 0; #if __cplusplus > 201703L @@ -10561,7 +10717,7 @@ CypherParser::KU_MultiplyDivideModuloOperatorContext* CypherParser::kU_MultiplyD }); try { enterOuterAlt(_localctx, 1); - setState(1771); + setState(1804); _la = _input->LA(1); if (!(_la == CypherParser::T__21 @@ -10613,7 +10769,7 @@ size_t CypherParser::OC_PowerOfExpressionContext::getRuleIndex() const { CypherParser::OC_PowerOfExpressionContext* CypherParser::oC_PowerOfExpression() { OC_PowerOfExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 200, CypherParser::RuleOC_PowerOfExpression); + enterRule(_localctx, 202, CypherParser::RuleOC_PowerOfExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10626,37 +10782,37 @@ CypherParser::OC_PowerOfExpressionContext* CypherParser::oC_PowerOfExpression() try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1773); + setState(1806); oC_UnaryAddSubtractOrFactorialExpression(); - setState(1784); + setState(1817); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 297, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 305, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1775); + setState(1808); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1774); + setState(1807); match(CypherParser::SP); } - setState(1777); + setState(1810); match(CypherParser::T__23); - setState(1779); + setState(1812); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1778); + setState(1811); match(CypherParser::SP); } - setState(1781); + setState(1814); oC_UnaryAddSubtractOrFactorialExpression(); } - setState(1786); + setState(1819); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 297, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 305, _ctx); } } @@ -10703,7 +10859,7 @@ size_t CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext::getRuleInd CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::oC_UnaryAddSubtractOrFactorialExpression() { OC_UnaryAddSubtractOrFactorialExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 202, CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression); + enterRule(_localctx, 204, CypherParser::RuleOC_UnaryAddSubtractOrFactorialExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10715,38 +10871,38 @@ CypherParser::OC_UnaryAddSubtractOrFactorialExpressionContext* CypherParser::oC_ }); try { enterOuterAlt(_localctx, 1); - setState(1791); + setState(1824); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::MINUS) { - setState(1787); + setState(1820); match(CypherParser::MINUS); - setState(1789); + setState(1822); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1788); + setState(1821); match(CypherParser::SP); } } - setState(1793); + setState(1826); oC_StringListNullOperatorExpression(); - setState(1798); + setState(1831); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 301, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 309, _ctx)) { case 1: { - setState(1795); + setState(1828); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1794); + setState(1827); match(CypherParser::SP); } - setState(1797); + setState(1830); match(CypherParser::FACTORIAL); break; } @@ -10799,7 +10955,7 @@ size_t CypherParser::OC_StringListNullOperatorExpressionContext::getRuleIndex() CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_StringListNullOperatorExpression() { OC_StringListNullOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 204, CypherParser::RuleOC_StringListNullOperatorExpression); + enterRule(_localctx, 206, CypherParser::RuleOC_StringListNullOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -10811,26 +10967,26 @@ CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_Strin }); try { enterOuterAlt(_localctx, 1); - setState(1800); + setState(1833); oC_PropertyOrLabelsExpression(); - setState(1808); + setState(1841); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 303, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 311, _ctx)) { case 1: { - setState(1801); + setState(1834); oC_StringOperatorExpression(); break; } case 2: { - setState(1803); + setState(1836); _errHandler->sync(this); _la = _input->LA(1); do { - setState(1802); + setState(1835); oC_ListOperatorExpression(); - setState(1805); + setState(1838); _errHandler->sync(this); _la = _input->LA(1); } while (_la == CypherParser::T__6); @@ -10838,7 +10994,7 @@ CypherParser::OC_StringListNullOperatorExpressionContext* CypherParser::oC_Strin } case 3: { - setState(1807); + setState(1840); oC_NullOperatorExpression(); break; } @@ -10879,7 +11035,7 @@ size_t CypherParser::OC_ListOperatorExpressionContext::getRuleIndex() const { CypherParser::OC_ListOperatorExpressionContext* CypherParser::oC_ListOperatorExpression() { OC_ListOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 206, CypherParser::RuleOC_ListOperatorExpression); + enterRule(_localctx, 208, CypherParser::RuleOC_ListOperatorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10889,19 +11045,19 @@ CypherParser::OC_ListOperatorExpressionContext* CypherParser::oC_ListOperatorExp exitRule(); }); try { - setState(1812); + setState(1845); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 304, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 312, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1810); + setState(1843); kU_ListExtractOperatorExpression(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1811); + setState(1844); kU_ListSliceOperatorExpression(); break; } @@ -10938,7 +11094,7 @@ size_t CypherParser::KU_ListExtractOperatorExpressionContext::getRuleIndex() con CypherParser::KU_ListExtractOperatorExpressionContext* CypherParser::kU_ListExtractOperatorExpression() { KU_ListExtractOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 208, CypherParser::RuleKU_ListExtractOperatorExpression); + enterRule(_localctx, 210, CypherParser::RuleKU_ListExtractOperatorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -10949,11 +11105,11 @@ CypherParser::KU_ListExtractOperatorExpressionContext* CypherParser::kU_ListExtr }); try { enterOuterAlt(_localctx, 1); - setState(1814); + setState(1847); match(CypherParser::T__6); - setState(1815); + setState(1848); oC_Expression(); - setState(1816); + setState(1849); match(CypherParser::T__7); } @@ -10988,7 +11144,7 @@ size_t CypherParser::KU_ListSliceOperatorExpressionContext::getRuleIndex() const CypherParser::KU_ListSliceOperatorExpressionContext* CypherParser::kU_ListSliceOperatorExpression() { KU_ListSliceOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 210, CypherParser::RuleKU_ListSliceOperatorExpression); + enterRule(_localctx, 212, CypherParser::RuleKU_ListSliceOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -11000,31 +11156,31 @@ CypherParser::KU_ListSliceOperatorExpressionContext* CypherParser::kU_ListSliceO }); try { enterOuterAlt(_localctx, 1); - setState(1818); + setState(1851); match(CypherParser::T__6); - setState(1820); + setState(1853); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 109) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 109)) & 1276780293) != 0)) { - setState(1819); + setState(1852); oC_Expression(); } - setState(1822); + setState(1855); match(CypherParser::T__5); - setState(1824); + setState(1857); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 109) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 109)) & 1276780293) != 0)) { - setState(1823); + setState(1856); oC_Expression(); } - setState(1826); + setState(1859); match(CypherParser::T__7); } @@ -11083,7 +11239,7 @@ size_t CypherParser::OC_StringOperatorExpressionContext::getRuleIndex() const { CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperatorExpression() { OC_StringOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 212, CypherParser::RuleOC_StringOperatorExpression); + enterRule(_localctx, 214, CypherParser::RuleOC_StringOperatorExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -11095,43 +11251,43 @@ CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperato }); try { enterOuterAlt(_localctx, 1); - setState(1839); + setState(1872); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 307, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 315, _ctx)) { case 1: { - setState(1828); + setState(1861); oC_RegularExpression(); break; } case 2: { - setState(1829); + setState(1862); match(CypherParser::SP); - setState(1830); + setState(1863); match(CypherParser::STARTS); - setState(1831); + setState(1864); match(CypherParser::SP); - setState(1832); + setState(1865); match(CypherParser::WITH); break; } case 3: { - setState(1833); + setState(1866); match(CypherParser::SP); - setState(1834); + setState(1867); match(CypherParser::ENDS); - setState(1835); + setState(1868); match(CypherParser::SP); - setState(1836); + setState(1869); match(CypherParser::WITH); break; } case 4: { - setState(1837); + setState(1870); match(CypherParser::SP); - setState(1838); + setState(1871); match(CypherParser::CONTAINS); break; } @@ -11139,15 +11295,15 @@ CypherParser::OC_StringOperatorExpressionContext* CypherParser::oC_StringOperato default: break; } - setState(1842); + setState(1875); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1841); + setState(1874); match(CypherParser::SP); } - setState(1844); + setState(1877); oC_PropertyOrLabelsExpression(); } @@ -11178,7 +11334,7 @@ size_t CypherParser::OC_RegularExpressionContext::getRuleIndex() const { CypherParser::OC_RegularExpressionContext* CypherParser::oC_RegularExpression() { OC_RegularExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 214, CypherParser::RuleOC_RegularExpression); + enterRule(_localctx, 216, CypherParser::RuleOC_RegularExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -11190,15 +11346,15 @@ CypherParser::OC_RegularExpressionContext* CypherParser::oC_RegularExpression() }); try { enterOuterAlt(_localctx, 1); - setState(1847); + setState(1880); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1846); + setState(1879); match(CypherParser::SP); } - setState(1849); + setState(1882); match(CypherParser::T__24); } @@ -11245,7 +11401,7 @@ size_t CypherParser::OC_NullOperatorExpressionContext::getRuleIndex() const { CypherParser::OC_NullOperatorExpressionContext* CypherParser::oC_NullOperatorExpression() { OC_NullOperatorExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 216, CypherParser::RuleOC_NullOperatorExpression); + enterRule(_localctx, 218, CypherParser::RuleOC_NullOperatorExpression); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -11255,35 +11411,35 @@ CypherParser::OC_NullOperatorExpressionContext* CypherParser::oC_NullOperatorExp exitRule(); }); try { - setState(1861); + setState(1894); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 310, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 318, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1851); + setState(1884); match(CypherParser::SP); - setState(1852); + setState(1885); match(CypherParser::IS); - setState(1853); + setState(1886); match(CypherParser::SP); - setState(1854); + setState(1887); match(CypherParser::NULL_); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1855); + setState(1888); match(CypherParser::SP); - setState(1856); + setState(1889); match(CypherParser::IS); - setState(1857); + setState(1890); match(CypherParser::SP); - setState(1858); + setState(1891); match(CypherParser::NOT); - setState(1859); + setState(1892); match(CypherParser::SP); - setState(1860); + setState(1893); match(CypherParser::NULL_); break; } @@ -11336,7 +11492,7 @@ size_t CypherParser::OC_PropertyOrLabelsExpressionContext::getRuleIndex() const CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::oC_PropertyOrLabelsExpression() { OC_PropertyOrLabelsExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 218, CypherParser::RuleOC_PropertyOrLabelsExpression); + enterRule(_localctx, 220, CypherParser::RuleOC_PropertyOrLabelsExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -11349,27 +11505,27 @@ CypherParser::OC_PropertyOrLabelsExpressionContext* CypherParser::oC_PropertyOrL try { size_t alt; enterOuterAlt(_localctx, 1); - setState(1863); + setState(1896); oC_Atom(); - setState(1870); + setState(1903); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 312, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 320, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { - setState(1865); + setState(1898); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1864); + setState(1897); match(CypherParser::SP); } - setState(1867); + setState(1900); oC_PropertyLookup(); } - setState(1872); + setState(1905); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 312, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 320, _ctx); } } @@ -11424,7 +11580,7 @@ size_t CypherParser::OC_AtomContext::getRuleIndex() const { CypherParser::OC_AtomContext* CypherParser::oC_Atom() { OC_AtomContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 220, CypherParser::RuleOC_Atom); + enterRule(_localctx, 222, CypherParser::RuleOC_Atom); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -11434,54 +11590,54 @@ CypherParser::OC_AtomContext* CypherParser::oC_Atom() { exitRule(); }); try { - setState(1880); + setState(1913); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 313, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 321, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1873); + setState(1906); oC_Literal(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1874); + setState(1907); oC_Parameter(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(1875); + setState(1908); oC_CaseExpression(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(1876); + setState(1909); oC_ParenthesizedExpression(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(1877); + setState(1910); oC_FunctionInvocation(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(1878); + setState(1911); oC_ExistentialSubquery(); break; } case 7: { enterOuterAlt(_localctx, 7); - setState(1879); + setState(1912); oC_Variable(); break; } @@ -11538,7 +11694,7 @@ size_t CypherParser::OC_LiteralContext::getRuleIndex() const { CypherParser::OC_LiteralContext* CypherParser::oC_Literal() { OC_LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 222, CypherParser::RuleOC_Literal); + enterRule(_localctx, 224, CypherParser::RuleOC_Literal); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -11548,20 +11704,20 @@ CypherParser::OC_LiteralContext* CypherParser::oC_Literal() { exitRule(); }); try { - setState(1888); + setState(1921); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::DecimalInteger: case CypherParser::RegularDecimalReal: { enterOuterAlt(_localctx, 1); - setState(1882); + setState(1915); oC_NumberLiteral(); break; } case CypherParser::StringLiteral: { enterOuterAlt(_localctx, 2); - setState(1883); + setState(1916); match(CypherParser::StringLiteral); break; } @@ -11569,28 +11725,28 @@ CypherParser::OC_LiteralContext* CypherParser::oC_Literal() { case CypherParser::TRUE: case CypherParser::FALSE: { enterOuterAlt(_localctx, 3); - setState(1884); + setState(1917); oC_BooleanLiteral(); break; } case CypherParser::NULL_: { enterOuterAlt(_localctx, 4); - setState(1885); + setState(1918); match(CypherParser::NULL_); break; } case CypherParser::T__6: { enterOuterAlt(_localctx, 5); - setState(1886); + setState(1919); oC_ListLiteral(); break; } case CypherParser::T__8: { enterOuterAlt(_localctx, 6); - setState(1887); + setState(1920); kU_StructLiteral(); break; } @@ -11631,7 +11787,7 @@ size_t CypherParser::OC_BooleanLiteralContext::getRuleIndex() const { CypherParser::OC_BooleanLiteralContext* CypherParser::oC_BooleanLiteral() { OC_BooleanLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 224, CypherParser::RuleOC_BooleanLiteral); + enterRule(_localctx, 226, CypherParser::RuleOC_BooleanLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -11643,7 +11799,7 @@ CypherParser::OC_BooleanLiteralContext* CypherParser::oC_BooleanLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(1890); + setState(1923); _la = _input->LA(1); if (!(_la == CypherParser::TRUE @@ -11699,7 +11855,7 @@ size_t CypherParser::OC_ListLiteralContext::getRuleIndex() const { CypherParser::OC_ListLiteralContext* CypherParser::oC_ListLiteral() { OC_ListLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 226, CypherParser::RuleOC_ListLiteral); + enterRule(_localctx, 228, CypherParser::RuleOC_ListLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -11711,53 +11867,53 @@ CypherParser::OC_ListLiteralContext* CypherParser::oC_ListLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(1892); + setState(1925); match(CypherParser::T__6); - setState(1894); + setState(1927); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1893); + setState(1926); match(CypherParser::SP); } - setState(1909); + setState(1942); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 109) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 109)) & 1276780293) != 0)) { - setState(1896); + setState(1929); oC_Expression(); - setState(1898); + setState(1931); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1897); + setState(1930); match(CypherParser::SP); } - setState(1906); + setState(1939); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3) { - setState(1900); + setState(1933); kU_ListEntry(); - setState(1902); + setState(1935); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1901); + setState(1934); match(CypherParser::SP); } - setState(1908); + setState(1941); _errHandler->sync(this); _la = _input->LA(1); } } - setState(1911); + setState(1944); match(CypherParser::T__7); } @@ -11792,7 +11948,7 @@ size_t CypherParser::KU_ListEntryContext::getRuleIndex() const { CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() { KU_ListEntryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 228, CypherParser::RuleKU_ListEntry); + enterRule(_localctx, 230, CypherParser::RuleKU_ListEntry); size_t _la = 0; #if __cplusplus > 201703L @@ -11804,14 +11960,14 @@ CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() { }); try { enterOuterAlt(_localctx, 1); - setState(1913); + setState(1946); match(CypherParser::T__3); - setState(1915); + setState(1948); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 320, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 328, _ctx)) { case 1: { - setState(1914); + setState(1947); match(CypherParser::SP); break; } @@ -11819,14 +11975,14 @@ CypherParser::KU_ListEntryContext* CypherParser::kU_ListEntry() { default: break; } - setState(1918); + setState(1951); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 109) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 109)) & 1276780293) != 0)) { - setState(1917); + setState(1950); oC_Expression(); } @@ -11870,7 +12026,7 @@ size_t CypherParser::KU_StructLiteralContext::getRuleIndex() const { CypherParser::KU_StructLiteralContext* CypherParser::kU_StructLiteral() { KU_StructLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 230, CypherParser::RuleKU_StructLiteral); + enterRule(_localctx, 232, CypherParser::RuleKU_StructLiteral); size_t _la = 0; #if __cplusplus > 201703L @@ -11882,55 +12038,55 @@ CypherParser::KU_StructLiteralContext* CypherParser::kU_StructLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(1920); + setState(1953); match(CypherParser::T__8); - setState(1922); + setState(1955); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1921); + setState(1954); match(CypherParser::SP); } - setState(1924); + setState(1957); kU_StructField(); - setState(1926); + setState(1959); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1925); + setState(1958); match(CypherParser::SP); } - setState(1938); + setState(1971); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3) { - setState(1928); + setState(1961); match(CypherParser::T__3); - setState(1930); + setState(1963); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1929); + setState(1962); match(CypherParser::SP); } - setState(1932); + setState(1965); kU_StructField(); - setState(1934); + setState(1967); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1933); + setState(1966); match(CypherParser::SP); } - setState(1940); + setState(1973); _errHandler->sync(this); _la = _input->LA(1); } - setState(1941); + setState(1974); match(CypherParser::T__9); } @@ -11977,7 +12133,7 @@ size_t CypherParser::KU_StructFieldContext::getRuleIndex() const { CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { KU_StructFieldContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 232, CypherParser::RuleKU_StructField); + enterRule(_localctx, 234, CypherParser::RuleKU_StructField); size_t _la = 0; #if __cplusplus > 201703L @@ -11989,20 +12145,20 @@ CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { }); try { enterOuterAlt(_localctx, 1); - setState(1945); + setState(1978); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::COMMENT: case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(1943); + setState(1976); oC_SymbolicName(); break; } case CypherParser::StringLiteral: { - setState(1944); + setState(1977); match(CypherParser::StringLiteral); break; } @@ -12010,25 +12166,25 @@ CypherParser::KU_StructFieldContext* CypherParser::kU_StructField() { default: throw NoViableAltException(this); } - setState(1948); + setState(1981); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1947); + setState(1980); match(CypherParser::SP); } - setState(1950); + setState(1983); match(CypherParser::T__5); - setState(1952); + setState(1985); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1951); + setState(1984); match(CypherParser::SP); } - setState(1954); + setState(1987); oC_Expression(); } @@ -12067,7 +12223,7 @@ size_t CypherParser::OC_ParenthesizedExpressionContext::getRuleIndex() const { CypherParser::OC_ParenthesizedExpressionContext* CypherParser::oC_ParenthesizedExpression() { OC_ParenthesizedExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 234, CypherParser::RuleOC_ParenthesizedExpression); + enterRule(_localctx, 236, CypherParser::RuleOC_ParenthesizedExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -12079,27 +12235,27 @@ CypherParser::OC_ParenthesizedExpressionContext* CypherParser::oC_ParenthesizedE }); try { enterOuterAlt(_localctx, 1); - setState(1956); + setState(1989); match(CypherParser::T__1); - setState(1958); + setState(1991); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1957); + setState(1990); match(CypherParser::SP); } - setState(1960); + setState(1993); oC_Expression(); - setState(1962); + setState(1995); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1961); + setState(1994); match(CypherParser::SP); } - setState(1964); + setState(1997); match(CypherParser::T__2); } @@ -12154,7 +12310,7 @@ size_t CypherParser::OC_FunctionInvocationContext::getRuleIndex() const { CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation() { OC_FunctionInvocationContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 236, CypherParser::RuleOC_FunctionInvocation); + enterRule(_localctx, 238, CypherParser::RuleOC_FunctionInvocation); size_t _la = 0; #if __cplusplus > 201703L @@ -12165,131 +12321,131 @@ CypherParser::OC_FunctionInvocationContext* CypherParser::oC_FunctionInvocation( exitRule(); }); try { - setState(2015); + setState(2048); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 344, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 352, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(1966); + setState(1999); oC_FunctionName(); - setState(1968); + setState(2001); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1967); + setState(2000); match(CypherParser::SP); } - setState(1970); + setState(2003); match(CypherParser::T__1); - setState(1972); + setState(2005); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1971); + setState(2004); match(CypherParser::SP); } - setState(1974); + setState(2007); match(CypherParser::STAR); - setState(1976); + setState(2009); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1975); + setState(2008); match(CypherParser::SP); } - setState(1978); + setState(2011); match(CypherParser::T__2); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(1980); + setState(2013); oC_FunctionName(); - setState(1982); + setState(2015); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1981); + setState(2014); match(CypherParser::SP); } - setState(1984); + setState(2017); match(CypherParser::T__1); - setState(1986); + setState(2019); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1985); + setState(2018); match(CypherParser::SP); } - setState(1992); + setState(2025); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::DISTINCT) { - setState(1988); + setState(2021); match(CypherParser::DISTINCT); - setState(1990); + setState(2023); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1989); + setState(2022); match(CypherParser::SP); } } - setState(2011); + setState(2044); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 281475110929028) != 0) || ((((_la - 109) & ~ 0x3fULL) == 0) && ((1ULL << (_la - 109)) & 1276780293) != 0)) { - setState(1994); + setState(2027); kU_FunctionParameter(); - setState(1996); + setState(2029); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1995); + setState(2028); match(CypherParser::SP); } - setState(2008); + setState(2041); _errHandler->sync(this); _la = _input->LA(1); while (_la == CypherParser::T__3) { - setState(1998); + setState(2031); match(CypherParser::T__3); - setState(2000); + setState(2033); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(1999); + setState(2032); match(CypherParser::SP); } - setState(2002); + setState(2035); kU_FunctionParameter(); - setState(2004); + setState(2037); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2003); + setState(2036); match(CypherParser::SP); } - setState(2010); + setState(2043); _errHandler->sync(this); _la = _input->LA(1); } } - setState(2013); + setState(2046); match(CypherParser::T__2); break; } @@ -12326,7 +12482,7 @@ size_t CypherParser::OC_FunctionNameContext::getRuleIndex() const { CypherParser::OC_FunctionNameContext* CypherParser::oC_FunctionName() { OC_FunctionNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 238, CypherParser::RuleOC_FunctionName); + enterRule(_localctx, 240, CypherParser::RuleOC_FunctionName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12337,7 +12493,7 @@ CypherParser::OC_FunctionNameContext* CypherParser::oC_FunctionName() { }); try { enterOuterAlt(_localctx, 1); - setState(2017); + setState(2050); oC_SymbolicName(); } @@ -12380,7 +12536,7 @@ size_t CypherParser::KU_FunctionParameterContext::getRuleIndex() const { CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() { KU_FunctionParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 240, CypherParser::RuleKU_FunctionParameter); + enterRule(_localctx, 242, CypherParser::RuleKU_FunctionParameter); size_t _la = 0; #if __cplusplus > 201703L @@ -12392,31 +12548,31 @@ CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() }); try { enterOuterAlt(_localctx, 1); - setState(2028); + setState(2061); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 347, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 355, _ctx)) { case 1: { - setState(2019); + setState(2052); oC_SymbolicName(); - setState(2021); + setState(2054); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2020); + setState(2053); match(CypherParser::SP); } - setState(2023); + setState(2056); match(CypherParser::T__5); - setState(2024); + setState(2057); match(CypherParser::T__4); - setState(2026); + setState(2059); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2025); + setState(2058); match(CypherParser::SP); } break; @@ -12425,7 +12581,7 @@ CypherParser::KU_FunctionParameterContext* CypherParser::kU_FunctionParameter() default: break; } - setState(2030); + setState(2063); oC_Expression(); } @@ -12476,7 +12632,7 @@ size_t CypherParser::OC_ExistentialSubqueryContext::getRuleIndex() const { CypherParser::OC_ExistentialSubqueryContext* CypherParser::oC_ExistentialSubquery() { OC_ExistentialSubqueryContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 242, CypherParser::RuleOC_ExistentialSubquery); + enterRule(_localctx, 244, CypherParser::RuleOC_ExistentialSubquery); size_t _la = 0; #if __cplusplus > 201703L @@ -12488,52 +12644,52 @@ CypherParser::OC_ExistentialSubqueryContext* CypherParser::oC_ExistentialSubquer }); try { enterOuterAlt(_localctx, 1); - setState(2032); + setState(2065); match(CypherParser::EXISTS); - setState(2034); + setState(2067); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2033); + setState(2066); match(CypherParser::SP); } - setState(2036); + setState(2069); match(CypherParser::T__8); - setState(2038); + setState(2071); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2037); + setState(2070); match(CypherParser::SP); } - setState(2040); + setState(2073); match(CypherParser::MATCH); - setState(2042); + setState(2075); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2041); + setState(2074); match(CypherParser::SP); } - setState(2044); + setState(2077); oC_Pattern(); - setState(2049); + setState(2082); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 352, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 360, _ctx)) { case 1: { - setState(2046); + setState(2079); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2045); + setState(2078); match(CypherParser::SP); } - setState(2048); + setState(2081); oC_Where(); break; } @@ -12541,15 +12697,15 @@ CypherParser::OC_ExistentialSubqueryContext* CypherParser::oC_ExistentialSubquer default: break; } - setState(2052); + setState(2085); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2051); + setState(2084); match(CypherParser::SP); } - setState(2054); + setState(2087); match(CypherParser::T__9); } @@ -12588,7 +12744,7 @@ size_t CypherParser::OC_PropertyLookupContext::getRuleIndex() const { CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() { OC_PropertyLookupContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 244, CypherParser::RuleOC_PropertyLookup); + enterRule(_localctx, 246, CypherParser::RuleOC_PropertyLookup); size_t _la = 0; #if __cplusplus > 201703L @@ -12600,30 +12756,30 @@ CypherParser::OC_PropertyLookupContext* CypherParser::oC_PropertyLookup() { }); try { enterOuterAlt(_localctx, 1); - setState(2056); + setState(2089); match(CypherParser::T__25); - setState(2058); + setState(2091); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2057); + setState(2090); match(CypherParser::SP); } - setState(2062); + setState(2095); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::COMMENT: case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(2060); + setState(2093); oC_PropertyKeyName(); break; } case CypherParser::STAR: { - setState(2061); + setState(2094); match(CypherParser::STAR); break; } @@ -12692,7 +12848,7 @@ size_t CypherParser::OC_CaseExpressionContext::getRuleIndex() const { CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { OC_CaseExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 246, CypherParser::RuleOC_CaseExpression); + enterRule(_localctx, 248, CypherParser::RuleOC_CaseExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -12705,27 +12861,27 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { try { size_t alt; enterOuterAlt(_localctx, 1); - setState(2086); + setState(2119); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 361, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 369, _ctx)) { case 1: { - setState(2064); + setState(2097); match(CypherParser::CASE); - setState(2069); + setState(2102); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2066); + setState(2099); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2065); + setState(2098); match(CypherParser::SP); } - setState(2068); + setState(2101); oC_CaseAlternative(); break; } @@ -12733,41 +12889,41 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: throw NoViableAltException(this); } - setState(2071); + setState(2104); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 357, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 365, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } case 2: { - setState(2073); + setState(2106); match(CypherParser::CASE); - setState(2075); + setState(2108); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2074); + setState(2107); match(CypherParser::SP); } - setState(2077); + setState(2110); oC_Expression(); - setState(2082); + setState(2115); _errHandler->sync(this); alt = 1; do { switch (alt) { case 1: { - setState(2079); + setState(2112); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2078); + setState(2111); match(CypherParser::SP); } - setState(2081); + setState(2114); oC_CaseAlternative(); break; } @@ -12775,9 +12931,9 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: throw NoViableAltException(this); } - setState(2084); + setState(2117); _errHandler->sync(this); - alt = getInterpreter()->adaptivePredict(_input, 360, _ctx); + alt = getInterpreter()->adaptivePredict(_input, 368, _ctx); } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER); break; } @@ -12785,30 +12941,30 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: break; } - setState(2096); + setState(2129); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 364, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 372, _ctx)) { case 1: { - setState(2089); + setState(2122); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2088); + setState(2121); match(CypherParser::SP); } - setState(2091); + setState(2124); match(CypherParser::ELSE); - setState(2093); + setState(2126); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2092); + setState(2125); match(CypherParser::SP); } - setState(2095); + setState(2128); oC_Expression(); break; } @@ -12816,15 +12972,15 @@ CypherParser::OC_CaseExpressionContext* CypherParser::oC_CaseExpression() { default: break; } - setState(2099); + setState(2132); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2098); + setState(2131); match(CypherParser::SP); } - setState(2101); + setState(2134); match(CypherParser::END); } @@ -12875,7 +13031,7 @@ size_t CypherParser::OC_CaseAlternativeContext::getRuleIndex() const { CypherParser::OC_CaseAlternativeContext* CypherParser::oC_CaseAlternative() { OC_CaseAlternativeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 248, CypherParser::RuleOC_CaseAlternative); + enterRule(_localctx, 250, CypherParser::RuleOC_CaseAlternative); size_t _la = 0; #if __cplusplus > 201703L @@ -12887,37 +13043,37 @@ CypherParser::OC_CaseAlternativeContext* CypherParser::oC_CaseAlternative() { }); try { enterOuterAlt(_localctx, 1); - setState(2103); + setState(2136); match(CypherParser::WHEN); - setState(2105); + setState(2138); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2104); + setState(2137); match(CypherParser::SP); } - setState(2107); + setState(2140); oC_Expression(); - setState(2109); + setState(2142); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2108); + setState(2141); match(CypherParser::SP); } - setState(2111); + setState(2144); match(CypherParser::THEN); - setState(2113); + setState(2146); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2112); + setState(2145); match(CypherParser::SP); } - setState(2115); + setState(2148); oC_Expression(); } @@ -12948,7 +13104,7 @@ size_t CypherParser::OC_VariableContext::getRuleIndex() const { CypherParser::OC_VariableContext* CypherParser::oC_Variable() { OC_VariableContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 250, CypherParser::RuleOC_Variable); + enterRule(_localctx, 252, CypherParser::RuleOC_Variable); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -12959,7 +13115,7 @@ CypherParser::OC_VariableContext* CypherParser::oC_Variable() { }); try { enterOuterAlt(_localctx, 1); - setState(2117); + setState(2150); oC_SymbolicName(); } @@ -12994,7 +13150,7 @@ size_t CypherParser::OC_NumberLiteralContext::getRuleIndex() const { CypherParser::OC_NumberLiteralContext* CypherParser::oC_NumberLiteral() { OC_NumberLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 252, CypherParser::RuleOC_NumberLiteral); + enterRule(_localctx, 254, CypherParser::RuleOC_NumberLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13004,19 +13160,19 @@ CypherParser::OC_NumberLiteralContext* CypherParser::oC_NumberLiteral() { exitRule(); }); try { - setState(2121); + setState(2154); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::RegularDecimalReal: { enterOuterAlt(_localctx, 1); - setState(2119); + setState(2152); oC_DoubleLiteral(); break; } case CypherParser::DecimalInteger: { enterOuterAlt(_localctx, 2); - setState(2120); + setState(2153); oC_IntegerLiteral(); break; } @@ -13057,7 +13213,7 @@ size_t CypherParser::OC_ParameterContext::getRuleIndex() const { CypherParser::OC_ParameterContext* CypherParser::oC_Parameter() { OC_ParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 254, CypherParser::RuleOC_Parameter); + enterRule(_localctx, 256, CypherParser::RuleOC_Parameter); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13068,22 +13224,22 @@ CypherParser::OC_ParameterContext* CypherParser::oC_Parameter() { }); try { enterOuterAlt(_localctx, 1); - setState(2123); + setState(2156); match(CypherParser::T__26); - setState(2126); + setState(2159); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::COMMENT: case CypherParser::HexLetter: case CypherParser::UnescapedSymbolicName: case CypherParser::EscapedSymbolicName: { - setState(2124); + setState(2157); oC_SymbolicName(); break; } case CypherParser::DecimalInteger: { - setState(2125); + setState(2158); match(CypherParser::DecimalInteger); break; } @@ -13128,7 +13284,7 @@ size_t CypherParser::OC_PropertyExpressionContext::getRuleIndex() const { CypherParser::OC_PropertyExpressionContext* CypherParser::oC_PropertyExpression() { OC_PropertyExpressionContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 256, CypherParser::RuleOC_PropertyExpression); + enterRule(_localctx, 258, CypherParser::RuleOC_PropertyExpression); size_t _la = 0; #if __cplusplus > 201703L @@ -13140,17 +13296,17 @@ CypherParser::OC_PropertyExpressionContext* CypherParser::oC_PropertyExpression( }); try { enterOuterAlt(_localctx, 1); - setState(2128); + setState(2161); oC_Atom(); - setState(2130); + setState(2163); _errHandler->sync(this); _la = _input->LA(1); if (_la == CypherParser::SP) { - setState(2129); + setState(2162); match(CypherParser::SP); } - setState(2132); + setState(2165); oC_PropertyLookup(); } @@ -13181,7 +13337,7 @@ size_t CypherParser::OC_PropertyKeyNameContext::getRuleIndex() const { CypherParser::OC_PropertyKeyNameContext* CypherParser::oC_PropertyKeyName() { OC_PropertyKeyNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 258, CypherParser::RuleOC_PropertyKeyName); + enterRule(_localctx, 260, CypherParser::RuleOC_PropertyKeyName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13192,7 +13348,7 @@ CypherParser::OC_PropertyKeyNameContext* CypherParser::oC_PropertyKeyName() { }); try { enterOuterAlt(_localctx, 1); - setState(2134); + setState(2167); oC_SchemaName(); } @@ -13223,7 +13379,7 @@ size_t CypherParser::OC_IntegerLiteralContext::getRuleIndex() const { CypherParser::OC_IntegerLiteralContext* CypherParser::oC_IntegerLiteral() { OC_IntegerLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 260, CypherParser::RuleOC_IntegerLiteral); + enterRule(_localctx, 262, CypherParser::RuleOC_IntegerLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13234,7 +13390,7 @@ CypherParser::OC_IntegerLiteralContext* CypherParser::oC_IntegerLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2136); + setState(2169); match(CypherParser::DecimalInteger); } @@ -13265,7 +13421,7 @@ size_t CypherParser::OC_DoubleLiteralContext::getRuleIndex() const { CypherParser::OC_DoubleLiteralContext* CypherParser::oC_DoubleLiteral() { OC_DoubleLiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 262, CypherParser::RuleOC_DoubleLiteral); + enterRule(_localctx, 264, CypherParser::RuleOC_DoubleLiteral); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13276,7 +13432,7 @@ CypherParser::OC_DoubleLiteralContext* CypherParser::oC_DoubleLiteral() { }); try { enterOuterAlt(_localctx, 1); - setState(2138); + setState(2171); match(CypherParser::RegularDecimalReal); } @@ -13307,7 +13463,7 @@ size_t CypherParser::OC_SchemaNameContext::getRuleIndex() const { CypherParser::OC_SchemaNameContext* CypherParser::oC_SchemaName() { OC_SchemaNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 264, CypherParser::RuleOC_SchemaName); + enterRule(_localctx, 266, CypherParser::RuleOC_SchemaName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13318,7 +13474,7 @@ CypherParser::OC_SchemaNameContext* CypherParser::oC_SchemaName() { }); try { enterOuterAlt(_localctx, 1); - setState(2140); + setState(2173); oC_SymbolicName(); } @@ -13361,7 +13517,7 @@ size_t CypherParser::OC_SymbolicNameContext::getRuleIndex() const { CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { OC_SymbolicNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 266, CypherParser::RuleOC_SymbolicName); + enterRule(_localctx, 268, CypherParser::RuleOC_SymbolicName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13371,19 +13527,19 @@ CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { exitRule(); }); try { - setState(2147); + setState(2180); _errHandler->sync(this); switch (_input->LA(1)) { case CypherParser::UnescapedSymbolicName: { enterOuterAlt(_localctx, 1); - setState(2142); + setState(2175); match(CypherParser::UnescapedSymbolicName); break; } case CypherParser::EscapedSymbolicName: { enterOuterAlt(_localctx, 2); - setState(2143); + setState(2176); antlrcpp::downCast(_localctx)->escapedsymbolicnameToken = match(CypherParser::EscapedSymbolicName); if ((antlrcpp::downCast(_localctx)->escapedsymbolicnameToken != nullptr ? antlrcpp::downCast(_localctx)->escapedsymbolicnameToken->getText() : "") == "``") { notifyEmptyToken(antlrcpp::downCast(_localctx)->escapedsymbolicnameToken); } break; @@ -13391,14 +13547,14 @@ CypherParser::OC_SymbolicNameContext* CypherParser::oC_SymbolicName() { case CypherParser::HexLetter: { enterOuterAlt(_localctx, 3); - setState(2145); + setState(2178); match(CypherParser::HexLetter); break; } case CypherParser::COMMENT: { enterOuterAlt(_localctx, 4); - setState(2146); + setState(2179); kU_NonReservedKeywords(); break; } @@ -13435,7 +13591,7 @@ size_t CypherParser::KU_NonReservedKeywordsContext::getRuleIndex() const { CypherParser::KU_NonReservedKeywordsContext* CypherParser::kU_NonReservedKeywords() { KU_NonReservedKeywordsContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 268, CypherParser::RuleKU_NonReservedKeywords); + enterRule(_localctx, 270, CypherParser::RuleKU_NonReservedKeywords); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -13446,7 +13602,7 @@ CypherParser::KU_NonReservedKeywordsContext* CypherParser::kU_NonReservedKeyword }); try { enterOuterAlt(_localctx, 1); - setState(2149); + setState(2182); match(CypherParser::COMMENT); } @@ -13473,7 +13629,7 @@ size_t CypherParser::OC_LeftArrowHeadContext::getRuleIndex() const { CypherParser::OC_LeftArrowHeadContext* CypherParser::oC_LeftArrowHead() { OC_LeftArrowHeadContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 270, CypherParser::RuleOC_LeftArrowHead); + enterRule(_localctx, 272, CypherParser::RuleOC_LeftArrowHead); size_t _la = 0; #if __cplusplus > 201703L @@ -13485,7 +13641,7 @@ CypherParser::OC_LeftArrowHeadContext* CypherParser::oC_LeftArrowHead() { }); try { enterOuterAlt(_localctx, 1); - setState(2151); + setState(2184); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 4026548224) != 0))) { @@ -13520,7 +13676,7 @@ size_t CypherParser::OC_RightArrowHeadContext::getRuleIndex() const { CypherParser::OC_RightArrowHeadContext* CypherParser::oC_RightArrowHead() { OC_RightArrowHeadContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 272, CypherParser::RuleOC_RightArrowHead); + enterRule(_localctx, 274, CypherParser::RuleOC_RightArrowHead); size_t _la = 0; #if __cplusplus > 201703L @@ -13532,7 +13688,7 @@ CypherParser::OC_RightArrowHeadContext* CypherParser::oC_RightArrowHead() { }); try { enterOuterAlt(_localctx, 1); - setState(2153); + setState(2186); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 64424574976) != 0))) { @@ -13571,7 +13727,7 @@ size_t CypherParser::OC_DashContext::getRuleIndex() const { CypherParser::OC_DashContext* CypherParser::oC_Dash() { OC_DashContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 274, CypherParser::RuleOC_Dash); + enterRule(_localctx, 276, CypherParser::RuleOC_Dash); size_t _la = 0; #if __cplusplus > 201703L @@ -13583,7 +13739,7 @@ CypherParser::OC_DashContext* CypherParser::oC_Dash() { }); try { enterOuterAlt(_localctx, 1); - setState(2155); + setState(2188); _la = _input->LA(1); if (!((((_la & ~ 0x3fULL) == 0) && ((1ULL << _la) & 140668768878592) != 0) || _la == CypherParser::MINUS)) { @@ -13606,7 +13762,7 @@ CypherParser::OC_DashContext* CypherParser::oC_Dash() { bool CypherParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) { switch (ruleIndex) { - case 29: return kU_DataTypeSempred(antlrcpp::downCast(context), predicateIndex); + case 30: return kU_DataTypeSempred(antlrcpp::downCast(context), predicateIndex); default: break; diff --git a/third_party/antlr4_cypher/include/cypher_parser.h b/third_party/antlr4_cypher/include/cypher_parser.h index 9e73ed7de5..e284e91b85 100644 --- a/third_party/antlr4_cypher/include/cypher_parser.h +++ b/third_party/antlr4_cypher/include/cypher_parser.h @@ -41,53 +41,54 @@ class CypherParser : public antlr4::Parser { }; enum { - RuleOC_Cypher = 0, RuleOC_Statement = 1, RuleKU_CopyFrom = 2, RuleKU_CopyFromByColumn = 3, - RuleKU_CopyTO = 4, RuleKU_StandaloneCall = 5, RuleKU_CommentOn = 6, - RuleKU_CreateMacro = 7, RuleKU_PositionalArgs = 8, RuleKU_DefaultArg = 9, - RuleKU_FilePaths = 10, RuleKU_ParsingOptions = 11, RuleKU_ParsingOption = 12, - RuleKU_DDL = 13, RuleKU_CreateNodeTable = 14, RuleKU_CreateRelTable = 15, - RuleKU_CreateRelTableGroup = 16, RuleKU_RelTableConnection = 17, RuleKU_CreateRdfGraph = 18, - RuleKU_DropTable = 19, RuleKU_AlterTable = 20, RuleKU_AlterOptions = 21, - RuleKU_AddProperty = 22, RuleKU_DropProperty = 23, RuleKU_RenameTable = 24, - RuleKU_RenameProperty = 25, RuleKU_PropertyDefinitions = 26, RuleKU_PropertyDefinition = 27, - RuleKU_CreateNodeConstraint = 28, RuleKU_DataType = 29, RuleKU_ListIdentifiers = 30, - RuleKU_ListIdentifier = 31, RuleOC_AnyCypherOption = 32, RuleOC_Explain = 33, - RuleOC_Profile = 34, RuleKU_Transaction = 35, RuleOC_Query = 36, RuleOC_RegularQuery = 37, - RuleOC_Union = 38, RuleOC_SingleQuery = 39, RuleOC_SinglePartQuery = 40, - RuleOC_MultiPartQuery = 41, RuleKU_QueryPart = 42, RuleOC_UpdatingClause = 43, - RuleOC_ReadingClause = 44, RuleKU_LoadFrom = 45, RuleKU_InQueryCall = 46, - RuleOC_Match = 47, RuleOC_Unwind = 48, RuleOC_Create = 49, RuleOC_Merge = 50, - RuleOC_MergeAction = 51, RuleOC_Set = 52, RuleOC_SetItem = 53, RuleOC_Delete = 54, - RuleOC_With = 55, RuleOC_Return = 56, RuleOC_ProjectionBody = 57, RuleOC_ProjectionItems = 58, - RuleOC_ProjectionItem = 59, RuleOC_Order = 60, RuleOC_Skip = 61, RuleOC_Limit = 62, - RuleOC_SortItem = 63, RuleOC_Where = 64, RuleOC_Pattern = 65, RuleOC_PatternPart = 66, - RuleOC_AnonymousPatternPart = 67, RuleOC_PatternElement = 68, RuleOC_NodePattern = 69, - RuleOC_PatternElementChain = 70, RuleOC_RelationshipPattern = 71, RuleOC_RelationshipDetail = 72, - RuleKU_Properties = 73, RuleOC_RelationshipTypes = 74, RuleOC_NodeLabels = 75, - RuleOC_NodeLabel = 76, RuleOC_RangeLiteral = 77, RuleKU_RecursiveRelationshipComprehension = 78, - RuleKU_IntermediateNodeProjectionItems = 79, RuleKU_IntermediateRelProjectionItems = 80, - RuleOC_LowerBound = 81, RuleOC_UpperBound = 82, RuleOC_LabelName = 83, - RuleOC_RelTypeName = 84, RuleOC_Expression = 85, RuleOC_OrExpression = 86, - RuleOC_XorExpression = 87, RuleOC_AndExpression = 88, RuleOC_NotExpression = 89, - RuleOC_ComparisonExpression = 90, RuleKU_ComparisonOperator = 91, RuleKU_BitwiseOrOperatorExpression = 92, - RuleKU_BitwiseAndOperatorExpression = 93, RuleKU_BitShiftOperatorExpression = 94, - RuleKU_BitShiftOperator = 95, RuleOC_AddOrSubtractExpression = 96, RuleKU_AddOrSubtractOperator = 97, - RuleOC_MultiplyDivideModuloExpression = 98, RuleKU_MultiplyDivideModuloOperator = 99, - RuleOC_PowerOfExpression = 100, RuleOC_UnaryAddSubtractOrFactorialExpression = 101, - RuleOC_StringListNullOperatorExpression = 102, RuleOC_ListOperatorExpression = 103, - RuleKU_ListExtractOperatorExpression = 104, RuleKU_ListSliceOperatorExpression = 105, - RuleOC_StringOperatorExpression = 106, RuleOC_RegularExpression = 107, - RuleOC_NullOperatorExpression = 108, RuleOC_PropertyOrLabelsExpression = 109, - RuleOC_Atom = 110, RuleOC_Literal = 111, RuleOC_BooleanLiteral = 112, - RuleOC_ListLiteral = 113, RuleKU_ListEntry = 114, RuleKU_StructLiteral = 115, - RuleKU_StructField = 116, RuleOC_ParenthesizedExpression = 117, RuleOC_FunctionInvocation = 118, - RuleOC_FunctionName = 119, RuleKU_FunctionParameter = 120, RuleOC_ExistentialSubquery = 121, - RuleOC_PropertyLookup = 122, RuleOC_CaseExpression = 123, RuleOC_CaseAlternative = 124, - RuleOC_Variable = 125, RuleOC_NumberLiteral = 126, RuleOC_Parameter = 127, - RuleOC_PropertyExpression = 128, RuleOC_PropertyKeyName = 129, RuleOC_IntegerLiteral = 130, - RuleOC_DoubleLiteral = 131, RuleOC_SchemaName = 132, RuleOC_SymbolicName = 133, - RuleKU_NonReservedKeywords = 134, RuleOC_LeftArrowHead = 135, RuleOC_RightArrowHead = 136, - RuleOC_Dash = 137 + RuleOC_Cypher = 0, RuleOC_Statement = 1, RuleKU_CopyFrom = 2, RuleKU_ColumnNames = 3, + RuleKU_CopyFromByColumn = 4, RuleKU_CopyTO = 5, RuleKU_StandaloneCall = 6, + RuleKU_CommentOn = 7, RuleKU_CreateMacro = 8, RuleKU_PositionalArgs = 9, + RuleKU_DefaultArg = 10, RuleKU_FilePaths = 11, RuleKU_ParsingOptions = 12, + RuleKU_ParsingOption = 13, RuleKU_DDL = 14, RuleKU_CreateNodeTable = 15, + RuleKU_CreateRelTable = 16, RuleKU_CreateRelTableGroup = 17, RuleKU_RelTableConnection = 18, + RuleKU_CreateRdfGraph = 19, RuleKU_DropTable = 20, RuleKU_AlterTable = 21, + RuleKU_AlterOptions = 22, RuleKU_AddProperty = 23, RuleKU_DropProperty = 24, + RuleKU_RenameTable = 25, RuleKU_RenameProperty = 26, RuleKU_PropertyDefinitions = 27, + RuleKU_PropertyDefinition = 28, RuleKU_CreateNodeConstraint = 29, RuleKU_DataType = 30, + RuleKU_ListIdentifiers = 31, RuleKU_ListIdentifier = 32, RuleOC_AnyCypherOption = 33, + RuleOC_Explain = 34, RuleOC_Profile = 35, RuleKU_Transaction = 36, RuleOC_Query = 37, + RuleOC_RegularQuery = 38, RuleOC_Union = 39, RuleOC_SingleQuery = 40, + RuleOC_SinglePartQuery = 41, RuleOC_MultiPartQuery = 42, RuleKU_QueryPart = 43, + RuleOC_UpdatingClause = 44, RuleOC_ReadingClause = 45, RuleKU_LoadFrom = 46, + RuleKU_InQueryCall = 47, RuleOC_Match = 48, RuleOC_Unwind = 49, RuleOC_Create = 50, + RuleOC_Merge = 51, RuleOC_MergeAction = 52, RuleOC_Set = 53, RuleOC_SetItem = 54, + RuleOC_Delete = 55, RuleOC_With = 56, RuleOC_Return = 57, RuleOC_ProjectionBody = 58, + RuleOC_ProjectionItems = 59, RuleOC_ProjectionItem = 60, RuleOC_Order = 61, + RuleOC_Skip = 62, RuleOC_Limit = 63, RuleOC_SortItem = 64, RuleOC_Where = 65, + RuleOC_Pattern = 66, RuleOC_PatternPart = 67, RuleOC_AnonymousPatternPart = 68, + RuleOC_PatternElement = 69, RuleOC_NodePattern = 70, RuleOC_PatternElementChain = 71, + RuleOC_RelationshipPattern = 72, RuleOC_RelationshipDetail = 73, RuleKU_Properties = 74, + RuleOC_RelationshipTypes = 75, RuleOC_NodeLabels = 76, RuleOC_NodeLabel = 77, + RuleOC_RangeLiteral = 78, RuleKU_RecursiveRelationshipComprehension = 79, + RuleKU_IntermediateNodeProjectionItems = 80, RuleKU_IntermediateRelProjectionItems = 81, + RuleOC_LowerBound = 82, RuleOC_UpperBound = 83, RuleOC_LabelName = 84, + RuleOC_RelTypeName = 85, RuleOC_Expression = 86, RuleOC_OrExpression = 87, + RuleOC_XorExpression = 88, RuleOC_AndExpression = 89, RuleOC_NotExpression = 90, + RuleOC_ComparisonExpression = 91, RuleKU_ComparisonOperator = 92, RuleKU_BitwiseOrOperatorExpression = 93, + RuleKU_BitwiseAndOperatorExpression = 94, RuleKU_BitShiftOperatorExpression = 95, + RuleKU_BitShiftOperator = 96, RuleOC_AddOrSubtractExpression = 97, RuleKU_AddOrSubtractOperator = 98, + RuleOC_MultiplyDivideModuloExpression = 99, RuleKU_MultiplyDivideModuloOperator = 100, + RuleOC_PowerOfExpression = 101, RuleOC_UnaryAddSubtractOrFactorialExpression = 102, + RuleOC_StringListNullOperatorExpression = 103, RuleOC_ListOperatorExpression = 104, + RuleKU_ListExtractOperatorExpression = 105, RuleKU_ListSliceOperatorExpression = 106, + RuleOC_StringOperatorExpression = 107, RuleOC_RegularExpression = 108, + RuleOC_NullOperatorExpression = 109, RuleOC_PropertyOrLabelsExpression = 110, + RuleOC_Atom = 111, RuleOC_Literal = 112, RuleOC_BooleanLiteral = 113, + RuleOC_ListLiteral = 114, RuleKU_ListEntry = 115, RuleKU_StructLiteral = 116, + RuleKU_StructField = 117, RuleOC_ParenthesizedExpression = 118, RuleOC_FunctionInvocation = 119, + RuleOC_FunctionName = 120, RuleKU_FunctionParameter = 121, RuleOC_ExistentialSubquery = 122, + RuleOC_PropertyLookup = 123, RuleOC_CaseExpression = 124, RuleOC_CaseAlternative = 125, + RuleOC_Variable = 126, RuleOC_NumberLiteral = 127, RuleOC_Parameter = 128, + RuleOC_PropertyExpression = 129, RuleOC_PropertyKeyName = 130, RuleOC_IntegerLiteral = 131, + RuleOC_DoubleLiteral = 132, RuleOC_SchemaName = 133, RuleOC_SymbolicName = 134, + RuleKU_NonReservedKeywords = 135, RuleOC_LeftArrowHead = 136, RuleOC_RightArrowHead = 137, + RuleOC_Dash = 138 }; explicit CypherParser(antlr4::TokenStream *input); @@ -110,6 +111,7 @@ class CypherParser : public antlr4::Parser { class OC_CypherContext; class OC_StatementContext; class KU_CopyFromContext; + class KU_ColumnNamesContext; class KU_CopyFromByColumnContext; class KU_CopyTOContext; class KU_StandaloneCallContext; @@ -291,12 +293,27 @@ class CypherParser : public antlr4::Parser { antlr4::tree::TerminalNode *FROM(); KU_FilePathsContext *kU_FilePaths(); KU_ParsingOptionsContext *kU_ParsingOptions(); + KU_ColumnNamesContext *kU_ColumnNames(); }; KU_CopyFromContext* kU_CopyFrom(); + class KU_ColumnNamesContext : public antlr4::ParserRuleContext { + public: + KU_ColumnNamesContext(antlr4::ParserRuleContext *parent, size_t invokingState); + virtual size_t getRuleIndex() const override; + std::vector oC_SchemaName(); + OC_SchemaNameContext* oC_SchemaName(size_t i); + std::vector SP(); + antlr4::tree::TerminalNode* SP(size_t i); + + + }; + + KU_ColumnNamesContext* kU_ColumnNames(); + class KU_CopyFromByColumnContext : public antlr4::ParserRuleContext { public: KU_CopyFromByColumnContext(antlr4::ParserRuleContext *parent, size_t invokingState);