diff --git a/src/duckdb/extension/core_functions/function_list.cpp b/src/duckdb/extension/core_functions/function_list.cpp index 4987d2e3f..0f14a8113 100644 --- a/src/duckdb/extension/core_functions/function_list.cpp +++ b/src/duckdb/extension/core_functions/function_list.cpp @@ -196,6 +196,7 @@ static const StaticFunctionDefinition core_functions[] = { DUCKDB_SCALAR_FUNCTION_SET(GenerateSeriesFun), DUCKDB_SCALAR_FUNCTION(GetBitFun), DUCKDB_SCALAR_FUNCTION(GetCurrentTimestampFun), + DUCKDB_SCALAR_FUNCTION(GetTypeFun), DUCKDB_SCALAR_FUNCTION_SET_ALIAS(GradeUpFun), DUCKDB_SCALAR_FUNCTION_SET(GreatestFun), DUCKDB_SCALAR_FUNCTION_SET(GreatestCommonDivisorFun), @@ -266,6 +267,7 @@ static const StaticFunctionDefinition core_functions[] = { DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampFun), DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampMsFun), DUCKDB_SCALAR_FUNCTION_SET(MakeTimestampNsFun), + DUCKDB_SCALAR_FUNCTION(MakeTypeFun), DUCKDB_SCALAR_FUNCTION_SET(MapFun), DUCKDB_SCALAR_FUNCTION(MapConcatFun), DUCKDB_SCALAR_FUNCTION(MapEntriesFun), diff --git a/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp b/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp index 36afd4537..f8642e689 100644 --- a/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp +++ b/src/duckdb/extension/core_functions/include/core_functions/scalar/generic_functions.hpp @@ -85,6 +85,26 @@ struct TypeOfFun { static ScalarFunction GetFunction(); }; +struct GetTypeFun { + static constexpr const char *Name = "get_type"; + static constexpr const char *Parameters = "expression"; + static constexpr const char *Description = "Returns the type of the result of the expression"; + static constexpr const char *Example = "get_type('abc')"; + static constexpr const char *Categories = ""; + + static ScalarFunction GetFunction(); +}; + +struct MakeTypeFun { + static constexpr const char *Name = "make_type"; + static constexpr const char *Parameters = "name,..."; + static constexpr const char *Description = "Construct a type from its name and optional parameters"; + static constexpr const char *Example = "make_type('DECIMAL', 10, 2)"; + static constexpr const char *Categories = ""; + + static ScalarFunction GetFunction(); +}; + struct CanCastImplicitlyFun { static constexpr const char *Name = "can_cast_implicitly"; static constexpr const char *Parameters = "source_type,target_type"; diff --git a/src/duckdb/extension/core_functions/lambda_functions.cpp b/src/duckdb/extension/core_functions/lambda_functions.cpp index 89356921c..322c7a202 100644 --- a/src/duckdb/extension/core_functions/lambda_functions.cpp +++ b/src/duckdb/extension/core_functions/lambda_functions.cpp @@ -5,6 +5,7 @@ #include "duckdb/planner/expression/bound_function_expression.hpp" #include "duckdb/planner/expression/bound_cast_expression.hpp" +#include "duckdb/planner/expression/bound_lambda_expression.hpp" namespace duckdb { @@ -22,10 +23,11 @@ struct LambdaExecuteInfo { // get the input types for the input chunk vector input_types; + + input_types.push_back(child_vector.GetType()); if (has_index) { input_types.push_back(LogicalType::BIGINT); } - input_types.push_back(child_vector.GetType()); for (idx_t i = 1; i < args.ColumnCount(); i++) { input_types.push_back(args.data[i].GetType()); } @@ -152,8 +154,9 @@ struct ListFilterFunctor { // slice the input chunk's corresponding vector to get the new lists // and append them to the result - idx_t source_list_idx = execute_info.has_index ? 1 : 0; - Vector result_lists(execute_info.input_chunk.data[source_list_idx], sel, count); + + // The first vector in the input chunk is always the list vector + Vector result_lists(execute_info.input_chunk.data[0], sel, count); ListVector::Append(result, result_lists, count, 0); } }; @@ -190,8 +193,8 @@ static void ExecuteExpression(const idx_t elem_cnt, const LambdaFunctions::Colum // reference the child vector (and the index vector) if (info.has_index) { - info.input_chunk.data[0].Reference(index_vector); - info.input_chunk.data[1].Reference(slice); + info.input_chunk.data[0].Reference(slice); + info.input_chunk.data[1].Reference(index_vector); } else { info.input_chunk.data[0].Reference(slice); } @@ -247,7 +250,8 @@ LogicalType LambdaFunctions::DetermineListChildType(const LogicalType &child_typ } else if (child_type.id() == LogicalTypeId::LIST) { return ListType::GetChildType(child_type); } - throw InternalException("The first argument must be a list or array type"); + + throw BinderException("Invalid LIST argument during lambda function binding!"); } return child_type; diff --git a/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp b/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp index f4df3a25a..787dc77fd 100644 --- a/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp +++ b/src/duckdb/extension/core_functions/scalar/date/date_trunc.cpp @@ -517,7 +517,8 @@ unique_ptr DateTruncStatistics(vector &child_sta auto result = NumericStats::CreateEmpty(min_value.type()); NumericStats::SetMin(result, min_value); NumericStats::SetMax(result, max_value); - result.CopyValidity(child_stats[0]); + + result.CombineValidity(child_stats[0], child_stats[1]); return result.ToUnique(); } diff --git a/src/duckdb/extension/core_functions/scalar/generic/type_functions.cpp b/src/duckdb/extension/core_functions/scalar/generic/type_functions.cpp new file mode 100644 index 000000000..fb6b83812 --- /dev/null +++ b/src/duckdb/extension/core_functions/scalar/generic/type_functions.cpp @@ -0,0 +1,121 @@ +#include "core_functions/scalar/generic_functions.hpp" +#include "duckdb/planner/expression/bound_constant_expression.hpp" +#include "duckdb/planner/expression/bound_function_expression.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/planner/binder.hpp" +#include "duckdb/parser/expression/type_expression.hpp" +#include "duckdb/execution/expression_executor.hpp" + +namespace duckdb { + +//---------------------------------------------------------------------------------------------------------------------- +// typeof function +//---------------------------------------------------------------------------------------------------------------------- + +static void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) { + Value v(args.data[0].GetType().ToString()); + result.Reference(v); +} + +static unique_ptr BindTypeOfFunctionExpression(FunctionBindExpressionInput &input) { + auto &return_type = input.children[0]->return_type; + if (return_type.id() == LogicalTypeId::UNKNOWN || return_type.id() == LogicalTypeId::SQLNULL) { + // parameter - unknown return type + return nullptr; + } + // emit a constant expression + return make_uniq(Value(return_type.ToString())); +} + +ScalarFunction TypeOfFun::GetFunction() { + auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction); + fun.SetNullHandling(FunctionNullHandling::SPECIAL_HANDLING); + fun.SetBindExpressionCallback(BindTypeOfFunctionExpression); + return fun; +} + +//---------------------------------------------------------------------------------------------------------------------- +// get_type function +//---------------------------------------------------------------------------------------------------------------------- +// This is like "typeof", except returns LogicalType::TYPE instead of VARCHAR + +static void GetTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) { + auto v = Value::TYPE(args.data[0].GetType()); + result.Reference(v); +} + +static unique_ptr BindGetTypeFunctionExpression(FunctionBindExpressionInput &input) { + auto &return_type = input.children[0]->return_type; + if (return_type.id() == LogicalTypeId::UNKNOWN || return_type.id() == LogicalTypeId::SQLNULL) { + // parameter - unknown return type + return nullptr; + } + // emit a constant expression + return make_uniq(Value::TYPE(return_type)); +} + +ScalarFunction GetTypeFun::GetFunction() { + auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, GetTypeFunction); + fun.SetNullHandling(FunctionNullHandling::SPECIAL_HANDLING); + fun.SetBindExpressionCallback(BindGetTypeFunctionExpression); + return fun; +} + +//---------------------------------------------------------------------------------------------------------------------- +// make_type function +//---------------------------------------------------------------------------------------------------------------------- +static void MakeTypeFunction(DataChunk &args, ExpressionState &state, Vector &result) { + throw InvalidInputException("make_type function can only be used in constant expressions"); +} + +static unique_ptr BindMakeTypeFunctionExpression(FunctionBindExpressionInput &input) { + vector> args; + + // Evaluate all arguments to constant values + for (auto &child : input.children) { + string name = child->alias; + if (!child->IsFoldable()) { + throw BinderException("make_type function arguments must be constant expressions"); + } + auto val = ExpressionExecutor::EvaluateScalar(input.context, *child); + args.emplace_back(name, val); + } + + if (args.empty()) { + throw BinderException("make_type function requires at least one argument"); + } + + if (args.front().second.type() != LogicalType::VARCHAR) { + throw BinderException("make_type function first argument must be the type name as VARCHAR"); + } + + vector> type_args; + for (idx_t i = 1; i < args.size(); i++) { + auto &arg = args[i]; + auto result = make_uniq(arg.second); + result->SetAlias(arg.first); + + type_args.push_back(std::move(result)); + } + + auto type_name = args.front().second.GetValue(); + auto qualified_name = QualifiedName::Parse(type_name); + + auto unbound_type = LogicalType::UNBOUND(make_uniq(qualified_name.catalog, qualified_name.schema, + qualified_name.name, std::move(type_args))); + + // Bind the unbound type + auto binder = Binder::CreateBinder(input.context); + binder->BindLogicalType(unbound_type); + return make_uniq(Value::TYPE(unbound_type)); +} + +ScalarFunction MakeTypeFun::GetFunction() { + auto fun = ScalarFunction({LogicalType::VARCHAR}, LogicalType::TYPE(), MakeTypeFunction); + fun.SetNullHandling(FunctionNullHandling::SPECIAL_HANDLING); + fun.SetBindExpressionCallback(BindMakeTypeFunctionExpression); + fun.varargs = LogicalType::ANY; + return fun; +} + +} // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp b/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp deleted file mode 100644 index 008df7678..000000000 --- a/src/duckdb/extension/core_functions/scalar/generic/typeof.cpp +++ /dev/null @@ -1,33 +0,0 @@ -#include "core_functions/scalar/generic_functions.hpp" -#include "duckdb/planner/expression/bound_constant_expression.hpp" -#include "duckdb/planner/expression/bound_function_expression.hpp" - -namespace duckdb { - -namespace { - -void TypeOfFunction(DataChunk &args, ExpressionState &state, Vector &result) { - Value v(args.data[0].GetType().ToString()); - result.Reference(v); -} - -unique_ptr BindTypeOfFunctionExpression(FunctionBindExpressionInput &input) { - auto &return_type = input.children[0]->return_type; - if (return_type.id() == LogicalTypeId::UNKNOWN || return_type.id() == LogicalTypeId::SQLNULL) { - // parameter - unknown return type - return nullptr; - } - // emit a constant expression - return make_uniq(Value(return_type.ToString())); -} - -} // namespace - -ScalarFunction TypeOfFun::GetFunction() { - auto fun = ScalarFunction({LogicalType::ANY}, LogicalType::VARCHAR, TypeOfFunction); - fun.SetNullHandling(FunctionNullHandling::SPECIAL_HANDLING); - fun.SetBindExpressionCallback(BindTypeOfFunctionExpression); - return fun; -} - -} // namespace duckdb diff --git a/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp b/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp index 017c611a2..69fd5c906 100644 --- a/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/list_filter.cpp @@ -2,6 +2,7 @@ #include "duckdb/function/lambda_functions.hpp" #include "duckdb/planner/expression/bound_cast_expression.hpp" +#include "duckdb/planner/expression/bound_lambda_expression.hpp" namespace duckdb { diff --git a/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp b/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp index f3c23e98f..e55ed6155 100644 --- a/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/list_reduce.cpp @@ -1,6 +1,8 @@ #include "core_functions/scalar/list_functions.hpp" + #include "duckdb/function/lambda_functions.hpp" #include "duckdb/planner/expression/bound_cast_expression.hpp" +#include "duckdb/planner/expression/bound_lambda_expression.hpp" namespace duckdb { @@ -41,11 +43,13 @@ struct ReduceExecuteInfo { } left_slice->Slice(left_vector, reduced_row_idx); + input_types.push_back(left_slice->GetType()); + input_types.push_back(left_slice->GetType()); + if (info.has_index) { input_types.push_back(LogicalType::BIGINT); } - input_types.push_back(left_slice->GetType()); - input_types.push_back(left_slice->GetType()); + // skip the first entry if there is an initial value for (idx_t i = info.has_initial ? 1 : 0; i < info.column_infos.size(); i++) { input_types.push_back(info.column_infos[i].vector.get().GetType()); @@ -133,18 +137,19 @@ bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFun input_chunk.InitializeEmpty(execute_info.input_types); input_chunk.SetCardinality(reduced_row_idx); - const idx_t slice_offset = info.has_index ? 1 : 0; - if (info.has_index) { - input_chunk.data[0].Reference(index_vector); - } + idx_t vec_offset = 0; if (loops == 0 && info.has_initial) { - info.column_infos[0].vector.get().Slice(execute_info.active_rows_sel, reduced_row_idx); - input_chunk.data[slice_offset + 1].Reference(info.column_infos[0].vector); + info.column_infos[vec_offset].vector.get().Slice(execute_info.active_rows_sel, reduced_row_idx); + input_chunk.data[vec_offset++].Reference(info.column_infos[0].vector); } else { - input_chunk.data[slice_offset + 1].Reference(*execute_info.left_slice); + input_chunk.data[vec_offset++].Reference(*execute_info.left_slice); + } + input_chunk.data[vec_offset++].Reference(right_slice); + + if (info.has_index) { + input_chunk.data[vec_offset++].Reference(index_vector); } - input_chunk.data[slice_offset].Reference(right_slice); // add the other columns // skip the initial value if there is one @@ -153,12 +158,12 @@ bool ExecuteReduce(const idx_t loops, ReduceExecuteInfo &execute_info, LambdaFun for (idx_t i = 0; i < info.column_infos.size() - initial_offset; i++) { if (info.column_infos[i].vector.get().GetVectorType() == VectorType::CONSTANT_VECTOR) { // only reference constant vectors - input_chunk.data[slice_offset + 2 + i].Reference(info.column_infos[initial_offset + i].vector); + input_chunk.data[vec_offset++].Reference(info.column_infos[initial_offset + i].vector); } else { // slice the other vectors slices.emplace_back(info.column_infos[initial_offset + i].vector, execute_info.active_rows_sel, reduced_row_idx); - input_chunk.data[slice_offset + 2 + i].Reference(slices.back()); + input_chunk.data[vec_offset++].Reference(slices.back()); } } diff --git a/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp b/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp index be4f319a9..c9aada10b 100644 --- a/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp +++ b/src/duckdb/extension/core_functions/scalar/list/list_transform.cpp @@ -2,6 +2,7 @@ #include "duckdb/function/lambda_functions.hpp" #include "duckdb/planner/expression/bound_cast_expression.hpp" +#include "duckdb/planner/expression/bound_lambda_expression.hpp" namespace duckdb { diff --git a/src/duckdb/extension/icu/icu-makedate.cpp b/src/duckdb/extension/icu/icu-makedate.cpp index 128e80d93..fb477122d 100644 --- a/src/duckdb/extension/icu/icu-makedate.cpp +++ b/src/duckdb/extension/icu/icu-makedate.cpp @@ -2,13 +2,12 @@ #include "duckdb/common/operator/cast_operators.hpp" #include "duckdb/common/operator/subtract.hpp" #include "duckdb/common/types/date.hpp" -#include "duckdb/common/types/time.hpp" #include "duckdb/common/types/timestamp.hpp" #include "duckdb/common/vector_operations/senary_executor.hpp" #include "duckdb/common/vector_operations/septenary_executor.hpp" #include "duckdb/function/cast/cast_function_set.hpp" #include "duckdb/main/extension/extension_loader.hpp" -#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp" +#include "duckdb/main/settings.hpp" #include "include/icu-casts.hpp" #include "include/icu-datefunc.hpp" #include "include/icu-datetrunc.hpp" @@ -57,6 +56,10 @@ BoundCastInfo ICUMakeDate::BindCastToDate(BindCastInput &input, const LogicalTyp if (!input.context) { throw InternalException("Missing context for TIMESTAMPTZ to DATE cast."); } + if (Settings::Get(*input.context)) { + throw BinderException("Casting from TIMESTAMP WITH TIME ZONE to DATE without an explicit time zone " + "has been disabled - use \"AT TIME ZONE ...\""); + } auto cast_data = make_uniq(make_uniq(*input.context)); @@ -80,7 +83,7 @@ struct ICUMakeTimestampTZFunc : public ICUDateFunc { ss -= secs; ss *= Interval::MSECS_PER_SEC; const auto millis = int32_t(ss); - int64_t micros = std::round((ss - millis) * Interval::MICROS_PER_MSEC); + int64_t micros = LossyNumericCast(std::round((ss - millis) * Interval::MICROS_PER_MSEC)); calendar->set(UCAL_YEAR, year); calendar->set(UCAL_MONTH, month); diff --git a/src/duckdb/extension/icu/icu-timezone.cpp b/src/duckdb/extension/icu/icu-timezone.cpp index 65993beaf..d3925df39 100644 --- a/src/duckdb/extension/icu/icu-timezone.cpp +++ b/src/duckdb/extension/icu/icu-timezone.cpp @@ -164,7 +164,7 @@ struct ICUFromNaiveTimestamp : public ICUDateFunc { if (!input.context) { throw InternalException("Missing context for TIMESTAMP to TIMESTAMPTZ cast."); } - if (DBConfig::GetSetting(*input.context)) { + if (Settings::Get(*input.context)) { throw BinderException("Casting from TIMESTAMP to TIMESTAMP WITH TIME ZONE without an explicit time zone " "has been disabled - use \"AT TIME ZONE ...\""); } @@ -251,7 +251,7 @@ struct ICUToNaiveTimestamp : public ICUDateFunc { if (!input.context) { throw InternalException("Missing context for TIMESTAMPTZ to TIMESTAMP cast."); } - if (DBConfig::GetSetting(*input.context)) { + if (Settings::Get(*input.context)) { throw BinderException("Casting from TIMESTAMP WITH TIME ZONE to TIMESTAMP without an explicit time zone " "has been disabled - use \"AT TIME ZONE ...\""); } diff --git a/src/duckdb/extension/json/json_functions/json_create.cpp b/src/duckdb/extension/json/json_functions/json_create.cpp index d1c8a8afb..f7566002f 100644 --- a/src/duckdb/extension/json/json_functions/json_create.cpp +++ b/src/duckdb/extension/json/json_functions/json_create.cpp @@ -605,8 +605,9 @@ static void CreateValues(const StructNames &names, yyjson_mut_doc *doc, yyjson_m case LogicalTypeId::INVALID: case LogicalTypeId::UNKNOWN: case LogicalTypeId::ANY: - case LogicalTypeId::USER: case LogicalTypeId::TEMPLATE: + case LogicalTypeId::UNBOUND: + case LogicalTypeId::TYPE: case LogicalTypeId::VARIANT: case LogicalTypeId::CHAR: case LogicalTypeId::STRING_LITERAL: diff --git a/src/duckdb/extension/parquet/include/column_writer.hpp b/src/duckdb/extension/parquet/include/column_writer.hpp index 1463137ad..816045ae7 100644 --- a/src/duckdb/extension/parquet/include/column_writer.hpp +++ b/src/duckdb/extension/parquet/include/column_writer.hpp @@ -145,7 +145,7 @@ class ColumnWriter { throw NotImplementedException("Writer doesn't require an AnalyzeSchemaFinalize pass"); } - virtual void FinalizeSchema(vector &schemas) = 0; + virtual idx_t FinalizeSchema(vector &schemas) = 0; //! Create the column writer for a specific type recursively static unique_ptr CreateWriterRecursive(ClientContext &context, ParquetWriter &writer, diff --git a/src/duckdb/extension/parquet/include/parquet_shredding.hpp b/src/duckdb/extension/parquet/include/parquet_shredding.hpp index f43cbc42c..9e4e5ebe5 100644 --- a/src/duckdb/extension/parquet/include/parquet_shredding.hpp +++ b/src/duckdb/extension/parquet/include/parquet_shredding.hpp @@ -36,7 +36,7 @@ struct ShreddingType { static ShreddingType Deserialize(Deserializer &source); public: - static ShreddingType GetShreddingTypes(const Value &val); + static ShreddingType GetShreddingTypes(const Value &val, ClientContext &context); void AddChild(const string &name, ShreddingType &&child); optional_ptr GetChild(const string &name) const; diff --git a/src/duckdb/extension/parquet/include/writer/list_column_writer.hpp b/src/duckdb/extension/parquet/include/writer/list_column_writer.hpp index df7ecf276..5cdbdd22f 100644 --- a/src/duckdb/extension/parquet/include/writer/list_column_writer.hpp +++ b/src/duckdb/extension/parquet/include/writer/list_column_writer.hpp @@ -44,7 +44,7 @@ class ListColumnWriter : public ColumnWriter { void BeginWrite(ColumnWriterState &state) override; void Write(ColumnWriterState &state, Vector &vector, idx_t count) override; void FinalizeWrite(ColumnWriterState &state) override; - void FinalizeSchema(vector &schemas) override; + idx_t FinalizeSchema(vector &schemas) override; protected: ColumnWriter &GetChildWriter(); diff --git a/src/duckdb/extension/parquet/include/writer/parquet_write_operators.hpp b/src/duckdb/extension/parquet/include/writer/parquet_write_operators.hpp index 95bf21e2a..687f7afd7 100644 --- a/src/duckdb/extension/parquet/include/writer/parquet_write_operators.hpp +++ b/src/duckdb/extension/parquet/include/writer/parquet_write_operators.hpp @@ -237,11 +237,6 @@ struct ParquetIntervalOperator : public BaseParquetOperator { } }; -struct ParquetUUIDTargetType { - static constexpr const idx_t PARQUET_UUID_SIZE = 16; - data_t bytes[PARQUET_UUID_SIZE]; -}; - struct ParquetUUIDOperator : public BaseParquetOperator { template static TGT Operation(SRC input) { @@ -274,11 +269,13 @@ struct ParquetUUIDOperator : public BaseParquetOperator { template static void HandleStats(ColumnWriterStatistics *stats_p, TGT target_value) { auto &stats = stats_p->Cast(); - if (!stats.has_stats || memcmp(target_value.bytes, stats.min, ParquetUUIDTargetType::PARQUET_UUID_SIZE) < 0) { - memcpy(stats.min, target_value.bytes, ParquetUUIDTargetType::PARQUET_UUID_SIZE); + if (!stats.has_stats || + memcmp(target_value.bytes, stats.min.bytes, ParquetUUIDTargetType::PARQUET_UUID_SIZE) < 0) { + stats.min = target_value; } - if (!stats.has_stats || memcmp(target_value.bytes, stats.max, ParquetUUIDTargetType::PARQUET_UUID_SIZE) > 0) { - memcpy(stats.max, target_value.bytes, ParquetUUIDTargetType::PARQUET_UUID_SIZE); + if (!stats.has_stats || + memcmp(target_value.bytes, stats.max.bytes, ParquetUUIDTargetType::PARQUET_UUID_SIZE) > 0) { + stats.max = target_value; } stats.has_stats = true; } diff --git a/src/duckdb/extension/parquet/include/writer/parquet_write_stats.hpp b/src/duckdb/extension/parquet/include/writer/parquet_write_stats.hpp index 840830e3a..dc42ce211 100644 --- a/src/duckdb/extension/parquet/include/writer/parquet_write_stats.hpp +++ b/src/duckdb/extension/parquet/include/writer/parquet_write_stats.hpp @@ -227,11 +227,16 @@ class StringStatisticsState : public ColumnWriterStatistics { } }; +struct ParquetUUIDTargetType { + static constexpr const idx_t PARQUET_UUID_SIZE = 16; + data_t bytes[PARQUET_UUID_SIZE]; +}; + class UUIDStatisticsState : public ColumnWriterStatistics { public: bool has_stats = false; - data_t min[16] = {0}; - data_t max[16] = {0}; + ParquetUUIDTargetType min; + ParquetUUIDTargetType max; public: bool HasStats() override { @@ -245,10 +250,10 @@ class UUIDStatisticsState : public ColumnWriterStatistics { return GetMaxValue(); } string GetMinValue() override { - return HasStats() ? string(char_ptr_cast(min), 16) : string(); + return HasStats() ? string(char_ptr_cast(min.bytes), ParquetUUIDTargetType::PARQUET_UUID_SIZE) : string(); } string GetMaxValue() override { - return HasStats() ? string(char_ptr_cast(max), 16) : string(); + return HasStats() ? string(char_ptr_cast(max.bytes), ParquetUUIDTargetType::PARQUET_UUID_SIZE) : string(); } }; diff --git a/src/duckdb/extension/parquet/include/writer/primitive_column_writer.hpp b/src/duckdb/extension/parquet/include/writer/primitive_column_writer.hpp index 36874cf6d..3b3dd5dbe 100644 --- a/src/duckdb/extension/parquet/include/writer/primitive_column_writer.hpp +++ b/src/duckdb/extension/parquet/include/writer/primitive_column_writer.hpp @@ -74,7 +74,7 @@ class PrimitiveColumnWriter : public ColumnWriter { void BeginWrite(ColumnWriterState &state) override; void Write(ColumnWriterState &state, Vector &vector, idx_t count) override; void FinalizeWrite(ColumnWriterState &state) override; - void FinalizeSchema(vector &schemas) override; + idx_t FinalizeSchema(vector &schemas) override; protected: static void WriteLevels(Allocator &allocator, WriteStream &temp_writer, const unsafe_vector &levels, diff --git a/src/duckdb/extension/parquet/include/writer/struct_column_writer.hpp b/src/duckdb/extension/parquet/include/writer/struct_column_writer.hpp index a3d433467..a35177de7 100644 --- a/src/duckdb/extension/parquet/include/writer/struct_column_writer.hpp +++ b/src/duckdb/extension/parquet/include/writer/struct_column_writer.hpp @@ -32,7 +32,7 @@ class StructColumnWriter : public ColumnWriter { void BeginWrite(ColumnWriterState &state) override; void Write(ColumnWriterState &state, Vector &vector, idx_t count) override; void FinalizeWrite(ColumnWriterState &state) override; - void FinalizeSchema(vector &schemas) override; + idx_t FinalizeSchema(vector &schemas) override; }; } // namespace duckdb diff --git a/src/duckdb/extension/parquet/include/writer/variant_column_writer.hpp b/src/duckdb/extension/parquet/include/writer/variant_column_writer.hpp index 07250c4ac..2c537f571 100644 --- a/src/duckdb/extension/parquet/include/writer/variant_column_writer.hpp +++ b/src/duckdb/extension/parquet/include/writer/variant_column_writer.hpp @@ -72,7 +72,7 @@ class VariantColumnWriter : public StructColumnWriter { ~VariantColumnWriter() override = default; public: - void FinalizeSchema(vector &schemas) override; + idx_t FinalizeSchema(vector &schemas) override; unique_ptr AnalyzeSchemaInit() override; void AnalyzeSchema(ParquetAnalyzeSchemaState &state, Vector &input, idx_t count) override; void AnalyzeSchemaFinalize(const ParquetAnalyzeSchemaState &state) override; diff --git a/src/duckdb/extension/parquet/parquet_extension.cpp b/src/duckdb/extension/parquet/parquet_extension.cpp index 59102a8eb..3f78bf482 100644 --- a/src/duckdb/extension/parquet/parquet_extension.cpp +++ b/src/duckdb/extension/parquet/parquet_extension.cpp @@ -248,7 +248,8 @@ static unique_ptr ParquetWriteBind(ClientContext &context, CopyFun } } const auto &child_value = struct_children[i]; - bind_data->shredding_types.AddChild(col_name, ShreddingType::GetShreddingTypes(child_value)); + bind_data->shredding_types.AddChild(col_name, + ShreddingType::GetShreddingTypes(child_value, context)); } } } else if (loption == "kv_metadata") { @@ -340,7 +341,7 @@ static unique_ptr ParquetWriteBind(ClientContext &context, CopyFun } } if (row_group_size_bytes_set) { - if (DBConfig::GetSetting(context)) { + if (Settings::Get(context)) { throw BinderException("ROW_GROUP_SIZE_BYTES does not work while preserving insertion order. Use \"SET " "preserve_insertion_order=false;\" to disable preserving insertion order."); } @@ -659,7 +660,8 @@ static unique_ptr ParquetCopyDeserialize(Deserializer &deserialize 115, "string_dictionary_page_size_limit", default_value.string_dictionary_page_size_limit); data->geoparquet_version = deserializer.ReadPropertyWithExplicitDefault(116, "geoparquet_version", default_value.geoparquet_version); - data->shredding_types = deserializer.ReadProperty(117, "shredding_types"); + data->shredding_types = + deserializer.ReadPropertyWithExplicitDefault(117, "shredding_types", ShreddingType()); return std::move(data); } diff --git a/src/duckdb/extension/parquet/parquet_reader.cpp b/src/duckdb/extension/parquet/parquet_reader.cpp index 8f4cd3997..f08fd1912 100644 --- a/src/duckdb/extension/parquet/parquet_reader.cpp +++ b/src/duckdb/extension/parquet/parquet_reader.cpp @@ -786,7 +786,7 @@ ParquetColumnDefinition ParquetColumnDefinition::FromSchemaValue(ClientContext & const auto children = StructValue::GetChildren(column_def); result.name = StringValue::Get(children[0]); - result.type = TransformStringToLogicalType(StringValue::Get(children[1])); + result.type = TransformStringToLogicalType(StringValue::Get(children[1]), context); string error_message; if (!children[2].TryCastAs(context, result.type, result.default_value, &error_message)) { throw BinderException("Unable to cast Parquet schema default_value \"%s\" to %s", children[2].ToString(), diff --git a/src/duckdb/extension/parquet/parquet_shredding.cpp b/src/duckdb/extension/parquet/parquet_shredding.cpp index b7ed673a8..c5f5092ea 100644 --- a/src/duckdb/extension/parquet/parquet_shredding.cpp +++ b/src/duckdb/extension/parquet/parquet_shredding.cpp @@ -68,12 +68,12 @@ optional_ptr ShreddingType::GetChild(const string &name) co return it->second; } -ShreddingType ShreddingType::GetShreddingTypes(const Value &val) { +ShreddingType ShreddingType::GetShreddingTypes(const Value &val, ClientContext &context) { if (val.type().id() != LogicalTypeId::VARCHAR) { throw BinderException("SHREDDING value should be of type VARCHAR, a stringified type to use for the column"); } auto type_str = val.GetValue(); - auto logical_type = TransformStringToLogicalType(type_str); + auto logical_type = TransformStringToLogicalType(type_str, context); return ConvertShreddingTypeRecursive(logical_type); } diff --git a/src/duckdb/extension/parquet/parquet_writer.cpp b/src/duckdb/extension/parquet/parquet_writer.cpp index e5b4427e7..11843009b 100644 --- a/src/duckdb/extension/parquet/parquet_writer.cpp +++ b/src/duckdb/extension/parquet/parquet_writer.cpp @@ -411,11 +411,6 @@ ParquetWriter::ParquetWriter(ClientContext &context, FileSystem &fs, string file file_meta_data.created_by = StringUtil::Format("DuckDB version %s (build %s)", DuckDB::LibraryVersion(), DuckDB::SourceID()); - duckdb_parquet::ColumnOrder column_order; - column_order.__set_TYPE_ORDER(duckdb_parquet::TypeDefinedOrder()); - file_meta_data.column_orders.resize(column_names.size(), column_order); - file_meta_data.__isset.column_orders = true; - for (auto &kv_pair : kv_metadata) { duckdb_parquet::KeyValue kv; kv.__set_key(kv_pair.first); @@ -524,9 +519,15 @@ void ParquetWriter::InitializeSchemaElements() { file_meta_data.schema[0].repetition_type = duckdb_parquet::FieldRepetitionType::REQUIRED; file_meta_data.schema[0].__isset.repetition_type = true; + idx_t unique_columns = 0; for (auto &column_writer : column_writers) { - column_writer->FinalizeSchema(file_meta_data.schema); + unique_columns += column_writer->FinalizeSchema(file_meta_data.schema); } + + duckdb_parquet::ColumnOrder column_order; + column_order.__set_TYPE_ORDER(duckdb_parquet::TypeDefinedOrder()); + file_meta_data.column_orders.resize(unique_columns, column_order); + file_meta_data.__isset.column_orders = true; } void ParquetWriter::PrepareRowGroup(ColumnDataCollection &raw_buffer, PreparedRowGroup &result, diff --git a/src/duckdb/extension/parquet/writer/list_column_writer.cpp b/src/duckdb/extension/parquet/writer/list_column_writer.cpp index a54017f23..f7d61bd1e 100644 --- a/src/duckdb/extension/parquet/writer/list_column_writer.cpp +++ b/src/duckdb/extension/parquet/writer/list_column_writer.cpp @@ -146,7 +146,7 @@ ColumnWriter &ListColumnWriter::GetChildWriter() { return *child_writers[0]; } -void ListColumnWriter::FinalizeSchema(vector &schemas) { +idx_t ListColumnWriter::FinalizeSchema(vector &schemas) { idx_t schema_idx = schemas.size(); auto &schema = column_schema; @@ -189,7 +189,7 @@ void ListColumnWriter::FinalizeSchema(vector &sch //! Instead, the "key_value" struct will be marked as REPEATED D_ASSERT(GetChildWriter().Schema().repetition_type == FieldRepetitionType::REPEATED); } - GetChildWriter().FinalizeSchema(schemas); + return GetChildWriter().FinalizeSchema(schemas); } } // namespace duckdb diff --git a/src/duckdb/extension/parquet/writer/primitive_column_writer.cpp b/src/duckdb/extension/parquet/writer/primitive_column_writer.cpp index dcaf80520..841b3df9f 100644 --- a/src/duckdb/extension/parquet/writer/primitive_column_writer.cpp +++ b/src/duckdb/extension/parquet/writer/primitive_column_writer.cpp @@ -431,7 +431,7 @@ void PrimitiveColumnWriter::WriteDictionary(PrimitiveColumnWriterState &state, u state.write_info.insert(state.write_info.begin(), std::move(write_info)); } -void PrimitiveColumnWriter::FinalizeSchema(vector &schemas) { +idx_t PrimitiveColumnWriter::FinalizeSchema(vector &schemas) { idx_t schema_idx = schemas.size(); auto &schema = column_schema; @@ -458,6 +458,7 @@ void PrimitiveColumnWriter::FinalizeSchema(vector schemas.push_back(std::move(schema_element)); D_ASSERT(child_writers.empty()); + return 1; } } // namespace duckdb diff --git a/src/duckdb/extension/parquet/writer/struct_column_writer.cpp b/src/duckdb/extension/parquet/writer/struct_column_writer.cpp index a792b736b..d17b32d06 100644 --- a/src/duckdb/extension/parquet/writer/struct_column_writer.cpp +++ b/src/duckdb/extension/parquet/writer/struct_column_writer.cpp @@ -105,7 +105,7 @@ void StructColumnWriter::FinalizeWrite(ColumnWriterState &state_p) { } } -void StructColumnWriter::FinalizeSchema(vector &schemas) { +idx_t StructColumnWriter::FinalizeSchema(vector &schemas) { idx_t schema_idx = schemas.size(); auto &schema = column_schema; @@ -129,9 +129,11 @@ void StructColumnWriter::FinalizeSchema(vector &s } schemas.push_back(std::move(schema_element)); + idx_t unique_columns = 0; for (auto &child_writer : child_writers) { - child_writer->FinalizeSchema(schemas); + unique_columns += child_writer->FinalizeSchema(schemas); } + return unique_columns; } } // namespace duckdb diff --git a/src/duckdb/extension/parquet/writer/variant/analyze_variant.cpp b/src/duckdb/extension/parquet/writer/variant/analyze_variant.cpp index c7575d09f..c7c84daa4 100644 --- a/src/duckdb/extension/parquet/writer/variant/analyze_variant.cpp +++ b/src/duckdb/extension/parquet/writer/variant/analyze_variant.cpp @@ -87,8 +87,8 @@ namespace { struct ShredAnalysisState { idx_t highest_count = 0; - LogicalTypeId type_id; - PhysicalType decimal_type; + LogicalTypeId type_id = LogicalTypeId::VARIANT; + PhysicalType decimal_type = PhysicalType::INVALID; }; } // namespace @@ -182,10 +182,13 @@ static LogicalType ConstructShreddedType(const VariantAnalyzeData &state) { void VariantColumnWriter::AnalyzeSchemaFinalize(const ParquetAnalyzeSchemaState &state_p) { auto &state = state_p.Cast(); auto shredded_type = ConstructShreddedType(state.analyze_data); - - auto typed_value = TransformTypedValueRecursive(shredded_type); is_analyzed = true; + if (shredded_type.id() == LogicalTypeId::VARIANT) { + //! Can't shred, keep the original children + return; + } + auto typed_value = TransformTypedValueRecursive(shredded_type); auto &schema = Schema(); auto &context = writer.GetContext(); D_ASSERT(child_writers.size() == 2); diff --git a/src/duckdb/extension/parquet/writer/variant/convert_variant.cpp b/src/duckdb/extension/parquet/writer/variant/convert_variant.cpp index f7be8c755..6bcccd867 100644 --- a/src/duckdb/extension/parquet/writer/variant/convert_variant.cpp +++ b/src/duckdb/extension/parquet/writer/variant/convert_variant.cpp @@ -5,6 +5,7 @@ #include "reader/variant/variant_binary_decoder.hpp" #include "parquet_shredding.hpp" #include "duckdb/function/variant/variant_shredding.hpp" +#include "duckdb/planner/expression_binder.hpp" namespace duckdb { @@ -809,7 +810,7 @@ static void ToParquetVariant(DataChunk &input, ExpressionState &state, Vector &r } } -void VariantColumnWriter::FinalizeSchema(vector &schemas) { +idx_t VariantColumnWriter::FinalizeSchema(vector &schemas) { idx_t schema_idx = schemas.size(); auto &schema = Schema(); @@ -831,9 +832,11 @@ void VariantColumnWriter::FinalizeSchema(vector & top_element.name = name; schemas.push_back(std::move(top_element)); + idx_t unique_columns = 0; for (auto &child_writer : child_writers) { - child_writer->FinalizeSchema(schemas); + unique_columns += child_writer->FinalizeSchema(schemas); } + return unique_columns; } LogicalType VariantColumnWriter::TransformTypedValueRecursive(const LogicalType &type) { @@ -875,7 +878,7 @@ static LogicalType GetParquetVariantType(optional_ptr shredding = n child_list_t children; children.emplace_back("metadata", LogicalType::BLOB); children.emplace_back("value", LogicalType::BLOB); - if (shredding) { + if (shredding && shredding->id() != LogicalTypeId::VARIANT) { children.emplace_back("typed_value", VariantColumnWriter::TransformTypedValueRecursive(*shredding)); } auto res = LogicalType::STRUCT(std::move(children)); @@ -906,7 +909,7 @@ static unique_ptr BindTransform(ClientContext &context, ScalarFunc if (type_str.IsNull()) { throw BinderException("Optional second argument 'shredding' can not be NULL"); } - auto shredded_type = TransformStringToLogicalType(type_str.GetValue()); + auto shredded_type = TransformStringToLogicalType(type_str.GetValue(), context); bound_function.SetReturnType(GetParquetVariantType(shredded_type)); } else { bound_function.SetReturnType(GetParquetVariantType()); diff --git a/src/duckdb/src/catalog/catalog.cpp b/src/duckdb/src/catalog/catalog.cpp index 0dec15f20..de3fca397 100644 --- a/src/duckdb/src/catalog/catalog.cpp +++ b/src/duckdb/src/catalog/catalog.cpp @@ -139,6 +139,10 @@ optional_ptr Catalog::CreateTable(ClientContext &context, unique_p optional_ptr Catalog::CreateTable(CatalogTransaction transaction, SchemaCatalogEntry &schema, BoundCreateTableInfo &info) { + auto supports_create_table = SupportsCreateTable(info); + if (supports_create_table.HasError()) { + supports_create_table.Throw(); + } return schema.CreateTable(transaction, info); } @@ -520,8 +524,7 @@ bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) n return true; } #ifndef DUCKDB_DISABLE_EXTENSION_LOAD - auto &dbconfig = DBConfig::GetConfig(context); - if (!dbconfig.options.autoload_known_extensions) { + if (!Settings::Get(context)) { return false; } try { @@ -537,8 +540,7 @@ bool Catalog::TryAutoLoad(ClientContext &context, const string &original_name) n String Catalog::AutoloadExtensionByConfigName(ClientContext &context, const String &configuration_name) { #ifndef DUCKDB_DISABLE_EXTENSION_LOAD - auto &dbconfig = DBConfig::GetConfig(context); - if (dbconfig.options.autoload_known_extensions) { + if (Settings::Get(context)) { auto extension_name = ExtensionHelper::FindExtensionInEntries(configuration_name.ToStdString(), EXTENSION_SETTINGS); if (ExtensionHelper::CanAutoloadExtension(extension_name)) { @@ -594,8 +596,7 @@ static bool CompareCatalogTypes(CatalogType type_a, CatalogType type_b) { bool Catalog::AutoLoadExtensionByCatalogEntry(DatabaseInstance &db, CatalogType type, const string &entry_name) { #ifndef DUCKDB_DISABLE_EXTENSION_LOAD - auto &dbconfig = DBConfig::GetConfig(db); - if (dbconfig.options.autoload_known_extensions) { + if (Settings::Get(db)) { string extension_name; if (IsAutoloadableFunction(type)) { auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS); @@ -640,7 +641,7 @@ CatalogException Catalog::UnrecognizedConfigurationError(ClientContext &context, // the setting is not in an extension // get a list of all options vector potential_names = DBConfig::GetOptionNames(); - for (auto &entry : DBConfig::GetConfig(context).extension_parameters) { + for (auto &entry : DBConfig::GetConfig(context).GetExtensionSettings()) { potential_names.push_back(entry.first); } throw CatalogException::MissingEntry("configuration parameter", name, potential_names); @@ -651,7 +652,7 @@ CatalogException Catalog::CreateMissingEntryException(CatalogEntryRetriever &ret const reference_set_t &schemas) { auto &context = retriever.GetContext(); auto entries = SimilarEntriesInSchemas(context, lookup_info, schemas); - auto max_schema_count = DBConfig::GetSetting(context); + auto max_schema_count = Settings::Get(context); reference_set_t unseen_schemas; auto &db_manager = DatabaseManager::Get(context); @@ -1211,6 +1212,25 @@ optional_ptr Catalog::GetDependencyManager() { return nullptr; } +ErrorData Catalog::SupportsCreateTable(BoundCreateTableInfo &info) { + auto &base = info.Base().Cast(); + if (!base.partition_keys.empty()) { + return ErrorData( + ExceptionType::CATALOG, + StringUtil::Format("PARTITIONED BY is not supported for tables in a %s catalog", GetCatalogType())); + } + if (!base.sort_keys.empty()) { + return ErrorData(ExceptionType::CATALOG, + StringUtil::Format("SORTED BY is not supported for tables in a %s catalog", GetCatalogType())); + } + if (!base.options.empty()) { + return ErrorData( + ExceptionType::CATALOG, + StringUtil::Format("WITH clause is not supported for tables in a %s catalog", GetCatalogType())); + } + return ErrorData(); +} + string Catalog::GetDefaultSchema() const { return DEFAULT_SCHEMA; } diff --git a/src/duckdb/src/catalog/catalog_entry/aggregate_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/aggregate_function_catalog_entry.cpp new file mode 100644 index 000000000..e8c653d94 --- /dev/null +++ b/src/duckdb/src/catalog/catalog_entry/aggregate_function_catalog_entry.cpp @@ -0,0 +1,17 @@ +#include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp" +#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp" +#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" +#include "duckdb/main/attached_database.hpp" + +namespace duckdb { + +AggregateFunctionCatalogEntry::AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, + CreateAggregateFunctionInfo &info) + : FunctionEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) { + for (auto &function : functions.functions) { + function.catalog_name = catalog.GetAttached().GetName(); + function.schema_name = schema.name; + } +} + +} // namespace duckdb diff --git a/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp b/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp index eda90ac9e..365561fd4 100644 --- a/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp +++ b/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp @@ -53,6 +53,10 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou // create the physical storage vector column_defs; for (auto &col_def : columns.Physical()) { + if (TypeVisitor::Contains(col_def.Type(), LogicalTypeId::TYPE)) { + throw InvalidInputException("A table cannot be created with a 'TYPE' column"); + } + column_defs.push_back(col_def.Copy()); } storage = make_shared_ptr(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info), @@ -242,6 +246,11 @@ unique_ptr DuckTableEntry::AlterEntry(ClientContext &context, Alte throw NotImplementedException("SET PARTITIONED BY is not supported for DuckDB tables"); case AlterTableType::SET_SORTED_BY: throw NotImplementedException("SET SORTED BY is not supported for DuckDB tables"); + case AlterTableType::SET_TABLE_OPTIONS: + throw NotImplementedException("SET () is not supported for DuckDB tables"); + case AlterTableType::RESET_TABLE_OPTIONS: { + throw NotImplementedException("RESET () is not supported for DuckDB tables"); + } default: throw InternalException("Unrecognized alter table type!"); } @@ -359,8 +368,11 @@ unique_ptr DuckTableEntry::AddColumn(ClientContext &context, AddCo for (auto &constraint : constraints) { create_info->constraints.push_back(constraint->Copy()); } + auto binder = Binder::CreateBinder(context); - binder->BindLogicalType(info.new_column.TypeMutable(), &catalog, schema.name); + binder->SetSearchPath(catalog, schema.name); + binder->BindLogicalType(info.new_column.TypeMutable()); + info.new_column.SetOid(columns.LogicalColumnCount()); info.new_column.SetStorageOid(columns.PhysicalColumnCount()); auto col = info.new_column.Copy(); @@ -973,8 +985,10 @@ unique_ptr DuckTableEntry::DropNotNull(ClientContext &context, Dro } unique_ptr DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) { - auto binder = Binder::CreateBinder(context); - binder->BindLogicalType(info.target_type, &catalog, schema.name); + // Bind type + auto type_binder = Binder::CreateBinder(context); + type_binder->SetSearchPath(catalog, schema.name); + type_binder->BindLogicalType(info.target_type); auto change_idx = GetColumnIndex(info.column_name); auto create_info = make_uniq(schema, name); @@ -983,6 +997,7 @@ unique_ptr DuckTableEntry::ChangeColumnType(ClientContext &context create_info->tags = tags; // Bind the USING expression. + auto binder = Binder::CreateBinder(context); vector bound_columns; AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type); auto expression = info.expression->Copy(); diff --git a/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp index e5778ad4c..16cc2627b 100644 --- a/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp +++ b/src/duckdb/src/catalog/catalog_entry/scalar_function_catalog_entry.cpp @@ -1,7 +1,9 @@ #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp" + +#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" #include "duckdb/common/vector.hpp" -#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp" #include "duckdb/main/attached_database.hpp" +#include "duckdb/parser/parsed_data/alter_scalar_function_info.hpp" namespace duckdb { diff --git a/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp index f31a589ee..6922aab5f 100644 --- a/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp +++ b/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp @@ -4,16 +4,18 @@ #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" #include "duckdb/common/algorithm.hpp" #include "duckdb/common/exception.hpp" +#include "duckdb/common/extra_type_info.hpp" #include "duckdb/main/database.hpp" #include "duckdb/parser/constraints/list.hpp" +#include "duckdb/parser/expression/cast_expression.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" -#include "duckdb/storage/table_storage_info.hpp" -#include "duckdb/planner/operator/logical_update.hpp" -#include "duckdb/planner/operator/logical_get.hpp" +#include "duckdb/planner/binder.hpp" #include "duckdb/planner/constraints/bound_check_constraint.hpp" +#include "duckdb/planner/expression/bound_columnref_expression.hpp" +#include "duckdb/planner/operator/logical_get.hpp" #include "duckdb/planner/operator/logical_projection.hpp" -#include "duckdb/common/extra_type_info.hpp" -#include "duckdb/parser/expression/cast_expression.hpp" +#include "duckdb/planner/operator/logical_update.hpp" +#include "duckdb/storage/table_storage_info.hpp" #include @@ -157,10 +159,19 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vectortype == ExtraTypeInfoType::STRING_TYPE_INFO) { - auto &string_info = extra_type_info->Cast(); - if (!string_info.collation.empty()) { - ss << " COLLATE " + string_info.collation; + if (extra_type_info) { + if (extra_type_info->type == ExtraTypeInfoType::STRING_TYPE_INFO) { + auto &string_info = extra_type_info->Cast(); + if (!string_info.collation.empty()) { + ss << " COLLATE " + string_info.collation; + } + } + if (extra_type_info->type == ExtraTypeInfoType::UNBOUND_TYPE_INFO) { + // TODO + // auto &colllation = UnboundType::GetCollation(column_type); + // if (!colllation.empty()) { + // ss << " COLLATE " + colllation; + //} } } bool not_null = not_null_columns.find(column.Logical()) != not_null_columns.end(); @@ -174,7 +185,6 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector(); - D_ASSERT(cast_expr.cast_type.id() == column_type.id()); generated_expression = *cast_expr.child; } ss << " GENERATED ALWAYS AS(" << generated_expression.get().ToString() << ")"; diff --git a/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp b/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp index f06ef164e..6ad264ca7 100644 --- a/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp +++ b/src/duckdb/src/catalog/catalog_entry/table_function_catalog_entry.cpp @@ -1,6 +1,8 @@ #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp" -#include "duckdb/parser/parsed_data/alter_table_function_info.hpp" + +#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" #include "duckdb/main/attached_database.hpp" +#include "duckdb/parser/parsed_data/alter_table_function_info.hpp" namespace duckdb { diff --git a/src/duckdb/src/catalog/catalog_set.cpp b/src/duckdb/src/catalog/catalog_set.cpp index 6e5b17610..5af535016 100644 --- a/src/duckdb/src/catalog/catalog_set.cpp +++ b/src/duckdb/src/catalog/catalog_set.cpp @@ -568,12 +568,17 @@ optional_ptr CatalogSet::CreateDefaultEntry(CatalogTransaction tra // no defaults either: return null return nullptr; } - read_lock.unlock(); + auto unlock = !defaults->LockDuringCreate(); + if (unlock) { + read_lock.unlock(); + } // this catalog set has a default map defined // check if there is a default entry that we can create with this name auto entry = defaults->CreateDefaultEntry(transaction, name); - read_lock.lock(); + if (unlock) { + read_lock.lock(); + } if (!entry) { // no default entry return nullptr; @@ -586,7 +591,9 @@ optional_ptr CatalogSet::CreateDefaultEntry(CatalogTransaction tra // we found a default entry, but failed // this means somebody else created the entry first // just retry? - read_lock.unlock(); + if (unlock) { + read_lock.unlock(); + } return GetEntry(transaction, name); } @@ -657,6 +664,7 @@ void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_loc if (!defaults || defaults->created_all_entries) { return; } + auto unlock = !defaults->LockDuringCreate(); // this catalog set has a default set defined: auto default_entries = defaults->GetDefaultEntries(); for (auto &default_entry : default_entries) { @@ -664,13 +672,17 @@ void CatalogSet::CreateDefaultEntries(CatalogTransaction transaction, unique_loc if (!entry_value) { // we unlock during the CreateEntry, since it might reference other catalog sets... // specifically for views this can happen since the view will be bound - read_lock.unlock(); + if (unlock) { + read_lock.unlock(); + } auto entry = defaults->CreateDefaultEntry(transaction, default_entry); if (!entry) { throw InternalException("Failed to create default entry for %s", default_entry); } - read_lock.lock(); + if (unlock) { + read_lock.lock(); + } CreateCommittedEntry(std::move(entry)); } } diff --git a/src/duckdb/src/catalog/default/default_functions.cpp b/src/duckdb/src/catalog/default/default_functions.cpp index 37d5e0286..ec40b5bbc 100644 --- a/src/duckdb/src/catalog/default/default_functions.cpp +++ b/src/duckdb/src/catalog/default/default_functions.cpp @@ -62,7 +62,7 @@ static const DefaultMacro internal_macros[] = { {"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, {{nullptr, nullptr}}, "pg_node_tree"}, {"pg_catalog", "format_pg_type", {"logical_type", "type_name", nullptr}, {{nullptr, nullptr}}, "case upper(logical_type) when 'FLOAT' then 'float4' when 'DOUBLE' then 'float8' when 'DECIMAL' then 'numeric' when 'ENUM' then lower(type_name) when 'VARCHAR' then 'varchar' when 'BLOB' then 'bytea' when 'TIMESTAMP' then 'timestamp' when 'TIME' then 'time' when 'TIMESTAMP WITH TIME ZONE' then 'timestamptz' when 'TIME WITH TIME ZONE' then 'timetz' when 'SMALLINT' then 'int2' when 'INTEGER' then 'int4' when 'BIGINT' then 'int8' when 'BOOLEAN' then 'bool' else lower(logical_type) end"}, {"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, {{nullptr, nullptr}}, "(select format_pg_type(logical_type, type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"}, - {"pg_catalog", "map_to_pg_oid", {"type_name", nullptr}, {{nullptr, nullptr}}, "case type_name when 'bool' then 16 when 'int16' then 21 when 'int' then 23 when 'bigint' then 20 when 'date' then 1082 when 'time' then 1083 when 'datetime' then 1114 when 'dec' then 1700 when 'float' then 700 when 'double' then 701 when 'bpchar' then 1043 when 'binary' then 17 when 'interval' then 1186 when 'timestamptz' then 1184 when 'timetz' then 1266 when 'bit' then 1560 when 'guid' then 2950 else null end"}, // map duckdb_oid to pg_oid. If no corresponding type, return null + {"pg_catalog", "map_to_pg_oid", {"type_name", nullptr}, {{nullptr, nullptr}}, "case type_name when 'bool' then 16 when 'int16' then 21 when 'int' then 23 when 'bigint' then 20 when 'date' then 1082 when 'time' then 1083 when 'datetime' then 1114 when 'dec' then 1700 when 'float' then 700 when 'double' then 701 when 'bpchar' then 1043 when 'binary' then 17 when 'interval' then 1186 when 'timestamptz' then 1184 when 'timestamp with time zone' then 1184 when 'timetz' then 1266 when 'time with time zone' then 1266 when 'bit' then 1560 when 'guid' then 2950 else null end"}, // map duckdb_oid to pg_oid. If no corresponding type, return null {"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, {{nullptr, nullptr}}, "true"}, //boolean //does user have privilege for role {"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, {{nullptr, nullptr}}, "true"}, //boolean //does current user have privilege for role diff --git a/src/duckdb/src/catalog/default/default_types.cpp b/src/duckdb/src/catalog/default/default_types.cpp index 23edac049..2e3c5c6da 100644 --- a/src/duckdb/src/catalog/default/default_types.cpp +++ b/src/duckdb/src/catalog/default/default_types.cpp @@ -4,10 +4,537 @@ #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp" #include "duckdb/common/string_util.hpp" #include "duckdb/parser/parsed_data/create_type_info.hpp" -#include "duckdb/catalog/default/builtin_types/types.hpp" +#include "duckdb/common/types/decimal.hpp" +#include "duckdb/common/exception/binder_exception.hpp" +#include "duckdb/common/array.hpp" +#include "duckdb/planner/expression_binder.hpp" namespace duckdb { +namespace { + +//---------------------------------------------------------------------------------------------------------------------- +// DECIMAL Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindDecimalType(BindLogicalTypeInput &input) { + auto &modifiers = input.modifiers; + + uint8_t width = 18; + uint8_t scale = 3; + + if (!modifiers.empty()) { + auto width_value = modifiers[0].GetValue(); + if (width_value.IsNull()) { + throw BinderException("DECIMAL type width cannot be NULL"); + } + if (width_value.DefaultTryCastAs(LogicalTypeId::UTINYINT)) { + width = width_value.GetValueUnsafe(); + scale = 0; // reset scale to 0 if only width is provided + } else { + throw BinderException("DECIMAL type width must be between 1 and %d", Decimal::MAX_WIDTH_DECIMAL); + } + } + + if (modifiers.size() > 1) { + auto scale_value = modifiers[1].GetValue(); + if (scale_value.IsNull()) { + throw BinderException("DECIMAL type scale cannot be NULL"); + } + if (scale_value.DefaultTryCastAs(LogicalTypeId::UTINYINT)) { + scale = scale_value.GetValueUnsafe(); + } else { + throw BinderException("DECIMAL type scale must be between 0 and %d", Decimal::MAX_WIDTH_DECIMAL - 1); + } + } + + if (modifiers.size() > 2) { + throw BinderException("DECIMAL type can take at most two type modifiers, width and scale"); + } + + if (width < 1 || width > Decimal::MAX_WIDTH_DECIMAL) { + throw BinderException("DECIMAL type width must be between 1 and %d", Decimal::MAX_WIDTH_DECIMAL); + } + + if (scale > width) { + throw BinderException("DECIMAL type scale cannot be greater than width"); + } + return LogicalType::DECIMAL(width, scale); +} + +//---------------------------------------------------------------------------------------------------------------------- +// TIMESTAMP Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindTimestampType(BindLogicalTypeInput &input) { + auto &modifiers = input.modifiers; + + if (modifiers.empty()) { + return LogicalType::TIMESTAMP; + } + + if (modifiers.size() > 1) { + throw BinderException("TIMESTAMP type takes at most one type modifier"); + } + + auto precision_value = modifiers[0].GetValue(); + if (precision_value.IsNull()) { + throw BinderException("TIMESTAMP type precision cannot be NULL"); + } + uint8_t precision; + if (precision_value.DefaultTryCastAs(LogicalTypeId::UTINYINT)) { + precision = precision_value.GetValueUnsafe(); + } else { + throw BinderException("TIMESTAMP type precision must be between 0 and 9"); + } + + if (precision > 9) { + throw BinderException("TIMESTAMP only supports until nano-second precision (9)"); + } + if (precision == 0) { + return LogicalType::TIMESTAMP_S; + } + if (precision <= 3) { + return LogicalType::TIMESTAMP_MS; + } + if (precision <= 6) { + return LogicalType::TIMESTAMP; + } + return LogicalType::TIMESTAMP_NS; +} + +//---------------------------------------------------------------------------------------------------------------------- +// VARCHAR Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindVarcharType(BindLogicalTypeInput &input) { + // Varchar type can have a single modifier indicating the length, but we ignore it for now + auto &modifiers = input.modifiers; + + if (!modifiers.empty() && modifiers.size() <= 2) { + for (auto &mod : modifiers) { + if (mod.IsNamed("collation") && mod.GetType() == LogicalType::VARCHAR && mod.IsNotNull()) { + // Ignore all other modifiers and return collation type + auto collation = StringValue::Get(mod.GetValue()); + + if (!input.context) { + throw BinderException("Cannot bind varchar with collation without a connection"); + } + + // Ensure this is a valid collation + ExpressionBinder::TestCollation(*input.context, collation); + + return LogicalType::VARCHAR_COLLATION(collation); + } + } + } + + if (modifiers.size() > 1) { + throw BinderException("VARCHAR type takes at most one type modifier"); + } + + return LogicalType::VARCHAR; +} + +//---------------------------------------------------------------------------------------------------------------------- +// BIT Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindBitType(BindLogicalTypeInput &input) { + // BIT type can have a single modifier indicating the length, but we ignore it for now + auto &args = input.modifiers; + if (args.size() > 1) { + throw BinderException("BIT type takes at most one type modifier"); + } + return LogicalType::BIT; +} + +//---------------------------------------------------------------------------------------------------------------------- +// INTERVAL Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindIntervalType(BindLogicalTypeInput &input) { + // Interval type can have a single modifier indicating the leading field, but we ignore it for now + auto &modifiers = input.modifiers; + if (modifiers.size() > 1) { + throw BinderException("INTERVAL type takes at most one type modifier"); + } + return LogicalType::INTERVAL; +} + +//---------------------------------------------------------------------------------------------------------------------- +// ENUM Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindEnumType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + + if (arguments.empty()) { + throw BinderException("ENUM type requires at least one argument"); + } + + Vector enum_vector(LogicalType::VARCHAR, NumericCast(arguments.size())); + auto string_data = FlatVector::GetData(enum_vector); + + for (idx_t arg_idx = 0; arg_idx < arguments.size(); arg_idx++) { + auto &arg = arguments[arg_idx]; + if (arg.HasName()) { + throw BinderException("ENUM type arguments cannot have names (argument %d has name \"%s\")", arg_idx + 1, + arg.GetName()); + } + + if (arg.GetValue().type() != LogicalTypeId::VARCHAR) { + throw BinderException("ENUM type requires a set of VARCHAR arguments"); + } + + if (arg.GetValue().IsNull()) { + throw BinderException("ENUM type arguments cannot be NULL (argument %d is NULL)", arg_idx + 1); + } + + string_data[arg_idx] = StringVector::AddString(enum_vector, StringValue::Get(arg.GetValue())); + } + + return LogicalType::ENUM(enum_vector, NumericCast(arguments.size())); +} + +//---------------------------------------------------------------------------------------------------------------------- +// LIST Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindListType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + if (arguments.size() != 1) { + throw BinderException("LIST type requires exactly one type modifier"); + } + auto &child_val = arguments[0].GetValue(); + if (child_val.IsNull()) { + throw BinderException("LIST type modifier cannot be NULL"); + } + if (child_val.type() != LogicalTypeId::TYPE) { + throw BinderException("LIST type modifier must be a type, but got %s", child_val.ToString()); + } + + auto child_type = TypeValue::GetType(arguments[0].GetValue()); + return LogicalType::LIST(child_type); +} + +//---------------------------------------------------------------------------------------------------------------------- +// ARRAY Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindArrayType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + if (arguments.size() != 2) { + throw BinderException("ARRAY type requires exactly two type modifiers"); + } + auto &elem_val = arguments[0].GetValue(); + if (elem_val.IsNull()) { + throw BinderException("ARRAY type modifier cannot be NULL"); + } + if (elem_val.type() != LogicalTypeId::TYPE) { + throw BinderException("ARRAY type modifier must be a type, but got %s", elem_val.ToString()); + } + + auto size_val = arguments[1].GetValue(); + if (size_val.IsNull()) { + throw BinderException("ARRAY type size modifier cannot be NULL"); + } + if (!size_val.type().IsIntegral()) { + throw BinderException("ARRAY type size modifier must be an integral type"); + } + if (!size_val.DefaultTryCastAs(LogicalTypeId::BIGINT)) { + throw BinderException("ARRAY type size modifier must be a BIGINT"); + } + + auto array_size = size_val.GetValueUnsafe(); + + if (array_size < 1) { + throw BinderException("ARRAY type size must be at least 1"); + } + if (array_size > static_cast(ArrayType::MAX_ARRAY_SIZE)) { + throw BinderException("ARRAY type size must be at most %d", ArrayType::MAX_ARRAY_SIZE); + } + + auto child_type = TypeValue::GetType(arguments[0].GetValue()); + return LogicalType::ARRAY(child_type, UnsafeNumericCast(array_size)); +} + +//---------------------------------------------------------------------------------------------------------------------- +// STRUCT Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindStructType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + + if (arguments.empty()) { + throw BinderException("STRUCT type requires at least one child type"); + } + + auto all_name = true; + auto all_anon = true; + for (auto &arg : arguments) { + if (arg.HasName()) { + all_anon = false; + } else { + all_name = false; + } + + // Also check if all arguments are types + if (arg.GetValue().type() != LogicalTypeId::TYPE) { + throw BinderException("STRUCT type arguments must be types"); + } + + // And not null! + if (arg.GetValue().IsNull()) { + throw BinderException("STRUCT type arguments cannot be NULL"); + } + } + + if (!all_name && !all_anon) { + throw BinderException("STRUCT type arguments must either all have names or all be anonymous"); + } + + if (all_anon) { + // Unnamed struct case + child_list_t children; + for (auto &arg : arguments) { + children.emplace_back("", TypeValue::GetType(arg.GetValue())); + } + return LogicalType::STRUCT(std::move(children)); + } + + // Named struct case + D_ASSERT(all_name); + child_list_t children; + case_insensitive_set_t name_collision_set; + + for (auto &arg : arguments) { + auto &child_name = arg.GetName(); + if (name_collision_set.find(child_name) != name_collision_set.end()) { + throw BinderException("Duplicate STRUCT type argument name \"%s\"", child_name); + } + name_collision_set.insert(child_name); + children.emplace_back(child_name, TypeValue::GetType(arg.GetValue())); + } + + return LogicalType::STRUCT(std::move(children)); +} + +//---------------------------------------------------------------------------------------------------------------------- +// MAP Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindMapType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + + if (arguments.size() != 2) { + throw BinderException("MAP type requires exactly two type modifiers: key type and value type"); + } + + auto &key_val = arguments[0].GetValue(); + auto &val_val = arguments[1].GetValue(); + + if (key_val.type() != LogicalTypeId::TYPE || val_val.type() != LogicalTypeId::TYPE) { + throw BinderException("MAP type modifiers must be types"); + } + if (key_val.IsNull()) { + throw BinderException("MAP type key type modifier cannot be NULL"); + } + if (val_val.IsNull()) { + throw BinderException("MAP type value type modifier cannot be NULL"); + } + + auto key_type = TypeValue::GetType(arguments[0].GetValue()); + auto val_type = TypeValue::GetType(arguments[1].GetValue()); + + return LogicalType::MAP(std::move(key_type), std::move(val_type)); +} + +//---------------------------------------------------------------------------------------------------------------------- +// UNION Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindUnionType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + + if (arguments.empty()) { + throw BinderException("UNION type requires at least one type modifier"); + } + + if (arguments.size() > UnionType::MAX_UNION_MEMBERS) { + throw BinderException("UNION type supports at most %d type modifiers", UnionType::MAX_UNION_MEMBERS); + } + + child_list_t children; + case_insensitive_set_t name_collision_set; + + for (auto &arg : arguments) { + if (!arg.HasName()) { + throw BinderException("UNION type modifiers must have names"); + } + if (arg.GetValue().type() != LogicalTypeId::TYPE) { + throw BinderException("UNION type modifiers must be types"); + } + if (arg.GetValue().IsNull()) { + throw BinderException("UNION type modifiers cannot be NULL"); + } + + auto &entry_name = arg.GetName(); + auto entry_type = TypeValue::GetType(arg.GetValue()); + + if (name_collision_set.find(entry_name) != name_collision_set.end()) { + throw BinderException("Duplicate UNION type member name \"%s\"", entry_name); + } + + name_collision_set.insert(entry_name); + children.emplace_back(entry_name, entry_type); + } + + return LogicalType::UNION(std::move(children)); +} + +//---------------------------------------------------------------------------------------------------------------------- +// VARIANT Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindVariantType(BindLogicalTypeInput &input) { + // We need this function to make sure we always create a VARIANT type with ExtraTypeInfo + auto &arguments = input.modifiers; + + if (!arguments.empty()) { + throw BinderException("Type 'VARIANT' does not take any type parameters"); + } + return LogicalType::VARIANT(); +} + +//---------------------------------------------------------------------------------------------------------------------- +// GEOMETRY Type +//---------------------------------------------------------------------------------------------------------------------- +LogicalType BindGeometryType(BindLogicalTypeInput &input) { + auto &arguments = input.modifiers; + + if (arguments.empty()) { + return LogicalType::GEOMETRY(); + } + + if (arguments.size() > 1) { + throw BinderException( + "GEOMETRY type takes a single optional type modifier with a coordinate system definition"); + } + + const auto &crs_value = arguments[0].GetValue(); + + // Don't do any casting here - only accept string type directly + if (crs_value.type() != LogicalTypeId::VARCHAR) { + throw BinderException("GEOMETRY type modifier must be a string with a coordinate system definition"); + } + if (crs_value.IsNull()) { + throw BinderException("GEOMETRY type modifier cannot be NULL"); + } + + // FIXME: Use extension/ClientContext to expand incomplete/shorthand CRS definitions + auto &crs = StringValue::Get(crs_value); + + return LogicalType::GEOMETRY(crs); +} + +//---------------------------------------------------------------------------------------------------------------------- +// All Types +//---------------------------------------------------------------------------------------------------------------------- + +struct DefaultType { + const char *name; + LogicalTypeId type; + bind_logical_type_function_t bind_function; +}; + +using builtin_type_array = std::array; + +const builtin_type_array BUILTIN_TYPES = {{{"decimal", LogicalTypeId::DECIMAL, BindDecimalType}, + {"dec", LogicalTypeId::DECIMAL, BindDecimalType}, + {"numeric", LogicalTypeId::DECIMAL, BindDecimalType}, + {"time", LogicalTypeId::TIME, nullptr}, + {"time_ns", LogicalTypeId::TIME_NS, nullptr}, + {"date", LogicalTypeId::DATE, nullptr}, + {"timestamp", LogicalTypeId::TIMESTAMP, BindTimestampType}, + {"datetime", LogicalTypeId::TIMESTAMP, BindTimestampType}, + {"timestamp_us", LogicalTypeId::TIMESTAMP, nullptr}, + {"timestamp_ms", LogicalTypeId::TIMESTAMP_MS, nullptr}, + {"timestamp_ns", LogicalTypeId::TIMESTAMP_NS, nullptr}, + {"timestamp_s", LogicalTypeId::TIMESTAMP_SEC, nullptr}, + {"timestamptz", LogicalTypeId::TIMESTAMP_TZ, nullptr}, + {"timestamp with time zone", LogicalTypeId::TIMESTAMP_TZ, nullptr}, + {"timetz", LogicalTypeId::TIME_TZ, nullptr}, + {"time with time zone", LogicalTypeId::TIME_TZ, nullptr}, + {"interval", LogicalTypeId::INTERVAL, BindIntervalType}, + {"varchar", LogicalTypeId::VARCHAR, BindVarcharType}, + {"bpchar", LogicalTypeId::VARCHAR, BindVarcharType}, + {"string", LogicalTypeId::VARCHAR, BindVarcharType}, + {"char", LogicalTypeId::VARCHAR, BindVarcharType}, + {"nvarchar", LogicalTypeId::VARCHAR, BindVarcharType}, + {"text", LogicalTypeId::VARCHAR, BindVarcharType}, + {"blob", LogicalTypeId::BLOB, nullptr}, + {"bytea", LogicalTypeId::BLOB, nullptr}, + {"varbinary", LogicalTypeId::BLOB, nullptr}, + {"binary", LogicalTypeId::BLOB, nullptr}, + {"hugeint", LogicalTypeId::HUGEINT, nullptr}, + {"int128", LogicalTypeId::HUGEINT, nullptr}, + {"uhugeint", LogicalTypeId::UHUGEINT, nullptr}, + {"uint128", LogicalTypeId::UHUGEINT, nullptr}, + {"bigint", LogicalTypeId::BIGINT, nullptr}, + {"oid", LogicalTypeId::BIGINT, nullptr}, + {"long", LogicalTypeId::BIGINT, nullptr}, + {"int8", LogicalTypeId::BIGINT, nullptr}, + {"int64", LogicalTypeId::BIGINT, nullptr}, + {"ubigint", LogicalTypeId::UBIGINT, nullptr}, + {"uint64", LogicalTypeId::UBIGINT, nullptr}, + {"integer", LogicalTypeId::INTEGER, nullptr}, + {"int", LogicalTypeId::INTEGER, nullptr}, + {"int4", LogicalTypeId::INTEGER, nullptr}, + {"signed", LogicalTypeId::INTEGER, nullptr}, + {"integral", LogicalTypeId::INTEGER, nullptr}, + {"int32", LogicalTypeId::INTEGER, nullptr}, + {"uinteger", LogicalTypeId::UINTEGER, nullptr}, + {"uint32", LogicalTypeId::UINTEGER, nullptr}, + {"smallint", LogicalTypeId::SMALLINT, nullptr}, + {"int2", LogicalTypeId::SMALLINT, nullptr}, + {"short", LogicalTypeId::SMALLINT, nullptr}, + {"int16", LogicalTypeId::SMALLINT, nullptr}, + {"usmallint", LogicalTypeId::USMALLINT, nullptr}, + {"uint16", LogicalTypeId::USMALLINT, nullptr}, + {"tinyint", LogicalTypeId::TINYINT, nullptr}, + {"int1", LogicalTypeId::TINYINT, nullptr}, + {"utinyint", LogicalTypeId::UTINYINT, nullptr}, + {"uint8", LogicalTypeId::UTINYINT, nullptr}, + {"struct", LogicalTypeId::STRUCT, BindStructType}, + {"row", LogicalTypeId::STRUCT, BindStructType}, + {"list", LogicalTypeId::LIST, BindListType}, + {"array", LogicalTypeId::ARRAY, BindArrayType}, + {"map", LogicalTypeId::MAP, BindMapType}, + {"union", LogicalTypeId::UNION, BindUnionType}, + {"bit", LogicalTypeId::BIT, BindBitType}, + {"bitstring", LogicalTypeId::BIT, BindBitType}, + {"variant", LogicalTypeId::VARIANT, BindVariantType}, + {"bignum", LogicalTypeId::BIGNUM, nullptr}, + {"varint", LogicalTypeId::BIGNUM, nullptr}, + {"boolean", LogicalTypeId::BOOLEAN, nullptr}, + {"bool", LogicalTypeId::BOOLEAN, nullptr}, + {"logical", LogicalTypeId::BOOLEAN, nullptr}, + {"uuid", LogicalTypeId::UUID, nullptr}, + {"guid", LogicalTypeId::UUID, nullptr}, + {"enum", LogicalTypeId::ENUM, BindEnumType}, + {"null", LogicalTypeId::SQLNULL, nullptr}, + {"float", LogicalTypeId::FLOAT, nullptr}, + {"real", LogicalTypeId::FLOAT, nullptr}, + {"float4", LogicalTypeId::FLOAT, nullptr}, + {"double", LogicalTypeId::DOUBLE, nullptr}, + {"float8", LogicalTypeId::DOUBLE, nullptr}, + {"geometry", LogicalTypeId::GEOMETRY, BindGeometryType}, + {"type", LogicalTypeId::TYPE, nullptr}}}; + +optional_ptr TryGetDefaultTypeEntry(const string &name) { + auto &internal_types = BUILTIN_TYPES; + for (auto &type : internal_types) { + if (StringUtil::CIEquals(name, type.name)) { + return &type; + } + } + return nullptr; +} + +} // namespace + +//---------------------------------------------------------------------------------------------------------------------- +// Default Type Generator +//---------------------------------------------------------------------------------------------------------------------- LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) { auto &internal_types = BUILTIN_TYPES; for (auto &type : internal_types) { @@ -18,6 +545,29 @@ LogicalTypeId DefaultTypeGenerator::GetDefaultType(const string &name) { return LogicalType::INVALID; } +LogicalType DefaultTypeGenerator::TryDefaultBind(const string &name, const vector> ¶ms) { + auto entry = TryGetDefaultTypeEntry(name); + if (!entry) { + return LogicalTypeId::INVALID; + } + + if (!entry->bind_function) { + if (params.empty()) { + return LogicalType(entry->type); + } else { + throw InvalidInputException("Type '%s' does not take any type parameters", name); + } + } + + vector args; + for (auto ¶m : params) { + args.emplace_back(param.first, param.second); + } + + BindLogicalTypeInput input {nullptr, LogicalType(entry->type), args}; + return entry->bind_function(input); +} + DefaultTypeGenerator::DefaultTypeGenerator(Catalog &catalog, SchemaCatalogEntry &schema) : DefaultGenerator(catalog), schema(schema) { } @@ -26,15 +576,16 @@ unique_ptr DefaultTypeGenerator::CreateDefaultEntry(ClientContext if (schema.name != DEFAULT_SCHEMA) { return nullptr; } - auto type_id = GetDefaultType(entry_name); - if (type_id == LogicalTypeId::INVALID) { + auto entry = TryGetDefaultTypeEntry(entry_name); + if (!entry || entry->type == LogicalTypeId::INVALID) { return nullptr; } CreateTypeInfo info; info.name = entry_name; - info.type = LogicalType(type_id); + info.type = LogicalType(entry->type); info.internal = true; info.temporary = true; + info.bind_function = entry->bind_function; return make_uniq_base(catalog, schema, info); } diff --git a/src/duckdb/src/catalog/default/default_views.cpp b/src/duckdb/src/catalog/default/default_views.cpp index 023b6f800..f2edfdaba 100644 --- a/src/duckdb/src/catalog/default/default_views.cpp +++ b/src/duckdb/src/catalog/default/default_views.cpp @@ -53,7 +53,7 @@ static const DefaultView internal_views[] = { {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL::VARCHAR self_referencing_column_name, NULL::VARCHAR reference_generation, NULL::VARCHAR user_defined_type_catalog, NULL::VARCHAR user_defined_type_schema, NULL::VARCHAR user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"}, {"information_schema", "character_sets", "SELECT NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"}, {"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, f.constraint_name constraint_name, c.database_name unique_constraint_catalog, c.schema_name unique_constraint_schema, c.constraint_name unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c, duckdb_constraints() f WHERE f.constraint_type = 'FOREIGN KEY' AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY') AND f.database_oid = c.database_oid AND f.schema_oid = c.schema_oid AND lower(f.referenced_table) = lower(c.table_name) AND [lower(x) for x in f.referenced_column_names] = [lower(x) for x in c.constraint_column_names]"}, - {"information_schema", "key_column_usage", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, UNNEST(constraint_column_names) column_name, UNNEST(generate_series(1, len(constraint_column_names))) ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN 1 ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"}, + {"information_schema", "key_column_usage", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, UNNEST(constraint_column_names) column_name, UNNEST(generate_series(1, len(constraint_column_names))) ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN UNNEST (generate_series(1, len(constraint_column_names))) ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"}, {"information_schema", "table_constraints", "SELECT database_name constraint_catalog, schema_name constraint_schema, constraint_name, database_name table_catalog, schema_name table_schema, table_name, CASE constraint_type WHEN 'NOT NULL' THEN 'CHECK' ELSE constraint_type END constraint_type, 'NO' is_deferrable, 'NO' initially_deferred, 'YES' enforced, 'YES' nulls_distinct FROM duckdb_constraints() WHERE constraint_type = 'PRIMARY KEY' OR constraint_type = 'FOREIGN KEY' OR constraint_type = 'UNIQUE' OR constraint_type = 'CHECK' OR constraint_type = 'NOT NULL';"}, {"information_schema", "constraint_column_usage", "SELECT database_name AS table_catalog, schema_name AS table_schema, table_name, column_name, database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, constraint_type, constraint_text FROM (SELECT dc.*, UNNEST(dc.constraint_column_names) AS column_name FROM duckdb_constraints() AS dc WHERE constraint_type NOT IN ('NOT NULL') );"}, {"information_schema", "constraint_table_usage", "SELECT database_name AS table_catalog, schema_name AS table_schema, table_name, database_name AS constraint_catalog, schema_name AS constraint_schema, constraint_name, constraint_type FROM duckdb_constraints() WHERE constraint_type NOT IN ('NOT NULL');"}, diff --git a/src/duckdb/src/common/box_renderer.cpp b/src/duckdb/src/common/box_renderer.cpp index b76721596..81caa2ee0 100644 --- a/src/duckdb/src/common/box_renderer.cpp +++ b/src/duckdb/src/common/box_renderer.cpp @@ -205,7 +205,7 @@ struct BoxRendererImplementation : public BoxRendererState { void RenderValue(BaseResultRenderer &ss, const string &value, idx_t column_width, ResultRenderType render_mode, const vector &annotations, ValueRenderAlignment alignment = ValueRenderAlignment::MIDDLE, - optional_idx render_width = optional_idx()); + optional_idx render_width = optional_idx(), const char *vertical = nullptr); string RenderType(const LogicalType &type); ValueRenderAlignment TypeAlignment(const LogicalType &type); void ConvertRenderVector(Vector &vector, Vector &render_lengths, idx_t count, const LogicalType &original_type, @@ -263,9 +263,10 @@ void BoxRendererImplementation::ComputeRowFooter(idx_t row_count, idx_t rendered footer.row_count_str = "? rows"; } if (config.large_number_rendering == LargeNumberRendering::FOOTER && !has_limited_rows) { - footer.readable_rows_str = TryFormatLargeNumber(to_string(row_count)); - if (!footer.readable_rows_str.empty()) { - footer.readable_rows_str += " rows"; + string readable_str = TryFormatLargeNumber(to_string(row_count)); + if (!readable_str.empty()) { + footer.readable_rows_str = to_string(row_count) + " total"; + footer.row_count_str = readable_str + " rows"; } } footer.has_hidden_rows = rendered_rows < row_count; @@ -412,7 +413,8 @@ string BoxRendererImplementation::TruncateValue(const string &value, idx_t colum void BoxRendererImplementation::RenderValue(BaseResultRenderer &ss, const string &value, idx_t column_width, ResultRenderType render_mode, const vector &annotations, - ValueRenderAlignment alignment, optional_idx render_width_input) { + ValueRenderAlignment alignment, optional_idx render_width_input, + const char *vertical) { idx_t render_width; if (render_width_input.IsValid()) { render_width = render_width_input.GetIndex(); @@ -457,7 +459,7 @@ void BoxRendererImplementation::RenderValue(BaseResultRenderer &ss, const string default: throw InternalException("Unrecognized value renderer alignment"); } - ss << config.VERTICAL; + ss << (vertical ? vertical : config.VERTICAL); ss << string(lpadding, ' '); if (!annotations.empty()) { // if we have annotations split up the rendering between annotations @@ -2127,7 +2129,7 @@ void BoxRendererImplementation::RenderValues(BaseResultRenderer &ss, vector= shown_size) { // we have space - render it here extra_render_str = " ("; + extra_render_str += shown_str; if (!readable_rows_str.empty()) { - extra_render_str += readable_rows_str + ", "; + extra_render_str += ", " + readable_rows_str; } - extra_render_str += shown_str; extra_render_str += ")"; D_ASSERT(extra_render_str.size() == shown_size); padding -= shown_size; @@ -2208,12 +2209,11 @@ void BoxRendererImplementation::RenderFooter(BaseResultRenderer &ss, idx_t row_c shown_str = string(); } - ss << config.VERTICAL; - ss << " "; + ss << " "; if (render_rows_and_columns) { ss.Render(ResultRenderType::FOOTER, row_count_str); if (!extra_render_str.empty()) { - ss.Render(ResultRenderType::NULL_VALUE, extra_render_str); + ss.Render(ResultRenderType::FOOTER, extra_render_str); } ss << string(padding, ' '); ss.Render(ResultRenderType::FOOTER, column_count_str); @@ -2223,12 +2223,10 @@ void BoxRendererImplementation::RenderFooter(BaseResultRenderer &ss, idx_t row_c ss << string(lpadding, ' '); ss.Render(ResultRenderType::FOOTER, row_count_str); if (!extra_render_str.empty()) { - ss.Render(ResultRenderType::NULL_VALUE, extra_render_str); + ss.Render(ResultRenderType::FOOTER, extra_render_str); } ss << string(rpadding, ' '); } - ss << " "; - ss << config.VERTICAL; ss << '\n'; if (!readable_rows_str.empty() || !shown_str.empty()) { // we still need to render the readable rows/shown strings @@ -2236,13 +2234,10 @@ void BoxRendererImplementation::RenderFooter(BaseResultRenderer &ss, idx_t row_c idx_t combined_shown_length = readable_rows_str.size() + shown_str.size() + 4; if (!readable_rows_str.empty() && !shown_str.empty() && combined_shown_length <= total_render_length) { // we can! merge them - ss << config.VERTICAL; - ss << " "; - ss.Render(ResultRenderType::NULL_VALUE, readable_rows_str); + ss << " "; + ss.Render(ResultRenderType::FOOTER, shown_str); ss << string(total_render_length - combined_shown_length, ' '); - ss.Render(ResultRenderType::NULL_VALUE, shown_str); - ss << " "; - ss << config.VERTICAL; + ss.Render(ResultRenderType::FOOTER, readable_rows_str); ss << '\n'; readable_rows_str = string(); shown_str = string(); @@ -2250,21 +2245,17 @@ void BoxRendererImplementation::RenderFooter(BaseResultRenderer &ss, idx_t row_c ValueRenderAlignment alignment = render_rows_and_columns ? ValueRenderAlignment::LEFT : ValueRenderAlignment::MIDDLE; vector annotations; - if (!readable_rows_str.empty()) { - RenderValue(ss, "(" + readable_rows_str + ")", total_render_length - 4, ResultRenderType::NULL_VALUE, - annotations, alignment); - ss << config.VERTICAL; + if (!shown_str.empty()) { + RenderValue(ss, "(" + shown_str + ")", total_render_length - 4, ResultRenderType::FOOTER, annotations, + alignment, optional_idx(), " "); ss << '\n'; } - if (!shown_str.empty()) { - RenderValue(ss, "(" + shown_str + ")", total_render_length - 4, ResultRenderType::NULL_VALUE, annotations, - alignment); - ss << config.VERTICAL; + if (!readable_rows_str.empty()) { + RenderValue(ss, "(" + readable_rows_str + ")", total_render_length - 4, ResultRenderType::FOOTER, + annotations, alignment, optional_idx(), " "); ss << '\n'; } } - // render the bottom line - RenderLayoutLine(ss, config.HORIZONTAL, config.HORIZONTAL, config.LDCORNER, config.RDCORNER); } //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/common/encryption_functions.cpp b/src/duckdb/src/common/encryption_functions.cpp index 262ff3c14..5cd1e4967 100644 --- a/src/duckdb/src/common/encryption_functions.cpp +++ b/src/duckdb/src/common/encryption_functions.cpp @@ -50,6 +50,9 @@ void AdditionalAuthenticatedData::WriteStringData(const std::string &val) const EncryptionEngine::EncryptionEngine() { } +EncryptionEngine::~EncryptionEngine() { +} + const_data_ptr_t EncryptionEngine::GetKeyFromCache(DatabaseInstance &db, const string &key_name) { auto &keys = EncryptionKeyManager::Get(db); return keys.GetKey(key_name); @@ -65,8 +68,8 @@ void EncryptionEngine::AddKeyToCache(DatabaseInstance &db, data_ptr_t key, const if (!keys.HasKey(key_name)) { keys.AddKey(key_name, key); } else { - // wipe out the key - std::memset(key, 0, MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(key, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); } } @@ -77,8 +80,8 @@ string EncryptionEngine::AddKeyToCache(DatabaseInstance &db, data_ptr_t key) { if (!keys.HasKey(key_id)) { keys.AddKey(key_id, key); } else { - // wipe out the original key - std::memset(key, 0, MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(key, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); } return key_id; diff --git a/src/duckdb/src/common/encryption_key_manager.cpp b/src/duckdb/src/common/encryption_key_manager.cpp index 409fe605c..4d174525b 100644 --- a/src/duckdb/src/common/encryption_key_manager.cpp +++ b/src/duckdb/src/common/encryption_key_manager.cpp @@ -75,7 +75,7 @@ string EncryptionKeyManager::GenerateRandomKeyID() { void EncryptionKeyManager::AddKey(const string &key_name, data_ptr_t key) { lock_guard guard(lock); derived_keys.emplace(key_name, EncryptionKey(key)); - // Zero-out the encryption key + // Zero-out the input encryption key duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(key, DERIVED_KEY_LENGTH); } @@ -92,6 +92,19 @@ const_data_ptr_t EncryptionKeyManager::GetKey(const string &key_name) const { void EncryptionKeyManager::DeleteKey(const string &key_name) { lock_guard guard(lock); + ClearKey(key_name); + EraseKey(key_name); +} + +void EncryptionKeyManager::ClearKey(const string &key_name) { + D_ASSERT(HasKey(key_name)); + auto const key_data = derived_keys.at(key_name).GetData(); + // clear the key (zero-out its memory) + duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(key_data, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); +} + +void EncryptionKeyManager::EraseKey(const string &key_name) { derived_keys.erase(key_name); } @@ -131,6 +144,7 @@ void EncryptionKeyManager::DeriveKey(string &user_key, data_ptr_t salt, data_ptr KeyDerivationFunctionSHA256(reinterpret_cast(decoded_key.data()), decoded_key.size(), salt, derived_key); + duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(data_ptr_cast(&user_key[0]), user_key.size()); duckdb_mbedtls::MbedTlsWrapper::AESStateMBEDTLS::SecureClearData(data_ptr_cast(&decoded_key[0]), decoded_key.size()); diff --git a/src/duckdb/src/common/encryption_state.cpp b/src/duckdb/src/common/encryption_state.cpp index 0763bc5a6..28e23f310 100644 --- a/src/duckdb/src/common/encryption_state.cpp +++ b/src/duckdb/src/common/encryption_state.cpp @@ -29,6 +29,8 @@ void EncryptionState::GenerateRandomData(data_ptr_t, idx_t) { throw NotImplementedException("EncryptionState Abstract Class is called"); } +static constexpr EncryptionTypes::EncryptionVersion MAX_VERSION = EncryptionTypes::V0_1; + string EncryptionTypes::CipherToString(CipherType cipher_p) { switch (cipher_p) { case GCM: @@ -56,6 +58,17 @@ EncryptionTypes::CipherType EncryptionTypes::StringToCipher(const string &encryp return INVALID; } +EncryptionTypes::EncryptionVersion EncryptionTypes::StringToVersion(const string &encryption_version_p) { + if (encryption_version_p == "v0") { + return V0_0; + } else if (encryption_version_p == "v1") { + return V0_1; + } else { + throw NotImplementedException("No encryption version higher then v%d is supported yet in this DuckDB version", + MAX_VERSION); + } +} + string EncryptionTypes::KDFToString(KeyDerivationFunction kdf_p) { switch (kdf_p) { case SHA256: diff --git a/src/duckdb/src/common/enum_util.cpp b/src/duckdb/src/common/enum_util.cpp index 9e04cf913..ff9a82e2c 100644 --- a/src/duckdb/src/common/enum_util.cpp +++ b/src/duckdb/src/common/enum_util.cpp @@ -16,6 +16,7 @@ #include "duckdb/common/column_index.hpp" #include "duckdb/common/enums/access_mode.hpp" #include "duckdb/common/enums/aggregate_handling.hpp" +#include "duckdb/common/enums/allow_parser_override.hpp" #include "duckdb/common/enums/arrow_format_version.hpp" #include "duckdb/common/enums/cache_validation_mode.hpp" #include "duckdb/common/enums/catalog_lookup_behavior.hpp" @@ -38,6 +39,7 @@ #include "duckdb/common/enums/index_constraint_type.hpp" #include "duckdb/common/enums/join_type.hpp" #include "duckdb/common/enums/joinref_type.hpp" +#include "duckdb/common/enums/lambda_syntax.hpp" #include "duckdb/common/enums/logical_operator_type.hpp" #include "duckdb/common/enums/memory_tag.hpp" #include "duckdb/common/enums/merge_action_type.hpp" @@ -172,7 +174,7 @@ #include "duckdb/planner/binder.hpp" #include "duckdb/planner/bound_result_modifier.hpp" #include "duckdb/planner/table_filter.hpp" -#include "duckdb/storage/buffer/block_handle.hpp" +#include "duckdb/storage/buffer/buffer_pool_reservation.hpp" #include "duckdb/storage/caching_mode.hpp" #include "duckdb/storage/compression/bitpacking.hpp" #include "duckdb/storage/magic_bytes.hpp" @@ -180,6 +182,7 @@ #include "duckdb/storage/statistics/variant_stats.hpp" #include "duckdb/storage/storage_index.hpp" #include "duckdb/storage/table/chunk_info.hpp" +#include "duckdb/storage/table/column_data.hpp" #include "duckdb/storage/table/column_segment.hpp" #include "duckdb/storage/table/table_index_list.hpp" #include "duckdb/storage/temporary_file_manager.hpp" @@ -355,6 +358,26 @@ AggregateType EnumUtil::FromString(const char *value) { return static_cast(StringUtil::StringToEnum(GetAggregateTypeValues(), 2, "AggregateType", value)); } +const StringUtil::EnumStringLiteral *GetAllowParserOverrideValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(AllowParserOverride::DEFAULT_OVERRIDE), "DEFAULT" }, + { static_cast(AllowParserOverride::FALLBACK_OVERRIDE), "FALLBACK" }, + { static_cast(AllowParserOverride::STRICT_OVERRIDE), "STRICT" }, + { static_cast(AllowParserOverride::STRICT_WHEN_SUPPORTED), "STRICT_WHEN_SUPPORTED" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(AllowParserOverride value) { + return StringUtil::EnumToString(GetAllowParserOverrideValues(), 4, "AllowParserOverride", static_cast(value)); +} + +template<> +AllowParserOverride EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetAllowParserOverrideValues(), 4, "AllowParserOverride", value)); +} + const StringUtil::EnumStringLiteral *GetAlterDatabaseTypeValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(AlterDatabaseType::RENAME_DATABASE), "RENAME_DATABASE" } @@ -444,19 +467,21 @@ const StringUtil::EnumStringLiteral *GetAlterTableTypeValues() { { static_cast(AlterTableType::SET_SORTED_BY), "SET_SORTED_BY" }, { static_cast(AlterTableType::ADD_FIELD), "ADD_FIELD" }, { static_cast(AlterTableType::REMOVE_FIELD), "REMOVE_FIELD" }, - { static_cast(AlterTableType::RENAME_FIELD), "RENAME_FIELD" } + { static_cast(AlterTableType::RENAME_FIELD), "RENAME_FIELD" }, + { static_cast(AlterTableType::SET_TABLE_OPTIONS), "SET_TABLE_OPTIONS" }, + { static_cast(AlterTableType::RESET_TABLE_OPTIONS), "RESET_TABLE_OPTIONS" } }; return values; } template<> const char* EnumUtil::ToChars(AlterTableType value) { - return StringUtil::EnumToString(GetAlterTableTypeValues(), 17, "AlterTableType", static_cast(value)); + return StringUtil::EnumToString(GetAlterTableTypeValues(), 19, "AlterTableType", static_cast(value)); } template<> AlterTableType EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetAlterTableTypeValues(), 17, "AlterTableType", value)); + return static_cast(StringUtil::StringToEnum(GetAlterTableTypeValues(), 19, "AlterTableType", value)); } const StringUtil::EnumStringLiteral *GetAlterTypeValues() { @@ -1124,22 +1149,22 @@ CompressedMaterializationDirection EnumUtil::FromString(CompressionType::COMPRESSION_AUTO), "COMPRESSION_AUTO" }, - { static_cast(CompressionType::COMPRESSION_UNCOMPRESSED), "COMPRESSION_UNCOMPRESSED" }, - { static_cast(CompressionType::COMPRESSION_CONSTANT), "COMPRESSION_CONSTANT" }, - { static_cast(CompressionType::COMPRESSION_RLE), "COMPRESSION_RLE" }, - { static_cast(CompressionType::COMPRESSION_DICTIONARY), "COMPRESSION_DICTIONARY" }, - { static_cast(CompressionType::COMPRESSION_PFOR_DELTA), "COMPRESSION_PFOR_DELTA" }, - { static_cast(CompressionType::COMPRESSION_BITPACKING), "COMPRESSION_BITPACKING" }, - { static_cast(CompressionType::COMPRESSION_FSST), "COMPRESSION_FSST" }, - { static_cast(CompressionType::COMPRESSION_CHIMP), "COMPRESSION_CHIMP" }, - { static_cast(CompressionType::COMPRESSION_PATAS), "COMPRESSION_PATAS" }, - { static_cast(CompressionType::COMPRESSION_ALP), "COMPRESSION_ALP" }, - { static_cast(CompressionType::COMPRESSION_ALPRD), "COMPRESSION_ALPRD" }, - { static_cast(CompressionType::COMPRESSION_ZSTD), "COMPRESSION_ZSTD" }, - { static_cast(CompressionType::COMPRESSION_ROARING), "COMPRESSION_ROARING" }, - { static_cast(CompressionType::COMPRESSION_EMPTY), "COMPRESSION_EMPTY" }, - { static_cast(CompressionType::COMPRESSION_DICT_FSST), "COMPRESSION_DICT_FSST" }, + { static_cast(CompressionType::COMPRESSION_AUTO), "AUTO" }, + { static_cast(CompressionType::COMPRESSION_UNCOMPRESSED), "UNCOMPRESSED" }, + { static_cast(CompressionType::COMPRESSION_CONSTANT), "CONSTANT" }, + { static_cast(CompressionType::COMPRESSION_RLE), "RLE" }, + { static_cast(CompressionType::COMPRESSION_DICTIONARY), "DICTIONARY" }, + { static_cast(CompressionType::COMPRESSION_PFOR_DELTA), "PFOR" }, + { static_cast(CompressionType::COMPRESSION_BITPACKING), "BITPACKING" }, + { static_cast(CompressionType::COMPRESSION_FSST), "FSST" }, + { static_cast(CompressionType::COMPRESSION_CHIMP), "CHIMP" }, + { static_cast(CompressionType::COMPRESSION_PATAS), "PATAS" }, + { static_cast(CompressionType::COMPRESSION_ALP), "ALP" }, + { static_cast(CompressionType::COMPRESSION_ALPRD), "ALPRD" }, + { static_cast(CompressionType::COMPRESSION_ZSTD), "ZSTD" }, + { static_cast(CompressionType::COMPRESSION_ROARING), "ROARING" }, + { static_cast(CompressionType::COMPRESSION_EMPTY), "EMPTY" }, + { static_cast(CompressionType::COMPRESSION_DICT_FSST), "DICT_FSST" }, { static_cast(CompressionType::COMPRESSION_COUNT), "COMPRESSION_COUNT" } }; return values; @@ -1728,6 +1753,7 @@ const StringUtil::EnumStringLiteral *GetExpressionClassValues() { { static_cast(ExpressionClass::POSITIONAL_REFERENCE), "POSITIONAL_REFERENCE" }, { static_cast(ExpressionClass::BETWEEN), "BETWEEN" }, { static_cast(ExpressionClass::LAMBDA_REF), "LAMBDA_REF" }, + { static_cast(ExpressionClass::TYPE), "TYPE" }, { static_cast(ExpressionClass::BOUND_AGGREGATE), "BOUND_AGGREGATE" }, { static_cast(ExpressionClass::BOUND_CASE), "BOUND_CASE" }, { static_cast(ExpressionClass::BOUND_CAST), "BOUND_CAST" }, @@ -1754,12 +1780,12 @@ const StringUtil::EnumStringLiteral *GetExpressionClassValues() { template<> const char* EnumUtil::ToChars(ExpressionClass value) { - return StringUtil::EnumToString(GetExpressionClassValues(), 40, "ExpressionClass", static_cast(value)); + return StringUtil::EnumToString(GetExpressionClassValues(), 41, "ExpressionClass", static_cast(value)); } template<> ExpressionClass EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetExpressionClassValues(), 40, "ExpressionClass", value)); + return static_cast(StringUtil::StringToEnum(GetExpressionClassValues(), 41, "ExpressionClass", value)); } const StringUtil::EnumStringLiteral *GetExpressionTypeValues() { @@ -1827,6 +1853,7 @@ const StringUtil::EnumStringLiteral *GetExpressionTypeValues() { { static_cast(ExpressionType::FUNCTION_REF), "FUNCTION_REF" }, { static_cast(ExpressionType::TABLE_REF), "TABLE_REF" }, { static_cast(ExpressionType::LAMBDA_REF), "LAMBDA_REF" }, + { static_cast(ExpressionType::TYPE), "TYPE" }, { static_cast(ExpressionType::CAST), "CAST" }, { static_cast(ExpressionType::BOUND_REF), "BOUND_REF" }, { static_cast(ExpressionType::BOUND_COLUMN_REF), "BOUND_COLUMN_REF" }, @@ -1842,12 +1869,12 @@ const StringUtil::EnumStringLiteral *GetExpressionTypeValues() { template<> const char* EnumUtil::ToChars(ExpressionType value) { - return StringUtil::EnumToString(GetExpressionTypeValues(), 72, "ExpressionType", static_cast(value)); + return StringUtil::EnumToString(GetExpressionTypeValues(), 73, "ExpressionType", static_cast(value)); } template<> ExpressionType EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetExpressionTypeValues(), 72, "ExpressionType", value)); + return static_cast(StringUtil::StringToEnum(GetExpressionTypeValues(), 73, "ExpressionType", value)); } const StringUtil::EnumStringLiteral *GetExtensionABITypeValues() { @@ -1952,6 +1979,25 @@ ExtraDropInfoType EnumUtil::FromString(const char *value) { return static_cast(StringUtil::StringToEnum(GetExtraDropInfoTypeValues(), 2, "ExtraDropInfoType", value)); } +const StringUtil::EnumStringLiteral *GetExtraPersistentColumnDataTypeValues() { + static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(ExtraPersistentColumnDataType::INVALID), "INVALID" }, + { static_cast(ExtraPersistentColumnDataType::VARIANT), "VARIANT" }, + { static_cast(ExtraPersistentColumnDataType::GEOMETRY), "GEOMETRY" } + }; + return values; +} + +template<> +const char* EnumUtil::ToChars(ExtraPersistentColumnDataType value) { + return StringUtil::EnumToString(GetExtraPersistentColumnDataTypeValues(), 3, "ExtraPersistentColumnDataType", static_cast(value)); +} + +template<> +ExtraPersistentColumnDataType EnumUtil::FromString(const char *value) { + return static_cast(StringUtil::StringToEnum(GetExtraPersistentColumnDataTypeValues(), 3, "ExtraPersistentColumnDataType", value)); +} + const StringUtil::EnumStringLiteral *GetExtraTypeInfoTypeValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(ExtraTypeInfoType::INVALID_TYPE_INFO), "INVALID_TYPE_INFO" }, @@ -1961,7 +2007,7 @@ const StringUtil::EnumStringLiteral *GetExtraTypeInfoTypeValues() { { static_cast(ExtraTypeInfoType::LIST_TYPE_INFO), "LIST_TYPE_INFO" }, { static_cast(ExtraTypeInfoType::STRUCT_TYPE_INFO), "STRUCT_TYPE_INFO" }, { static_cast(ExtraTypeInfoType::ENUM_TYPE_INFO), "ENUM_TYPE_INFO" }, - { static_cast(ExtraTypeInfoType::USER_TYPE_INFO), "USER_TYPE_INFO" }, + { static_cast(ExtraTypeInfoType::UNBOUND_TYPE_INFO), "UNBOUND_TYPE_INFO" }, { static_cast(ExtraTypeInfoType::AGGREGATE_STATE_TYPE_INFO), "AGGREGATE_STATE_TYPE_INFO" }, { static_cast(ExtraTypeInfoType::ARRAY_TYPE_INFO), "ARRAY_TYPE_INFO" }, { static_cast(ExtraTypeInfoType::ANY_TYPE_INFO), "ANY_TYPE_INFO" }, @@ -2759,8 +2805,9 @@ const StringUtil::EnumStringLiteral *GetLogicalTypeIdValues() { { static_cast(LogicalTypeId::SQLNULL), "NULL" }, { static_cast(LogicalTypeId::UNKNOWN), "UNKNOWN" }, { static_cast(LogicalTypeId::ANY), "ANY" }, - { static_cast(LogicalTypeId::USER), "USER" }, + { static_cast(LogicalTypeId::UNBOUND), "UNBOUND" }, { static_cast(LogicalTypeId::TEMPLATE), "TEMPLATE" }, + { static_cast(LogicalTypeId::TYPE), "TYPE" }, { static_cast(LogicalTypeId::BOOLEAN), "BOOLEAN" }, { static_cast(LogicalTypeId::TINYINT), "TINYINT" }, { static_cast(LogicalTypeId::SMALLINT), "SMALLINT" }, @@ -2812,12 +2859,12 @@ const StringUtil::EnumStringLiteral *GetLogicalTypeIdValues() { template<> const char* EnumUtil::ToChars(LogicalTypeId value) { - return StringUtil::EnumToString(GetLogicalTypeIdValues(), 51, "LogicalTypeId", static_cast(value)); + return StringUtil::EnumToString(GetLogicalTypeIdValues(), 52, "LogicalTypeId", static_cast(value)); } template<> LogicalTypeId EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetLogicalTypeIdValues(), 51, "LogicalTypeId", value)); + return static_cast(StringUtil::StringToEnum(GetLogicalTypeIdValues(), 52, "LogicalTypeId", value)); } const StringUtil::EnumStringLiteral *GetLookupResultTypeValues() { @@ -2895,19 +2942,21 @@ const StringUtil::EnumStringLiteral *GetMemoryTagValues() { { static_cast(MemoryTag::EXTENSION), "EXTENSION" }, { static_cast(MemoryTag::TRANSACTION), "TRANSACTION" }, { static_cast(MemoryTag::EXTERNAL_FILE_CACHE), "EXTERNAL_FILE_CACHE" }, - { static_cast(MemoryTag::WINDOW), "WINDOW" } + { static_cast(MemoryTag::WINDOW), "WINDOW" }, + { static_cast(MemoryTag::OBJECT_CACHE), "OBJECT_CACHE" }, + { static_cast(MemoryTag::UNKNOWN), "UNKNOWN" } }; return values; } template<> const char* EnumUtil::ToChars(MemoryTag value) { - return StringUtil::EnumToString(GetMemoryTagValues(), 15, "MemoryTag", static_cast(value)); + return StringUtil::EnumToString(GetMemoryTagValues(), 17, "MemoryTag", static_cast(value)); } template<> MemoryTag EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetMemoryTagValues(), 15, "MemoryTag", value)); + return static_cast(StringUtil::StringToEnum(GetMemoryTagValues(), 17, "MemoryTag", value)); } const StringUtil::EnumStringLiteral *GetMergeActionConditionValues() { @@ -4326,19 +4375,20 @@ const StringUtil::EnumStringLiteral *GetShowTypeValues() { static constexpr StringUtil::EnumStringLiteral values[] { { static_cast(ShowType::SUMMARY), "SUMMARY" }, { static_cast(ShowType::DESCRIBE), "DESCRIBE" }, - { static_cast(ShowType::SHOW_FROM), "SHOW_FROM" } + { static_cast(ShowType::SHOW_FROM), "SHOW_FROM" }, + { static_cast(ShowType::SHOW_UNQUALIFIED), "SHOW_UNQUALIFIED" } }; return values; } template<> const char* EnumUtil::ToChars(ShowType value) { - return StringUtil::EnumToString(GetShowTypeValues(), 3, "ShowType", static_cast(value)); + return StringUtil::EnumToString(GetShowTypeValues(), 4, "ShowType", static_cast(value)); } template<> ShowType EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetShowTypeValues(), 3, "ShowType", value)); + return static_cast(StringUtil::StringToEnum(GetShowTypeValues(), 4, "ShowType", value)); } const StringUtil::EnumStringLiteral *GetSimplifiedTokenTypeValues() { @@ -5113,6 +5163,7 @@ UnionInvalidReason EnumUtil::FromString(const char *value) { const StringUtil::EnumStringLiteral *GetVariantChildLookupModeValues() { static constexpr StringUtil::EnumStringLiteral values[] { + { static_cast(VariantChildLookupMode::INVALID), "INVALID" }, { static_cast(VariantChildLookupMode::BY_KEY), "BY_KEY" }, { static_cast(VariantChildLookupMode::BY_INDEX), "BY_INDEX" } }; @@ -5121,12 +5172,12 @@ const StringUtil::EnumStringLiteral *GetVariantChildLookupModeValues() { template<> const char* EnumUtil::ToChars(VariantChildLookupMode value) { - return StringUtil::EnumToString(GetVariantChildLookupModeValues(), 2, "VariantChildLookupMode", static_cast(value)); + return StringUtil::EnumToString(GetVariantChildLookupModeValues(), 3, "VariantChildLookupMode", static_cast(value)); } template<> VariantChildLookupMode EnumUtil::FromString(const char *value) { - return static_cast(StringUtil::StringToEnum(GetVariantChildLookupModeValues(), 2, "VariantChildLookupMode", value)); + return static_cast(StringUtil::StringToEnum(GetVariantChildLookupModeValues(), 3, "VariantChildLookupMode", value)); } const StringUtil::EnumStringLiteral *GetVariantLogicalTypeValues() { diff --git a/src/duckdb/src/common/enums/compression_type.cpp b/src/duckdb/src/common/enums/compression_type.cpp index 427cfbe91..15cfdac70 100644 --- a/src/duckdb/src/common/enums/compression_type.cpp +++ b/src/duckdb/src/common/enums/compression_type.cpp @@ -73,41 +73,6 @@ CompressionAvailabilityResult CompressionTypeIsAvailable(CompressionType compres return CompressionAvailabilityResult(); } -CompressionType CompressionTypeFromString(const string &str) { - auto compression = StringUtil::Lower(str); - //! NOTE: this explicitly does not include 'constant' and 'empty validity', these are internal compression functions - //! not general purpose - if (compression == "uncompressed") { - return CompressionType::COMPRESSION_UNCOMPRESSED; - } else if (compression == "rle") { - return CompressionType::COMPRESSION_RLE; - } else if (compression == "dictionary") { - return CompressionType::COMPRESSION_DICTIONARY; - } else if (compression == "pfor") { - return CompressionType::COMPRESSION_PFOR_DELTA; - } else if (compression == "bitpacking") { - return CompressionType::COMPRESSION_BITPACKING; - } else if (compression == "fsst") { - return CompressionType::COMPRESSION_FSST; - } else if (compression == "chimp") { - return CompressionType::COMPRESSION_CHIMP; - } else if (compression == "patas") { - return CompressionType::COMPRESSION_PATAS; - } else if (compression == "zstd") { - return CompressionType::COMPRESSION_ZSTD; - } else if (compression == "alp") { - return CompressionType::COMPRESSION_ALP; - } else if (compression == "alprd") { - return CompressionType::COMPRESSION_ALPRD; - } else if (compression == "roaring") { - return CompressionType::COMPRESSION_ROARING; - } else if (compression == "dict_fsst") { - return CompressionType::COMPRESSION_DICT_FSST; - } else { - return CompressionType::COMPRESSION_AUTO; - } -} - string CompressionTypeToString(CompressionType type) { switch (type) { case CompressionType::COMPRESSION_AUTO: diff --git a/src/duckdb/src/common/enums/expression_type.cpp b/src/duckdb/src/common/enums/expression_type.cpp index f1375d3a1..42014a9d1 100644 --- a/src/duckdb/src/common/enums/expression_type.cpp +++ b/src/duckdb/src/common/enums/expression_type.cpp @@ -147,6 +147,8 @@ string ExpressionTypeToString(ExpressionType type) { return "LAMBDA"; case ExpressionType::ARROW: return "ARROW"; + case ExpressionType::TYPE: + return "TYPE"; case ExpressionType::BOUND_EXPANDED: return "BOUND_EXPANDED"; case ExpressionType::INVALID: @@ -196,6 +198,8 @@ string ExpressionClassToString(ExpressionClass type) { return "POSITIONAL_REFERENCE"; case ExpressionClass::BETWEEN: return "BETWEEN"; + case ExpressionClass::TYPE: + return "TYPE"; case ExpressionClass::BOUND_AGGREGATE: return "BOUND_AGGREGATE"; case ExpressionClass::BOUND_CASE: diff --git a/src/duckdb/src/common/error_data.cpp b/src/duckdb/src/common/error_data.cpp index 8b8da300d..770ab4d14 100644 --- a/src/duckdb/src/common/error_data.cpp +++ b/src/duckdb/src/common/error_data.cpp @@ -18,35 +18,40 @@ ErrorData::ErrorData(const std::exception &ex) : ErrorData(ex.what()) { } ErrorData::ErrorData(ExceptionType type, const string &message) - : initialized(true), type(type), raw_message(SanitizeErrorMessage(message)), - final_message(ConstructFinalMessage()) { + : initialized(true), type(type), raw_message(SanitizeErrorMessage(message)) { + // In the case of ExceptionType::INTERNAL, the stack trace is part of the final message. + // To construct it, we need to access extra_info, which has to be initialized first. + // Thus, we only set final_message in the constructor's body. + final_message = ConstructFinalMessage(); } ErrorData::ErrorData(const string &message) : initialized(true), type(ExceptionType::INVALID), raw_message(string()), final_message(string()) { // parse the constructed JSON if (message.empty() || message[0] != '{') { - // not JSON! Use the message as a raw Exception message and leave type as uninitialized - + // Not a JSON-formatted message. + // Use the message as a raw Exception message and leave the type as uninitialized. if (message == std::bad_alloc().what()) { type = ExceptionType::OUT_OF_MEMORY; raw_message = "Allocation failure"; } else { raw_message = message; } - } else { - auto info = StringUtil::ParseJSONMap(message)->Flatten(); - for (auto &entry : info) { - if (entry.first == "exception_type") { - type = Exception::StringToExceptionType(entry.second); - } else if (entry.first == "exception_message") { - raw_message = SanitizeErrorMessage(entry.second); - } else { - extra_info[entry.first] = entry.second; - } - } + final_message = ConstructFinalMessage(); + return; } + // JSON-formatted message. + auto info = StringUtil::ParseJSONMap(message)->Flatten(); + for (auto &entry : info) { + if (entry.first == "exception_type") { + type = Exception::StringToExceptionType(entry.second); + } else if (entry.first == "exception_message") { + raw_message = SanitizeErrorMessage(entry.second); + } else { + extra_info[entry.first] = entry.second; + } + } final_message = ConstructFinalMessage(); } diff --git a/src/duckdb/src/common/extra_type_info.cpp b/src/duckdb/src/common/extra_type_info.cpp index 932c08c0c..dc34d88ec 100644 --- a/src/duckdb/src/common/extra_type_info.cpp +++ b/src/duckdb/src/common/extra_type_info.cpp @@ -6,6 +6,8 @@ #include "duckdb/common/serializer/serializer.hpp" #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" #include "duckdb/common/string_map_set.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/type_expression.hpp" namespace duckdb { @@ -261,30 +263,66 @@ shared_ptr AggregateStateTypeInfo::Copy() const { //===--------------------------------------------------------------------===// // User Type Info //===--------------------------------------------------------------------===// -UserTypeInfo::UserTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO) { -} +void UnboundTypeInfo::Serialize(Serializer &serializer) const { + ExtraTypeInfo::Serialize(serializer); -UserTypeInfo::UserTypeInfo(string name_p) - : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)) { -} + if (serializer.ShouldSerialize(7)) { + serializer.WritePropertyWithDefault>(204, "expr", expr); + return; + } -UserTypeInfo::UserTypeInfo(string name_p, vector modifiers_p) - : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), user_type_name(std::move(name_p)), - user_type_modifiers(std::move(modifiers_p)) { -} + // Try to write this as an old "USER" type, if possible + if (expr->type != ExpressionType::TYPE) { + throw SerializationException( + "Cannot serialize non-type type expression when targeting database storage version '%s'", + serializer.GetOptions().serialization_compatibility.duckdb_version); + } -UserTypeInfo::UserTypeInfo(string catalog_p, string schema_p, string name_p, vector modifiers_p) - : ExtraTypeInfo(ExtraTypeInfoType::USER_TYPE_INFO), catalog(std::move(catalog_p)), schema(std::move(schema_p)), - user_type_name(std::move(name_p)), user_type_modifiers(std::move(modifiers_p)) { -} + auto &type_expr = expr->Cast(); + serializer.WritePropertyWithDefault(200, "name", type_expr.GetTypeName()); + serializer.WritePropertyWithDefault(201, "catalog", type_expr.GetCatalog()); + serializer.WritePropertyWithDefault(202, "schema", type_expr.GetSchema()); + + // Try to write the user type mods too + vector user_type_mods; + for (auto ¶m : type_expr.GetChildren()) { + if (param->type != ExpressionType::VALUE_CONSTANT) { + throw SerializationException( + "Cannot serialize non-constant type parameter when targeting serialization version %s", + serializer.GetOptions().serialization_compatibility.duckdb_version); + } -bool UserTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const { - auto &other = other_p->Cast(); - return other.user_type_name == user_type_name; + auto &const_expr = param->Cast(); + user_type_mods.push_back(const_expr.value); + } + + serializer.WritePropertyWithDefault>(203, "user_type_modifiers", user_type_mods); } -shared_ptr UserTypeInfo::Copy() const { - return make_shared_ptr(*this); +shared_ptr UnboundTypeInfo::Deserialize(Deserializer &deserializer) { + auto result = duckdb::shared_ptr(new UnboundTypeInfo()); + + deserializer.ReadPropertyWithDefault>(204, "expr", result->expr); + + if (!result->expr) { + // This is a legacy "USER" type + string name; + deserializer.ReadPropertyWithDefault(200, "name", name); + string catalog; + deserializer.ReadPropertyWithDefault(201, "catalog", catalog); + string schema; + deserializer.ReadPropertyWithDefault(202, "schema", schema); + + vector> user_type_mods; + auto mods = deserializer.ReadPropertyWithDefault>(203, "user_type_modifiers"); + for (auto &mod : mods) { + user_type_mods.push_back(make_uniq_base(mod)); + } + + result->expr = make_uniq(catalog, schema, name, std::move(user_type_mods)); + } + + return std::move(result); } //===--------------------------------------------------------------------===// @@ -523,4 +561,26 @@ shared_ptr GeoTypeInfo::Copy() const { return make_shared_ptr(*this); } +//===--------------------------------------------------------------------===// +// Unbound Type Info +//===--------------------------------------------------------------------===// +UnboundTypeInfo::UnboundTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::UNBOUND_TYPE_INFO) { +} + +UnboundTypeInfo::UnboundTypeInfo(unique_ptr expr_p) + : ExtraTypeInfo(ExtraTypeInfoType::UNBOUND_TYPE_INFO), expr(std::move(expr_p)) { +} + +bool UnboundTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const { + auto &other = other_p->Cast(); + if (!expr->Equals(*other.expr)) { + return false; + } + return true; +} + +shared_ptr UnboundTypeInfo::Copy() const { + return make_shared_ptr(expr->Copy()); +} + } // namespace duckdb diff --git a/src/duckdb/src/common/file_system.cpp b/src/duckdb/src/common/file_system.cpp index ce4f9022a..72fbc13ab 100644 --- a/src/duckdb/src/common/file_system.cpp +++ b/src/duckdb/src/common/file_system.cpp @@ -5,6 +5,7 @@ #include "duckdb/common/file_opener.hpp" #include "duckdb/common/helper.hpp" #include "duckdb/common/string_util.hpp" +#include "duckdb/common/multi_file/multi_file_list.hpp" #include "duckdb/common/windows.hpp" #include "duckdb/function/scalar/string_functions.hpp" #include "duckdb/logging/log_type.hpp" @@ -60,6 +61,7 @@ constexpr FileOpenFlags FileFlags::FILE_FLAGS_EXCLUSIVE_CREATE; constexpr FileOpenFlags FileFlags::FILE_FLAGS_NULL_IF_EXISTS; constexpr FileOpenFlags FileFlags::FILE_FLAGS_MULTI_CLIENT_ACCESS; constexpr FileOpenFlags FileFlags::FILE_FLAGS_DISABLE_LOGGING; +constexpr FileOpenFlags FileFlags::FILE_FLAGS_ENABLE_EXTENSION_INSTALL; void FileOpenFlags::Verify() { #ifdef DEBUG @@ -412,6 +414,10 @@ bool FileSystem::SupportsListFilesExtended() const { return false; } +bool FileSystem::SupportsGlobExtended() const { + return false; +} + void FileSystem::Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) { throw NotImplementedException("%s: Read (with location) is not implemented!", GetName()); } @@ -600,9 +606,28 @@ bool FileSystem::HasGlob(const string &str) { } vector FileSystem::Glob(const string &path, FileOpener *opener) { + if (SupportsGlobExtended()) { + auto result = GlobFilesExtended(path, FileGlobOptions::ALLOW_EMPTY, opener); + return result->GetAllFiles(); + } throw NotImplementedException("%s: Glob is not implemented!", GetName()); } +unique_ptr FileSystem::Glob(const string &path, const FileGlobInput &input, + optional_ptr opener) { + if (!SupportsGlobExtended()) { + auto result = Glob(path, opener.get()); + return make_uniq(std::move(result)); + } else { + return GlobFilesExtended(path, input, opener); + } +} + +unique_ptr FileSystem::GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener) { + throw NotImplementedException("%s: GlobFilesExtended is not implemented!", GetName()); +} + void FileSystem::RegisterSubSystem(unique_ptr sub_fs) { throw NotImplementedException("%s: Can't register a sub system on a non-virtual file system", GetName()); } @@ -639,9 +664,9 @@ bool FileSystem::CanHandleFile(const string &fpath) { throw NotImplementedException("%s: CanHandleFile is not implemented!", GetName()); } -vector FileSystem::GlobFiles(const string &pattern, ClientContext &context, const FileGlobInput &input) { - auto result = Glob(pattern); - if (result.empty()) { +unique_ptr FileSystem::GlobFileList(const string &pattern, const FileGlobInput &input) { + auto result = GlobFilesExtended(pattern, input); + if (result->IsEmpty()) { if (input.behavior == FileGlobOptions::FALLBACK_GLOB && !HasGlob(pattern)) { // if we have no glob in the pattern and we have an extension, we try to glob if (!HasGlob(pattern)) { @@ -649,8 +674,8 @@ vector FileSystem::GlobFiles(const string &pattern, ClientContext throw InternalException("FALLBACK_GLOB requires an extension to be specified"); } string new_pattern = JoinPath(JoinPath(pattern, "**"), "*." + input.extension); - result = GlobFiles(new_pattern, context, FileGlobOptions::ALLOW_EMPTY); - if (!result.empty()) { + result = GlobFileList(new_pattern, FileGlobOptions::ALLOW_EMPTY); + if (!result->IsEmpty()) { // we found files by globbing the target as if it was a directory - return them return result; } @@ -663,6 +688,11 @@ vector FileSystem::GlobFiles(const string &pattern, ClientContext return result; } +vector FileSystem::GlobFiles(const string &pattern, const FileGlobInput &input) { + auto file_list = GlobFileList(pattern, input); + return file_list->GetAllFiles(); +} + void FileSystem::Seek(FileHandle &handle, idx_t location) { throw NotImplementedException("%s: Seek is not implemented!", GetName()); } diff --git a/src/duckdb/src/common/hive_partitioning.cpp b/src/duckdb/src/common/hive_partitioning.cpp index 78f3b40e8..a4ae9486a 100644 --- a/src/duckdb/src/common/hive_partitioning.cpp +++ b/src/duckdb/src/common/hive_partitioning.cpp @@ -126,7 +126,7 @@ std::map HivePartitioning::Parse(const string &filename) { Value HivePartitioning::GetValue(ClientContext &context, const string &key, const string &str_val, const LogicalType &type) { // Handle nulls - if (StringUtil::CIEquals(str_val, "NULL")) { + if (StringUtil::CIEquals(str_val, "NULL") || str_val == "__HIVE_DEFAULT_PARTITION__") { return Value(type); } if (type.id() == LogicalTypeId::VARCHAR) { @@ -244,26 +244,13 @@ static void TemplatedGetHivePartitionValues(Vector &input, vector(data[sel.get_index(0)]).GetTypeMutable() != type; - if (reinterpret) { - for (idx_t i = 0; i < count; i++) { - auto &key = keys[i]; - const auto idx = sel.get_index(i); - if (validity.RowIsValid(idx)) { - key.values[col_idx] = GetHiveKeyValue(data[idx], type); - } else { - key.values[col_idx] = GetHiveKeyNullValue(type); - } - } - } else { - for (idx_t i = 0; i < count; i++) { - auto &key = keys[i]; - const auto idx = sel.get_index(i); - if (validity.RowIsValid(idx)) { - key.values[col_idx] = GetHiveKeyValue(data[idx]); - } else { - key.values[col_idx] = GetHiveKeyNullValue(type); - } + for (idx_t i = 0; i < count; i++) { + auto &key = keys[i]; + const auto idx = sel.get_index(i); + if (validity.RowIsValid(idx)) { + key.values[col_idx] = GetHiveKeyValue(data[idx], type); + } else { + key.values[col_idx] = GetHiveKeyNullValue(type); } } } diff --git a/src/duckdb/src/common/local_file_system.cpp b/src/duckdb/src/common/local_file_system.cpp index 3d9cae503..246796e32 100644 --- a/src/duckdb/src/common/local_file_system.cpp +++ b/src/duckdb/src/common/local_file_system.cpp @@ -11,6 +11,7 @@ #include "duckdb/main/database.hpp" #include "duckdb/logging/file_system_logger.hpp" #include "duckdb/logging/log_manager.hpp" +#include "duckdb/common/multi_file/multi_file_list.hpp" #include #include @@ -1370,9 +1371,7 @@ static bool IsCrawl(const string &glob) { // glob must match exactly return glob == "**"; } -static bool HasMultipleCrawl(const vector &splits) { - return std::count(splits.begin(), splits.end(), "**") > 1; -} + static bool IsSymbolicLink(const string &path) { auto normalized_path = LocalFileSystem::NormalizeLocalPath(path); #ifndef _WIN32 @@ -1386,45 +1385,8 @@ static bool IsSymbolicLink(const string &path) { #endif } -static void RecursiveGlobDirectories(FileSystem &fs, const string &path, vector &result, - bool match_directory, bool join_path) { - fs.ListFiles(path, [&](OpenFileInfo &info) { - if (join_path) { - info.path = fs.JoinPath(path, info.path); - } - if (IsSymbolicLink(info.path)) { - return; - } - bool is_directory = FileSystem::IsDirectory(info); - bool return_file = is_directory == match_directory; - if (is_directory) { - if (return_file) { - result.push_back(info); - } - RecursiveGlobDirectories(fs, info.path, result, match_directory, true); - } else if (return_file) { - result.push_back(std::move(info)); - } - }); -} - -static void GlobFilesInternal(FileSystem &fs, const string &path, const string &glob, bool match_directory, - vector &result, bool join_path) { - fs.ListFiles(path, [&](OpenFileInfo &info) { - bool is_directory = FileSystem::IsDirectory(info); - if (is_directory != match_directory) { - return; - } - if (Glob(info.path.c_str(), info.path.size(), glob.c_str(), glob.size())) { - if (join_path) { - info.path = fs.JoinPath(path, info.path); - } - result.push_back(std::move(info)); - } - }); -} - -vector LocalFileSystem::FetchFileWithoutGlob(const string &path, FileOpener *opener, bool absolute_path) { +vector LocalFileSystem::FetchFileWithoutGlob(const string &path, optional_ptr opener, + bool absolute_path) { vector result; if (FileExists(path, opener) || IsPipe(path, opener)) { result.emplace_back(path); @@ -1485,14 +1447,93 @@ const char *LocalFileSystem::NormalizeLocalPath(const string &path) { return path.c_str() + GetFileUrlOffset(path); } -vector LocalFileSystem::Glob(const string &path, FileOpener *opener) { +struct PathSplit { + PathSplit(LocalFileSystem &fs, string path_p) : path(std::move(path_p)), has_glob(fs.HasGlob(path)) { + } + + string path; + bool has_glob; +}; + +static bool HasMultipleCrawl(const vector &splits) { + idx_t crawl_count = 0; + for (auto &split : splits) { + if (split.path == "**") { + crawl_count++; + } + } + return crawl_count > 1; +} + +struct ExpandDirectory { + ExpandDirectory(string path_p, idx_t split_index, bool is_empty = false) + : path(std::move(path_p)), split_index(split_index), is_empty(is_empty) { + } + + string path; + idx_t split_index; + bool is_empty = false; + + bool operator<(const ExpandDirectory &other) const { + return path > other.path; + } +}; + +static void CrawlDirectoryLevel(FileSystem &fs, const string &path, optional_ptr> files, + std::priority_queue &directories, idx_t split_index) { + fs.ListFiles(path, [&](OpenFileInfo &info) { + info.path = fs.JoinPath(path, info.path); + if (IsSymbolicLink(info.path)) { + return; + } + bool is_directory = FileSystem::IsDirectory(info); + if (is_directory) { + directories.emplace(std::move(info.path), split_index); + } else if (files) { + files->push_back(std::move(info)); + } + }); +} + +static void GlobFilesInternal(FileSystem &fs, const string &path, const string &glob, bool match_directory, + vector &result) { + fs.ListFiles(path, [&](OpenFileInfo &info) { + bool is_directory = FileSystem::IsDirectory(info); + if (is_directory != match_directory) { + return; + } + if (Glob(info.path.c_str(), info.path.size(), glob.c_str(), glob.size())) { + info.path = fs.JoinPath(path, info.path); + result.push_back(std::move(info)); + } + }); +} + +struct LocalGlobResult : public LazyMultiFileList { +public: + LocalGlobResult(LocalFileSystem &fs, const string &path, FileGlobOptions options, optional_ptr opener); + +protected: + bool ExpandNextPath() const override; + +private: + LocalFileSystem &fs; + string path; + optional_ptr opener; + vector splits; + bool absolute_path = false; + mutable std::priority_queue expand_directories; + mutable bool finished = false; +}; + +LocalGlobResult::LocalGlobResult(LocalFileSystem &fs, const string &path_p, FileGlobOptions options_p, + optional_ptr opener) + : LazyMultiFileList(FileOpener::TryGetClientContext(opener)), fs(fs), path(path_p), opener(opener) { if (path.empty()) { - return vector(); + finished = true; + return; } // split up the path into separate chunks - vector splits; - - bool is_file_url = StringUtil::StartsWith(path, "file:/"); idx_t file_url_path_offset = GetFileUrlOffset(path); idx_t last_pos = 0; @@ -1504,129 +1545,151 @@ vector LocalFileSystem::Glob(const string &path, FileOpener *opene continue; } if (splits.empty()) { - // splits.push_back(path.substr(file_url_path_offset, i-file_url_path_offset)); - splits.push_back(path.substr(0, i)); + splits.emplace_back(fs, path.substr(0, i)); } else { - splits.push_back(path.substr(last_pos, i - last_pos)); + splits.emplace_back(fs, path.substr(last_pos, i - last_pos)); } last_pos = i + 1; } } - splits.push_back(path.substr(last_pos, path.size() - last_pos)); + splits.emplace_back(fs, path.substr(last_pos, path.size() - last_pos)); // handle absolute paths - bool absolute_path = false; - if (IsPathAbsolute(path)) { + absolute_path = false; + if (fs.IsPathAbsolute(path)) { // first character is a slash - unix absolute path absolute_path = true; - } else if (StringUtil::Contains(splits[0], ":")) { // TODO: this is weird? shouldn't IsPathAbsolute handle this? + } else if (StringUtil::Contains(splits[0].path, + ":")) { // TODO: this is weird? shouldn't IsPathAbsolute handle this? // first split has a colon - windows absolute path absolute_path = true; - } else if (splits[0] == "~") { + } else if (splits[0].path == "~") { // starts with home directory - auto home_directory = GetHomeDirectory(opener); + auto home_directory = fs.GetHomeDirectory(opener); if (!home_directory.empty()) { absolute_path = true; - splits[0] = home_directory; + splits[0].path = home_directory; D_ASSERT(path[0] == '~'); - if (!HasGlob(path)) { - return Glob(home_directory + path.substr(1)); + if (!fs.HasGlob(path)) { + expanded_files = fs.FetchFileWithoutGlob(home_directory + path.substr(1), opener, absolute_path); + finished = true; + return; } } } // Check if the path has a glob at all - if (!HasGlob(path)) { + if (!fs.HasGlob(path)) { // no glob: return only the file (if it exists or is a pipe) - return FetchFileWithoutGlob(path, opener, absolute_path); + expanded_files = fs.FetchFileWithoutGlob(path, opener, absolute_path); + finished = true; + return; } - vector previous_directories; if (absolute_path) { // for absolute paths, we don't start by scanning the current directory - previous_directories.push_back(splits[0]); + // FIXME: we don't support /[GLOB]/.. - i.e. globs in the first level of an absolute path + if (splits.size() > 1) { + expand_directories.emplace(splits[0].path, 1); + } } else { // If file_search_path is set, use those paths as the first glob elements Value value; if (opener && opener->TryGetCurrentSetting("file_search_path", value)) { auto search_paths_str = value.ToString(); - vector search_paths = StringUtil::Split(search_paths_str, ','); + auto search_paths = StringUtil::Split(search_paths_str, ','); for (const auto &search_path : search_paths) { - previous_directories.push_back(search_path); + expand_directories.emplace(search_path, 0); } } + if (expand_directories.empty()) { + expand_directories.emplace(".", 0, true); + } } if (HasMultipleCrawl(splits)) { throw IOException("Cannot use multiple \'**\' in one path"); } +} + +bool LocalGlobResult::ExpandNextPath() const { + if (finished) { + return false; + } + if (expand_directories.empty()) { + if (expanded_files.empty()) { + // no result found that matches the glob + // last ditch effort: search the path as a string literal + expanded_files = fs.FetchFileWithoutGlob(path, opener, absolute_path); + } + finished = true; + return false; + } - idx_t start_index; - if (is_file_url) { - start_index = 1; - } else if (absolute_path) { - start_index = 1; + auto next_dir = expand_directories.top(); + auto is_empty = next_dir.is_empty; + auto split_index = next_dir.split_index; + auto ¤t_path = next_dir.path; + expand_directories.pop(); + + auto &next_split = splits[split_index]; + bool is_last_component = split_index + 1 == splits.size(); + auto &next_component = next_split.path; + bool has_glob = next_split.has_glob; + // if it's the last chunk we need to find files, otherwise we find directories + // not the last chunk: gather a list of all directories that match the glob pattern + if (!has_glob) { + // no glob, just append as-is + if (is_empty) { + if (is_last_component) { + throw InternalException("No glob in only component - but entire split has globs?"); + } + // no path yet - just append + expand_directories.emplace(next_component, split_index + 1); + } else { + if (is_last_component) { + // last component - we are emitting a result here + auto filename = fs.JoinPath(current_path, next_component); + if (fs.FileExists(filename, opener) || fs.DirectoryExists(filename, opener)) { + expanded_files.emplace_back(std::move(filename)); + } + } else { + // not the last component - add the next directory as "to-be-expanded" + expand_directories.emplace(fs.JoinPath(current_path, next_component), split_index + 1); + } + } } else { - start_index = 0; - } - - for (idx_t i = start_index ? 1 : 0; i < splits.size(); i++) { - bool is_last_chunk = i + 1 == splits.size(); - bool has_glob = HasGlob(splits[i]); - // if it's the last chunk we need to find files, otherwise we find directories - // not the last chunk: gather a list of all directories that match the glob pattern - vector result; - if (!has_glob) { - // no glob, just append as-is - if (previous_directories.empty()) { - result.push_back(splits[i]); + // glob - need to resolve the glob + if (IsCrawl(next_component)) { + if (is_last_component) { + // the crawl is the last component - we are looking for files in this directory + // any directories we encounter are added to the expand directories + CrawlDirectoryLevel(fs, current_path, expanded_files, expand_directories, split_index); } else { - if (is_last_chunk) { - for (auto &prev_directory : previous_directories) { - const string filename = JoinPath(prev_directory.path, splits[i]); - if (FileExists(filename, opener) || DirectoryExists(filename, opener)) { - result.push_back(filename); - } - } - } else { - for (auto &prev_directory : previous_directories) { - result.push_back(JoinPath(prev_directory.path, splits[i])); - } - } + // not the last crawl + // ** also matches the current directory (i.e. dir/**/file.parquet also matches dir/file.parquet) + expand_directories.emplace(current_path, split_index + 1); + // now crawl the contents of this directory - but don't add any files we find + CrawlDirectoryLevel(fs, current_path, nullptr, expand_directories, split_index); } } else { - if (IsCrawl(splits[i])) { - if (!is_last_chunk) { - result = previous_directories; - } - if (previous_directories.empty()) { - RecursiveGlobDirectories(*this, ".", result, !is_last_chunk, false); - } else { - for (auto &prev_dir : previous_directories) { - RecursiveGlobDirectories(*this, prev_dir.path, result, !is_last_chunk, true); - } - } + // glob this directory according to the next component + if (is_last_component) { + // last component - match files and place them in the result + GlobFilesInternal(fs, current_path, next_component, false, expanded_files); } else { - if (previous_directories.empty()) { - // no previous directories: list in the current path - GlobFilesInternal(*this, ".", splits[i], !is_last_chunk, result, false); - } else { - // previous directories - // we iterate over each of the previous directories, and apply the glob of the current directory - for (auto &prev_directory : previous_directories) { - GlobFilesInternal(*this, prev_directory.path, splits[i], !is_last_chunk, result, true); - } + // not the last component - match directories and add to expansion list + vector child_directories; + GlobFilesInternal(fs, current_path, next_component, true, child_directories); + for (auto &file : child_directories) { + expand_directories.emplace(std::move(file.path), split_index + 1); } } } - if (result.empty()) { - // no result found that matches the glob - // last ditch effort: search the path as a string literal - return FetchFileWithoutGlob(path, opener, absolute_path); - } - if (is_last_chunk) { - return result; - } - previous_directories = std::move(result); } - return vector(); + return true; +} + +unique_ptr LocalFileSystem::GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener) { + return make_uniq(*this, path, FileGlobOptions::ALLOW_EMPTY, opener); } unique_ptr FileSystem::CreateLocal() { diff --git a/src/duckdb/src/common/multi_file/multi_file_list.cpp b/src/duckdb/src/common/multi_file/multi_file_list.cpp index 97e6addac..e39c92694 100644 --- a/src/duckdb/src/common/multi_file/multi_file_list.cpp +++ b/src/duckdb/src/common/multi_file/multi_file_list.cpp @@ -4,10 +4,9 @@ #include "duckdb/common/hive_partitioning.hpp" #include "duckdb/common/types.hpp" #include "duckdb/function/function_set.hpp" -#include "duckdb/function/table_function.hpp" #include "duckdb/main/config.hpp" #include "duckdb/planner/operator/logical_get.hpp" -#include "duckdb/common/string_util.hpp" +#include "duckdb/planner/expression/bound_columnref_expression.hpp" #include @@ -79,14 +78,15 @@ bool PushdownInternal(ClientContext &context, const MultiFileOptions &options, c //===--------------------------------------------------------------------===// // MultiFileListIterator //===--------------------------------------------------------------------===// -MultiFileListIterationHelper MultiFileList::Files() { +MultiFileListIterationHelper MultiFileList::Files() const { return MultiFileListIterationHelper(*this); } -MultiFileListIterationHelper::MultiFileListIterationHelper(MultiFileList &file_list_p) : file_list(file_list_p) { +MultiFileListIterationHelper::MultiFileListIterationHelper(const MultiFileList &file_list_p) : file_list(file_list_p) { } -MultiFileListIterationHelper::MultiFileListIterator::MultiFileListIterator(MultiFileList *file_list_p) +MultiFileListIterationHelper::MultiFileListIterator::MultiFileListIterator( + optional_ptr file_list_p) : file_list(file_list_p) { if (!file_list) { return; @@ -136,27 +136,41 @@ const OpenFileInfo &MultiFileListIterationHelper::MultiFileListIterator::operato //===--------------------------------------------------------------------===// // MultiFileList //===--------------------------------------------------------------------===// -MultiFileList::MultiFileList(vector paths, FileGlobInput glob_input_p) - : paths(std::move(paths)), glob_input(std::move(glob_input_p)) { +MultiFileList::MultiFileList() { } -MultiFileList::MultiFileList(vector paths, FileGlobOptions options) - : MultiFileList(std::move(paths), FileGlobInput(options)) { +MultiFileList::~MultiFileList() { } -MultiFileList::~MultiFileList() { +void MultiFileList::InitializeScan(MultiFileListScanData &iterator) const { + iterator.current_file_idx = 0; } -const vector MultiFileList::GetPaths() const { - return paths; +vector MultiFileList::GetDisplayFileList(optional_idx max_files) const { + vector files; + for (idx_t i = 0;; i++) { + if (max_files.IsValid() && files.size() >= max_files.GetIndex()) { + break; + } + auto file = GetFile(i); + if (file.path.empty()) { + break; + } + files.push_back(std::move(file)); + } + return files; } -void MultiFileList::InitializeScan(MultiFileListScanData &iterator) { - iterator.current_file_idx = 0; +MultiFileCount MultiFileList::GetFileCount(idx_t min_exact_count) const { + return MultiFileCount(GetTotalFileCount()); } -bool MultiFileList::Scan(MultiFileListScanData &iterator, OpenFileInfo &result_file) { +bool MultiFileList::Scan(MultiFileListScanData &iterator, OpenFileInfo &result_file) const { D_ASSERT(iterator.current_file_idx != DConstants::INVALID_INDEX); + if (iterator.scan_type == MultiFileListScanType::FETCH_IF_AVAILABLE && + !FileIsAvailable(iterator.current_file_idx)) { + return false; + } auto maybe_file = GetFile(iterator.current_file_idx); if (maybe_file.path.empty()) { @@ -171,8 +185,17 @@ bool MultiFileList::Scan(MultiFileListScanData &iterator, OpenFileInfo &result_f unique_ptr MultiFileList::ComplexFilterPushdown(ClientContext &context, const MultiFileOptions &options, MultiFilePushdownInfo &info, - vector> &filters) { - // By default the filter pushdown into a multifilelist does nothing + vector> &filters) const { + if (!options.hive_partitioning && !options.filename) { + return nullptr; + } + + // FIXME: don't copy list until first file is filtered + auto file_copy = GetAllFiles(); + auto res = PushdownInternal(context, options, info, filters, file_copy); + if (res) { + return make_uniq(std::move(file_copy)); + } return nullptr; } @@ -181,75 +204,51 @@ unique_ptr MultiFileList::DynamicFilterPushdown(ClientContext &co const vector &types, const vector &column_ids, TableFilterSet &filters) const { - // By default the filter pushdown into a multifilelist does nothing + if (!options.hive_partitioning && !options.filename) { + return nullptr; + } + + // FIXME: don't copy list until first file is filtered + auto file_copy = GetAllFiles(); + auto res = PushdownInternal(context, options, names, types, column_ids, filters, file_copy); + if (res) { + return make_uniq(std::move(file_copy)); + } + return nullptr; } -unique_ptr MultiFileList::GetCardinality(ClientContext &context) { +unique_ptr MultiFileList::GetCardinality(ClientContext &context) const { return nullptr; } -OpenFileInfo MultiFileList::GetFirstFile() { +OpenFileInfo MultiFileList::GetFirstFile() const { return GetFile(0); } -bool MultiFileList::IsEmpty() { +bool MultiFileList::IsEmpty() const { return GetExpandResult() == FileExpandResult::NO_FILES; } -unique_ptr MultiFileList::Copy() { +unique_ptr MultiFileList::Copy() const { return make_uniq(GetAllFiles()); } +bool MultiFileList::FileIsAvailable(idx_t i) const { + return true; +} + //===--------------------------------------------------------------------===// // SimpleMultiFileList //===--------------------------------------------------------------------===// -SimpleMultiFileList::SimpleMultiFileList(vector paths_p) - : MultiFileList(std::move(paths_p), FileGlobOptions::ALLOW_EMPTY) { -} - -unique_ptr SimpleMultiFileList::ComplexFilterPushdown(ClientContext &context_p, - const MultiFileOptions &options, - MultiFilePushdownInfo &info, - vector> &filters) { - if (!options.hive_partitioning && !options.filename) { - return nullptr; - } - - // FIXME: don't copy list until first file is filtered - auto file_copy = paths; - auto res = PushdownInternal(context_p, options, info, filters, file_copy); - - if (res) { - return make_uniq(file_copy); - } - - return nullptr; -} - -unique_ptr -SimpleMultiFileList::DynamicFilterPushdown(ClientContext &context, const MultiFileOptions &options, - const vector &names, const vector &types, - const vector &column_ids, TableFilterSet &filters) const { - if (!options.hive_partitioning && !options.filename) { - return nullptr; - } - - // FIXME: don't copy list until first file is filtered - auto file_copy = paths; - auto res = PushdownInternal(context, options, names, types, column_ids, filters, file_copy); - if (res) { - return make_uniq(file_copy); - } - - return nullptr; +SimpleMultiFileList::SimpleMultiFileList(vector paths_p) : paths(std::move(paths_p)) { } -vector SimpleMultiFileList::GetAllFiles() { +vector SimpleMultiFileList::GetAllFiles() const { return paths; } -FileExpandResult SimpleMultiFileList::GetExpandResult() { +FileExpandResult SimpleMultiFileList::GetExpandResult() const { if (paths.size() > 1) { return FileExpandResult::MULTIPLE_FILES; } else if (paths.size() == 1) { @@ -259,7 +258,7 @@ FileExpandResult SimpleMultiFileList::GetExpandResult() { return FileExpandResult::NO_FILES; } -OpenFileInfo SimpleMultiFileList::GetFile(idx_t i) { +OpenFileInfo SimpleMultiFileList::GetFile(idx_t i) const { if (paths.empty() || i >= paths.size()) { return OpenFileInfo(""); } @@ -267,99 +266,61 @@ OpenFileInfo SimpleMultiFileList::GetFile(idx_t i) { return paths[i]; } -idx_t SimpleMultiFileList::GetTotalFileCount() { +idx_t SimpleMultiFileList::GetTotalFileCount() const { return paths.size(); } //===--------------------------------------------------------------------===// -// GlobMultiFileList +// LazyFileList //===--------------------------------------------------------------------===// -GlobMultiFileList::GlobMultiFileList(ClientContext &context_p, vector paths_p, FileGlobInput glob_input) - : MultiFileList(std::move(paths_p), std::move(glob_input)), context(context_p), current_path(0) { +LazyMultiFileList::LazyMultiFileList(optional_ptr context_p) : context(context_p) { } -unique_ptr GlobMultiFileList::ComplexFilterPushdown(ClientContext &context_p, - const MultiFileOptions &options, - MultiFilePushdownInfo &info, - vector> &filters) { +vector LazyMultiFileList::GetAllFiles() const { lock_guard lck(lock); - - // Expand all - // FIXME: lazy expansion - // FIXME: push down filters into glob - while (ExpandNextPath()) { - } - - if (!options.hive_partitioning && !options.filename) { - return nullptr; - } - auto res = PushdownInternal(context, options, info, filters, expanded_files); - if (res) { - return make_uniq(expanded_files); + while (ExpandNextPathInternal()) { } - - return nullptr; -} - -unique_ptr -GlobMultiFileList::DynamicFilterPushdown(ClientContext &context, const MultiFileOptions &options, - const vector &names, const vector &types, - const vector &column_ids, TableFilterSet &filters) const { - if (!options.hive_partitioning && !options.filename) { - return nullptr; - } - lock_guard lck(lock); - - // Expand all paths into a copy - // FIXME: lazy expansion and push filters into glob - idx_t path_index = current_path; - auto file_list = expanded_files; - while (ExpandPathInternal(path_index, file_list)) { - } - - auto res = PushdownInternal(context, options, names, types, column_ids, filters, file_list); - if (res) { - return make_uniq(file_list); - } - - return nullptr; + return expanded_files; } -vector GlobMultiFileList::GetAllFiles() { +idx_t LazyMultiFileList::GetTotalFileCount() const { lock_guard lck(lock); - while (ExpandNextPath()) { + while (ExpandNextPathInternal()) { } - return expanded_files; + return expanded_files.size(); } -idx_t GlobMultiFileList::GetTotalFileCount() { +MultiFileCount LazyMultiFileList::GetFileCount(idx_t min_exact_count) const { lock_guard lck(lock); - while (ExpandNextPath()) { + // expand files so that we get to min_exact_count + while (!all_files_expanded && expanded_files.size() < min_exact_count && ExpandNextPathInternal()) { } - return expanded_files.size(); + auto type = all_files_expanded ? FileExpansionType::ALL_FILES_EXPANDED : FileExpansionType::NOT_ALL_FILES_KNOWN; + return MultiFileCount(expanded_files.size(), type); } -FileExpandResult GlobMultiFileList::GetExpandResult() { +FileExpandResult LazyMultiFileList::GetExpandResult() const { // GetFile(1) will ensure at least the first 2 files are expanded if they are available - GetFile(1); + (void)GetFile(1); + lock_guard lck(lock); if (expanded_files.size() > 1) { return FileExpandResult::MULTIPLE_FILES; } else if (expanded_files.size() == 1) { return FileExpandResult::SINGLE_FILE; } - return FileExpandResult::NO_FILES; } -OpenFileInfo GlobMultiFileList::GetFile(idx_t i) { +bool LazyMultiFileList::FileIsAvailable(idx_t i) const { lock_guard lck(lock); - return GetFileInternal(i); + return i < expanded_files.size(); } -OpenFileInfo GlobMultiFileList::GetFileInternal(idx_t i) { +OpenFileInfo LazyMultiFileList::GetFile(idx_t i) const { + lock_guard lck(lock); while (expanded_files.size() <= i) { - if (!ExpandNextPath()) { + if (!ExpandNextPathInternal()) { return OpenFileInfo(""); } } @@ -367,26 +328,76 @@ OpenFileInfo GlobMultiFileList::GetFileInternal(idx_t i) { return expanded_files[i]; } -bool GlobMultiFileList::ExpandPathInternal(idx_t ¤t_path, vector &result) const { - if (current_path >= paths.size()) { +bool LazyMultiFileList::ExpandNextPathInternal() const { + if (all_files_expanded) { + return false; + } + if (context && context->interrupted) { + throw InterruptException(); + } + if (!ExpandNextPath()) { + all_files_expanded = true; return false; } - - auto &fs = FileSystem::GetFileSystem(context); - auto glob_files = fs.GlobFiles(paths[current_path].path, context, glob_input); - std::sort(glob_files.begin(), glob_files.end()); - result.insert(result.end(), glob_files.begin(), glob_files.end()); - - current_path++; return true; } -bool GlobMultiFileList::ExpandNextPath() { - return ExpandPathInternal(current_path, expanded_files); +//===--------------------------------------------------------------------===// +// GlobMultiFileList +//===--------------------------------------------------------------------===// +GlobMultiFileList::GlobMultiFileList(ClientContext &context_p, vector globs_p, FileGlobInput glob_input_p) + : LazyMultiFileList(&context_p), context(context_p), globs(std::move(globs_p)), glob_input(std::move(glob_input_p)), + current_glob(0) { +} + +vector GlobMultiFileList::GetDisplayFileList(optional_idx max_files) const { + // for globs we display the actual globs in the ToString() - instead of expanding to the files read + vector result; + for (auto &glob : globs) { + if (max_files.IsValid() && result.size() >= max_files.GetIndex()) { + break; + } + result.emplace_back(glob); + } + return result; } -bool GlobMultiFileList::IsFullyExpanded() const { - return current_path == paths.size(); +bool GlobMultiFileList::ExpandNextPath() const { + if (current_glob >= globs.size()) { + return false; + } + if (current_glob >= file_lists.size()) { + // glob is not yet started for this file - start it and initiate the scan over this file + auto &fs = FileSystem::GetFileSystem(context); + auto glob_result = fs.GlobFileList(globs[current_glob], glob_input); + scan_state = MultiFileListScanData(); + glob_result->InitializeScan(scan_state); + file_lists.push_back(std::move(glob_result)); + } + // get the next batch of files we can fetch through the glob + auto &glob_list = *file_lists[current_glob]; + scan_state.scan_type = MultiFileListScanType::ALWAYS_FETCH; + OpenFileInfo file; + if (!glob_list.Scan(scan_state, file)) { + // no more files available in this glob - move to the next glob + current_glob++; + return true; + } + // we found a file as part of this glob - add it to the result + vector glob_files; + glob_files.push_back(std::move(file)); + + // now continue scanning files that are already available (i.e. that don't require extra I/O operations to fetch) + scan_state.scan_type = MultiFileListScanType::FETCH_IF_AVAILABLE; + while (glob_list.Scan(scan_state, file)) { + glob_files.push_back(std::move(file)); + } + + // sort the files and add them to the list of files + std::sort(glob_files.begin(), glob_files.end()); + expanded_files.insert(expanded_files.end(), glob_files.begin(), glob_files.end()); + + return true; } } // namespace duckdb diff --git a/src/duckdb/src/common/multi_file/multi_file_reader.cpp b/src/duckdb/src/common/multi_file/multi_file_reader.cpp index d69e4a187..b5a160694 100644 --- a/src/duckdb/src/common/multi_file/multi_file_reader.cpp +++ b/src/duckdb/src/common/multi_file/multi_file_reader.cpp @@ -118,11 +118,7 @@ vector MultiFileReader::ParsePaths(const Value &input) { shared_ptr MultiFileReader::CreateFileList(ClientContext &context, const vector &paths, const FileGlobInput &glob_input) { - vector open_files; - for (auto &path : paths) { - open_files.emplace_back(path); - } - auto res = make_uniq(context, std::move(open_files), glob_input); + auto res = make_uniq(context, paths, glob_input); if (res->GetExpandResult() == FileExpandResult::NO_FILES && glob_input.behavior != FileGlobOptions::ALLOW_EMPTY) { throw IOException("%s needs at least one file to read", function_name); } diff --git a/src/duckdb/src/common/operator/cast_operators.cpp b/src/duckdb/src/common/operator/cast_operators.cpp index 5998d7787..233bcf619 100644 --- a/src/duckdb/src/common/operator/cast_operators.cpp +++ b/src/duckdb/src/common/operator/cast_operators.cpp @@ -26,6 +26,8 @@ #include "duckdb/common/operator/integer_cast_operator.hpp" #include "duckdb/common/operator/double_cast_operator.hpp" #include "duckdb/planner/expression.hpp" +#include "duckdb/common/serializer/binary_deserializer.hpp" +#include "duckdb/common/serializer/memory_stream.hpp" #include #include @@ -1424,6 +1426,22 @@ string_t CastFromPointer::Operation(uintptr_t input, Vector &vector) { return StringVector::AddString(vector, s); } +//===--------------------------------------------------------------------===// +// Cast From Pointer +//===--------------------------------------------------------------------===// +template <> +string_t CastFromType::Operation(string_t input, Vector &vector) { + MemoryStream stream(data_ptr_cast(input.GetDataWriteable()), input.GetSize()); + BinaryDeserializer deserializer(stream); + try { + auto type = LogicalType::Deserialize(deserializer); + return StringVector::AddString(vector, type.ToString()); + } catch (std::exception &ex) { + // TODO: Format better error here? + return StringVector::AddString(vector, ex.what()); + } +} + //===--------------------------------------------------------------------===// // Cast To Blob //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/common/string_util.cpp b/src/duckdb/src/common/string_util.cpp index 682a94392..9c8cf8295 100644 --- a/src/duckdb/src/common/string_util.cpp +++ b/src/duckdb/src/common/string_util.cpp @@ -77,6 +77,14 @@ idx_t StringUtil::ToUnsigned(const string &str) { return std::stoull(str); } +int64_t StringUtil::ToSigned(const string &str) { + return std::stoll(str); +} + +double StringUtil::ToDouble(const string &str) { + return std::stod(str); +} + void StringUtil::LTrim(string &str) { auto it = str.begin(); while (it != str.end() && CharacterIsSpace(*it)) { diff --git a/src/duckdb/src/common/types.cpp b/src/duckdb/src/common/types.cpp index 83374d0de..2819f7a35 100644 --- a/src/duckdb/src/common/types.cpp +++ b/src/duckdb/src/common/types.cpp @@ -17,15 +17,16 @@ #include "duckdb/common/types/vector.hpp" #include "duckdb/common/uhugeint.hpp" #include "duckdb/function/cast_rules.hpp" -#include "duckdb/main/attached_database.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/main/client_data.hpp" -#include "duckdb/main/config.hpp" -#include "duckdb/main/database.hpp" -#include "duckdb/main/database_manager.hpp" +#include "duckdb/common/types/type_manager.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/parser/keyword_helper.hpp" #include "duckdb/parser/parser.hpp" #include "duckdb/main/settings.hpp" +#include "duckdb/parser/expression/type_expression.hpp" +#include "duckdb/common/serializer/serializer.hpp" +#include "duckdb/common/serializer/deserializer.hpp" #include @@ -119,6 +120,7 @@ PhysicalType LogicalType::GetInternalType() { case LogicalTypeId::CHAR: case LogicalTypeId::BLOB: case LogicalTypeId::BIT: + case LogicalTypeId::TYPE: return PhysicalType::VARCHAR; case LogicalTypeId::INTERVAL: return PhysicalType::INTERVAL; @@ -158,7 +160,7 @@ PhysicalType LogicalType::GetInternalType() { case LogicalTypeId::INTEGER_LITERAL: case LogicalTypeId::TEMPLATE: return PhysicalType::INVALID; - case LogicalTypeId::USER: + case LogicalTypeId::UNBOUND: return PhysicalType::UNKNOWN; case LogicalTypeId::AGGREGATE_STATE: return PhysicalType::VARCHAR; @@ -387,7 +389,7 @@ static string TypeModifierListToString(const vector &mod_li } string LogicalType::ToString() const { - if (id_ != LogicalTypeId::USER) { + if (id_ != LogicalTypeId::UNBOUND) { auto alias = GetAlias(); if (!alias.empty()) { if (HasExtensionInfo()) { @@ -482,39 +484,17 @@ string LogicalType::ToString() const { ret += ")"; return ret; } - case LogicalTypeId::USER: { - string result; - auto &catalog = UserType::GetCatalog(*this); - auto &schema = UserType::GetSchema(*this); - auto &type = UserType::GetTypeName(*this); - auto &mods = UserType::GetTypeModifiers(*this); - - if (!catalog.empty()) { - result = KeywordHelper::WriteOptionallyQuoted(catalog); - } - if (!schema.empty()) { - if (!result.empty()) { - result += "."; - } - result += KeywordHelper::WriteOptionallyQuoted(schema); - } - if (!result.empty()) { - result += "."; - } - result += KeywordHelper::WriteOptionallyQuoted(type); - - if (!mods.empty()) { - result += "("; - for (idx_t i = 0; i < mods.size(); i++) { - result += mods[i].ToString(); - if (i < mods.size() - 1) { - result += ", "; - } - } - result += ")"; + case LogicalTypeId::UNBOUND: { + if (!type_info_) { + return "UNBOUND"; } - return result; + auto &expr = UnboundType::GetTypeExpression(*this); + if (expr->type != ExpressionType::TYPE) { + return "(" + expr->ToString() + ")"; + } else { + return expr->ToString(); + } } case LogicalTypeId::AGGREGATE_STATE: { return AggregateStateType::GetTypeName(*this); @@ -547,110 +527,13 @@ LogicalTypeId TransformStringToLogicalTypeId(const string &str) { if (type == LogicalTypeId::INVALID) { // This is a User Type, at this point we don't know if its one of the User Defined Types or an error // It is checked in the binder - type = LogicalTypeId::USER; + type = LogicalTypeId::UNBOUND; } return type; } -LogicalType TransformStringToLogicalType(const string &str) { - if (StringUtil::Lower(str) == "null") { - return LogicalType::SQLNULL; - } - ColumnList column_list; - try { - column_list = Parser::ParseColumnList("dummy " + str); - } catch (const std::runtime_error &e) { - const vector suggested_types {"BIGINT", - "INT8", - "LONG", - "BIT", - "BITSTRING", - "BLOB", - "BYTEA", - "BINARY,", - "VARBINARY", - "BOOLEAN", - "BOOL", - "LOGICAL", - "DATE", - "DECIMAL(prec, scale)", - "DOUBLE", - "FLOAT8", - "FLOAT", - "FLOAT4", - "REAL", - "HUGEINT", - "INTEGER", - "INT4", - "INT", - "SIGNED", - "INTERVAL", - "SMALLINT", - "INT2", - "SHORT", - "TIME", - "TIMESTAMPTZ", - "TIMESTAMP", - "DATETIME", - "TINYINT", - "INT1", - "UBIGINT", - "UHUGEINT", - "UINTEGER", - "USMALLINT", - "UTINYINT", - "UUID", - "VARCHAR", - "CHAR", - "BPCHAR", - "TEXT", - "STRING", - "MAP(INTEGER, VARCHAR)", - "UNION(num INTEGER, text VARCHAR)"}; - std::ostringstream error; - error << "Value \"" << str << "\" can not be converted to a DuckDB Type." << '\n'; - error << "Possible examples as suggestions: " << '\n'; - auto suggestions = StringUtil::TopNJaroWinkler(suggested_types, str); - for (auto &suggestion : suggestions) { - error << "* " << suggestion << '\n'; - } - throw InvalidInputException(error.str()); - } - return column_list.GetColumn(LogicalIndex(0)).Type(); -} - -LogicalType GetUserTypeRecursive(const LogicalType &type, ClientContext &context) { - if (type.id() == LogicalTypeId::USER && type.HasAlias()) { - auto &type_entry = - Catalog::GetEntry(context, INVALID_CATALOG, INVALID_SCHEMA, type.GetAlias()); - return type_entry.user_type; - } - // Look for LogicalTypeId::USER in nested types - if (type.id() == LogicalTypeId::STRUCT) { - child_list_t children; - children.reserve(StructType::GetChildCount(type)); - for (auto &child : StructType::GetChildTypes(type)) { - children.emplace_back(child.first, GetUserTypeRecursive(child.second, context)); - } - return LogicalType::STRUCT(children); - } - if (type.id() == LogicalTypeId::LIST) { - return LogicalType::LIST(GetUserTypeRecursive(ListType::GetChildType(type), context)); - } - if (type.id() == LogicalTypeId::ARRAY) { - return LogicalType::ARRAY(GetUserTypeRecursive(ArrayType::GetChildType(type), context), - ArrayType::GetSize(type)); - } - if (type.id() == LogicalTypeId::MAP) { - return LogicalType::MAP(GetUserTypeRecursive(MapType::KeyType(type), context), - GetUserTypeRecursive(MapType::ValueType(type), context)); - } - // Not LogicalTypeId::USER or a nested type - return type; -} - LogicalType TransformStringToLogicalType(const string &str, ClientContext &context) { - return GetUserTypeRecursive(TransformStringToLogicalType(str), context); + return TypeManager::Get(context).ParseLogicalType(str, context); } bool LogicalType::IsIntegral() const { @@ -1278,10 +1161,15 @@ struct ForceGetTypeOperation { bool LogicalType::TryGetMaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right, LogicalType &result) { - if (DBConfig::GetSetting(context)) { + if (Settings::Get(context)) { result = LogicalType::ForceMaxLogicalType(left, right); return true; } + return TryGetMaxLogicalTypeUnchecked(left, right, result); +} + +bool LogicalType::TryGetMaxLogicalTypeUnchecked(const LogicalType &left, const LogicalType &right, + LogicalType &result) { return TryGetMaxLogicalTypeInternal(left, right, result); } @@ -1378,7 +1266,8 @@ static idx_t GetLogicalTypeScore(const LogicalType &type) { case LogicalTypeId::AGGREGATE_STATE: case LogicalTypeId::POINTER: case LogicalTypeId::VALIDITY: - case LogicalTypeId::USER: + case LogicalTypeId::UNBOUND: + case LogicalTypeId::TYPE: break; } return 1000; @@ -1469,6 +1358,33 @@ bool ApproxEqual(double ldecimal, double rdecimal) { return std::fabs(ldecimal - rdecimal) <= epsilon; } +void LogicalType::Serialize(Serializer &serializer) const { + // This is a UNBOUND type and we are writing to older storage. + // 1. try to default-bind into a concrete logical type, and serialize that + // 2. if that fails, serialize normally, in which case the UNBOUND_TYPE_INFO will try to + // write itself as an old-style USER type. + if (id_ == LogicalTypeId::UNBOUND && !serializer.ShouldSerialize(7)) { + try { + auto bound_type = UnboundType::TryDefaultBind(*this); + if (bound_type.id() != LogicalTypeId::INVALID && bound_type.id() != LogicalTypeId::UNBOUND) { + bound_type.Serialize(serializer); + return; + } + } catch (...) { + // Ignore errors, just try to write as a USER type instead + } + } + serializer.WriteProperty(100, "id", id_); + serializer.WritePropertyWithDefault>(101, "type_info", type_info_); +} + +LogicalType LogicalType::Deserialize(Deserializer &deserializer) { + auto id = deserializer.ReadProperty(100, "id"); + auto type_info = deserializer.ReadPropertyWithDefault>(101, "type_info"); + LogicalType result(id, std::move(type_info)); + return result; +} + //===--------------------------------------------------------------------===// // Extra Type Info //===--------------------------------------------------------------------===// @@ -1499,9 +1415,6 @@ void LogicalType::SetAlias(string alias) { } string LogicalType::GetAlias() const { - if (id() == LogicalTypeId::USER) { - return UserType::GetTypeName(*this); - } if (type_info_) { return type_info_->alias; } @@ -1509,9 +1422,6 @@ string LogicalType::GetAlias() const { } bool LogicalType::HasAlias() const { - if (id() == LogicalTypeId::USER) { - return !UserType::GetTypeName(*this).empty(); - } if (type_info_ && !type_info_->alias.empty()) { return true; } @@ -1767,52 +1677,18 @@ const child_list_t UnionType::CopyMemberTypes(const LogicalType &ty } //===--------------------------------------------------------------------===// -// User Type +// Unbound Type //===--------------------------------------------------------------------===// -const string &UserType::GetCatalog(const LogicalType &type) { - D_ASSERT(type.id() == LogicalTypeId::USER); - auto info = type.AuxInfo(); - return info->Cast().catalog; -} - -const string &UserType::GetSchema(const LogicalType &type) { - D_ASSERT(type.id() == LogicalTypeId::USER); - auto info = type.AuxInfo(); - return info->Cast().schema; +LogicalType LogicalType::UNBOUND(unique_ptr expr) { + auto info = make_shared_ptr(std::move(expr)); + return LogicalType(LogicalTypeId::UNBOUND, std::move(info)); } -const string &UserType::GetTypeName(const LogicalType &type) { - D_ASSERT(type.id() == LogicalTypeId::USER); - auto info = type.AuxInfo(); - return info->Cast().user_type_name; -} - -const vector &UserType::GetTypeModifiers(const LogicalType &type) { - D_ASSERT(type.id() == LogicalTypeId::USER); - auto info = type.AuxInfo(); - return info->Cast().user_type_modifiers; -} - -vector &UserType::GetTypeModifiers(LogicalType &type) { - D_ASSERT(type.id() == LogicalTypeId::USER); - auto info = type.GetAuxInfoShrPtr(); - return info->Cast().user_type_modifiers; -} - -LogicalType LogicalType::USER(const string &user_type_name) { - auto info = make_shared_ptr(user_type_name); - return LogicalType(LogicalTypeId::USER, std::move(info)); -} - -LogicalType LogicalType::USER(const string &user_type_name, const vector &user_type_mods) { - auto info = make_shared_ptr(user_type_name, user_type_mods); - return LogicalType(LogicalTypeId::USER, std::move(info)); -} - -LogicalType LogicalType::USER(string catalog, string schema, string name, vector user_type_mods) { - auto info = make_shared_ptr(std::move(catalog), std::move(schema), std::move(name), - std::move(user_type_mods)); - return LogicalType(LogicalTypeId::USER, std::move(info)); +//===--------------------------------------------------------------------===// +// Type Type +//===--------------------------------------------------------------------===// +LogicalType LogicalType::TYPE() { + return LogicalType(LogicalTypeId::TYPE); } //===--------------------------------------------------------------------===// @@ -2079,6 +1955,77 @@ const CoordinateReferenceSystem &GeoType::GetCRS(const LogicalType &type) { return geo_info.crs; } +//===--------------------------------------------------------------------===// +// Unbound Types +//===--------------------------------------------------------------------===// + +const unique_ptr &UnboundType::GetTypeExpression(const LogicalType &type) { + D_ASSERT(type.id() == LogicalTypeId::UNBOUND); + auto info = type.AuxInfo(); + D_ASSERT(info->type == ExtraTypeInfoType::UNBOUND_TYPE_INFO); + return info->Cast().expr; +} + +LogicalType UnboundType::TryParseAndDefaultBind(const string &type_str) { + if (type_str.empty()) { + return LogicalType::INVALID; + } + try { + ColumnList list = Parser::ParseColumnList("dummy " + type_str); + auto unbound = list.GetColumn(LogicalIndex(0)).Type(); + return TryDefaultBind(unbound); + } catch (const std::runtime_error &e) { + throw InvalidInputException("Could not parse type string '%s'", type_str); + } +} + +static LogicalType TryDefaultBindTypeExpression(const ParsedExpression &expr) { + if (expr.type != ExpressionType::TYPE) { + throw InvalidInputException("Cannot default bind unbound type with non-type expression"); + } + const auto &type_expr = expr.Cast(); + + // Now we try to bind the unbound type to a default type + auto &name = type_expr.GetTypeName(); + auto &args = type_expr.GetChildren(); + + vector> bound_args; + for (auto &arg : args) { + switch (arg->GetExpressionType()) { + case ExpressionType::TYPE: { + auto type = TryDefaultBindTypeExpression(*arg); + bound_args.emplace_back(arg->GetName(), Value::TYPE(type)); + } break; + case ExpressionType::VALUE_CONSTANT: { + auto &const_expr = arg->Cast(); + bound_args.emplace_back(arg->GetName(), const_expr.value); + } break; + default: + throw InvalidInputException("Cannot default bind unbound type with non-type, non-expression parameter"); + break; + } + } + + // Try to bind as far as we can + auto result = DefaultTypeGenerator::TryDefaultBind(name, bound_args); + if (result.id() != LogicalTypeId::INVALID) { + return result; + } + + // Otherwise, wrap this as an unbound type + auto copy = expr.Copy(); + return LogicalType::UNBOUND(std::move(copy)); + // return LogicalType::INVALID; +} + +LogicalType UnboundType::TryDefaultBind(const LogicalType &unbound_type) { + if (!unbound_type.IsUnbound()) { + return unbound_type; + } + auto &expr = UnboundType::GetTypeExpression(unbound_type); + return TryDefaultBindTypeExpression(*expr); +} + //===--------------------------------------------------------------------===// // Logical Type //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/common/types/geometry.cpp b/src/duckdb/src/common/types/geometry.cpp index cc9bacfda..52c17c405 100644 --- a/src/duckdb/src/common/types/geometry.cpp +++ b/src/duckdb/src/common/types/geometry.cpp @@ -929,7 +929,6 @@ void ConvertWKB(BlobReader &reader, FixedSizeBlobWriter &writer) { // Public interface //---------------------------------------------------------------------------------------------------------------------- namespace duckdb { - constexpr const idx_t Geometry::MAX_RECURSION_DEPTH; bool Geometry::FromBinary(const string_t &wkb, string_t &result, Vector &result_vector, bool strict) { @@ -1083,6 +1082,11 @@ static uint32_t ParseVertices(BlobReader &reader, GeometryExtent &extent, uint32 } uint32_t Geometry::GetExtent(const string_t &wkb, GeometryExtent &extent) { + bool has_any_empty = false; + return GetExtent(wkb, extent, has_any_empty); +} + +uint32_t Geometry::GetExtent(const string_t &wkb, GeometryExtent &extent, bool &has_any_empty) { BlobReader reader(wkb.GetData(), static_cast(wkb.GetSize())); uint32_t vertex_count = 0; @@ -1106,16 +1110,33 @@ uint32_t Geometry::GetExtent(const string_t &wkb, GeometryExtent &extent) { switch (geom_type) { case GeometryType::POINT: { - vertex_count += ParseVertices(reader, extent, 1, vert_type, true); + const auto parsed_count = ParseVertices(reader, extent, 1, vert_type, true); + if (parsed_count == 0) { + has_any_empty = true; + continue; + } + vertex_count += parsed_count; } break; case GeometryType::LINESTRING: { const auto vert_count = reader.Read(); + if (vert_count == 0) { + has_any_empty = true; + continue; + } vertex_count += ParseVertices(reader, extent, vert_count, vert_type, false); } break; case GeometryType::POLYGON: { const auto ring_count = reader.Read(); + if (ring_count == 0) { + has_any_empty = true; + continue; + } for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { const auto vert_count = reader.Read(); + if (vert_count == 0) { + has_any_empty = true; + continue; + } vertex_count += ParseVertices(reader, extent, vert_count, vert_type, false); } } break; @@ -1123,8 +1144,10 @@ uint32_t Geometry::GetExtent(const string_t &wkb, GeometryExtent &extent) { case GeometryType::MULTILINESTRING: case GeometryType::MULTIPOLYGON: case GeometryType::GEOMETRYCOLLECTION: { - // Skip count. We don't need it for extent calculation. - reader.Skip(sizeof(uint32_t)); + const auto part_count = reader.Read(); + if (part_count == 0) { + has_any_empty = true; + } } break; default: throw InvalidInputException("Unsupported geometry type %d in WKB", static_cast(geom_type)); @@ -1133,4 +1156,1039 @@ uint32_t Geometry::GetExtent(const string_t &wkb, GeometryExtent &extent) { return vertex_count; } +//---------------------------------------------------------------------------------------------------------------------- +// Shredding +//---------------------------------------------------------------------------------------------------------------------- + +template +static void ToPoints(Vector &source_vec, Vector &target_vec, idx_t row_count) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + const auto geom_data = FlatVector::GetData(source_vec); + const auto &vert_parts = StructVector::GetEntries(target_vec); + double *vert_data[V::WIDTH]; + + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, row_idx, true); + continue; + } + + const auto &blob = geom_data[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + vert_data[dim_idx][row_idx] = reader.Read(); + } + } +} + +template +static void FromPoints(Vector &source_vec, Vector &target_vec, idx_t row_count, idx_t result_offset) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + const auto &vert_parts = StructVector::GetEntries(source_vec); + const auto geom_data = FlatVector::GetData(target_vec); + double *vert_data[V::WIDTH]; + + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + const auto out_idx = result_offset + row_idx; + + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, out_idx, true); + continue; + } + + // byte order + type/meta + vertex data + const auto blob_size = sizeof(uint8_t) + sizeof(uint32_t) + sizeof(V); + auto blob = StringVector::EmptyString(target_vec, blob_size); + const auto blob_data = blob.GetDataWriteable(); + + FixedSizeBlobWriter writer(blob_data, static_cast(blob_size)); + + const auto meta = static_cast(GeometryType::POINT) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + + writer.Write(1); // Little-endian + writer.Write(meta); // Type/meta + + // Write vertex data + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + writer.Write(vert_data[dim_idx][row_idx]); + } + + blob.Finalize(); + geom_data[out_idx] = blob; + } +} + +template +static void ToLineStrings(Vector &source_vec, Vector &target_vec, idx_t row_count) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + idx_t vert_total = 0; + idx_t vert_start = 0; + + // First pass, figure out how many vertices are in this linestring + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, row_idx, true); + continue; + } + + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + const auto vert_count = reader.Read(); + + vert_total += vert_count; + } + + ListVector::Reserve(target_vec, vert_total); + ListVector::SetListSize(target_vec, vert_total); + + auto list_data = ListVector::GetData(target_vec); + auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(target_vec)); + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + // Second pass, write out the linestrings + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + continue; + } + + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + const auto vert_count = reader.Read(); + + // Set list entry + auto &list_entry = list_data[row_idx]; + list_entry.offset = vert_start; + list_entry.length = vert_count; + + // Read vertices + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + vert_data[dim_idx][vert_start + vert_idx] = reader.Read(); + } + } + + vert_start += vert_count; + } + + D_ASSERT(vert_start == vert_total); +} + +template +static void FromLineStrings(Vector &source_vec, Vector &target_vec, idx_t row_count, idx_t result_offset) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + const auto line_data = ListVector::GetData(source_vec); + const auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(source_vec)); + + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + const auto out_idx = result_offset + row_idx; + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, out_idx, true); + continue; + } + + const auto &line_entry = line_data[row_idx]; + const auto vert_count = line_entry.length; + + // byte order + type/meta + vertex data + const auto blob_size = sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t) + vert_count * sizeof(V); + auto blob = StringVector::EmptyString(target_vec, blob_size); + const auto blob_data = blob.GetDataWriteable(); + + FixedSizeBlobWriter writer(blob_data, static_cast(blob_size)); + + const auto meta = + static_cast(GeometryType::LINESTRING) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + + writer.Write(1); // Little-endian + writer.Write(meta); // Type/meta + writer.Write(UnsafeNumericCast(vert_count)); // Vertex count + + // Write vertex data + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + writer.Write(vert_data[dim_idx][line_entry.offset + vert_idx]); + } + } + + blob.Finalize(); + FlatVector::GetData(target_vec)[out_idx] = blob; + } +} + +template +static void ToPolygons(Vector &source_vec, Vector &target_vec, idx_t row_count) { + source_vec.Flatten(row_count); + + idx_t vert_total = 0; + idx_t ring_total = 0; + idx_t vert_start = 0; + idx_t ring_start = 0; + + // First pass, figure out how many vertices and rings are in this polygon + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, row_idx, true); + continue; + } + + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + const auto ring_count = reader.Read(); + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + const auto vert_count = reader.Read(); + + // Skip vertices + reader.Skip(sizeof(V) * vert_count); + + vert_total += vert_count; + } + ring_total += ring_count; + } + + // Reserve space in the target vector + ListVector::Reserve(target_vec, ring_total); + ListVector::SetListSize(target_vec, ring_total); + + auto &ring_vec = ListVector::GetEntry(target_vec); + ListVector::Reserve(ring_vec, vert_total); + ListVector::SetListSize(ring_vec, vert_total); + + const auto poly_data = ListVector::GetData(target_vec); + const auto ring_data = ListVector::GetData(ring_vec); + auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(ring_vec)); + double *vert_data[V::WIDTH]; + + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + continue; + } + + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + const auto ring_count = reader.Read(); + // Set polygon entry + auto &poly_entry = poly_data[row_idx]; + poly_entry.offset = ring_start; + poly_entry.length = ring_count; + + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + const auto vert_count = reader.Read(); + + // Set ring entry + auto &ring_entry = ring_data[ring_start + ring_idx]; + ring_entry.offset = vert_start; + ring_entry.length = vert_count; + + // Read vertices + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + vert_data[dim_idx][vert_start + vert_idx] = reader.Read(); + } + } + + vert_start += vert_count; + } + + ring_start += ring_count; + } + + D_ASSERT(vert_start == vert_total); + D_ASSERT(ring_start == ring_total); +} + +template +static void FromPolygons(Vector &source_vec, Vector &target_vec, idx_t row_count, idx_t result_offset) { + source_vec.Flatten(row_count); + + const auto poly_data = ListVector::GetData(source_vec); + const auto &ring_vec = ListVector::GetEntry(source_vec); + const auto ring_data = ListVector::GetData(ring_vec); + const auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(ring_vec)); + + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + const auto out_idx = result_offset + row_idx; + + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, out_idx, true); + continue; + } + + const auto &poly_entry = poly_data[row_idx]; + const auto ring_count = poly_entry.length; + + // First, compute total size + idx_t blob_size = sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t); // byte order + type/meta + ring count + + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + const auto &ring_entry = ring_data[poly_entry.offset + ring_idx]; + const auto vert_count = ring_entry.length; + // vertex count + blob_size += sizeof(uint32_t); + // vertex data + blob_size += vert_count * sizeof(V); + } + + auto blob = StringVector::EmptyString(target_vec, blob_size); + const auto blob_data = blob.GetDataWriteable(); + + FixedSizeBlobWriter writer(blob_data, static_cast(blob_size)); + + const auto meta = static_cast(GeometryType::POLYGON) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + + writer.Write(1); // Little-endian + writer.Write(meta); // Type/meta + writer.Write(UnsafeNumericCast(ring_count)); // Ring count + + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + const auto &ring_entry = ring_data[poly_entry.offset + ring_idx]; + const auto vert_count = ring_entry.length; + + writer.Write(UnsafeNumericCast(vert_count)); // Vertex count + + // Write vertex data + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + writer.Write(vert_data[dim_idx][ring_entry.offset + vert_idx]); + } + } + } + + blob.Finalize(); + FlatVector::GetData(target_vec)[out_idx] = blob; + } +} + +template +static void ToMultiPoints(Vector &source_vec, Vector &target_vec, idx_t row_count) { + source_vec.Flatten(row_count); + + const auto geom_data = FlatVector::GetData(source_vec); + + idx_t vert_total = 0; + idx_t vert_start = 0; + + // First pass, figure out how many vertices are in this multipoint + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, row_idx, true); + continue; + } + const auto &blob = geom_data[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + const auto part_count = reader.Read(); + vert_total += part_count; + } + + // Reserve space in the target vector + ListVector::Reserve(target_vec, vert_total); + ListVector::SetListSize(target_vec, vert_total); + + auto mult_data = ListVector::GetData(target_vec); + auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(target_vec)); + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + // Second pass, write out the multipoints + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + continue; + } + + const auto &blob = geom_data[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + const auto part_count = reader.Read(); + + // Set multipoint entry + auto &mult_entry = mult_data[row_idx]; + mult_entry.offset = vert_start; + mult_entry.length = part_count; + + for (uint32_t part_idx = 0; part_idx < part_count; part_idx++) { + // Skip byte order and type/meta of the point + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + vert_data[dim_idx][vert_start + part_idx] = reader.Read(); + } + } + + vert_start += part_count; + } + + D_ASSERT(vert_start == vert_total); +} + +template +static void FromMultiPoints(Vector &source_vec, Vector &target_vec, idx_t row_count, idx_t result_offset) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + const auto mult_data = ListVector::GetData(source_vec); + const auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(source_vec)); + + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + const auto out_idx = result_offset + row_idx; + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, out_idx, true); + continue; + } + + const auto &mult_entry = mult_data[row_idx]; + const auto part_count = mult_entry.length; + + // First, compute total size + // byte order + type/meta + part count + idx_t blob_size = sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t); + + for (uint32_t part_idx = 0; part_idx < part_count; part_idx++) { + // point byte order + type/meta + vertex data + blob_size += sizeof(uint8_t) + sizeof(uint32_t) + sizeof(V); + } + + auto blob = StringVector::EmptyString(target_vec, blob_size); + const auto blob_data = blob.GetDataWriteable(); + + FixedSizeBlobWriter writer(blob_data, static_cast(blob_size)); + + const auto meta = + static_cast(GeometryType::MULTIPOINT) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + + writer.Write(1); // Little-endian + writer.Write(meta); // Type/meta + writer.Write(UnsafeNumericCast(part_count)); // Part count + + for (uint32_t part_idx = 0; part_idx < part_count; part_idx++) { + // Write point byte order and type/meta + const auto point_meta = + static_cast(GeometryType::POINT) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + writer.Write(1); // Little-endian + writer.Write(point_meta); // Type/meta + + // Write vertex data + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + writer.Write(vert_data[dim_idx][mult_entry.offset + part_idx]); + } + } + + blob.Finalize(); + FlatVector::GetData(target_vec)[out_idx] = blob; + } +} + +template +static void ToMultiLineStrings(Vector &source_vec, Vector &target_vec, idx_t row_count) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + // This is basically the same as Polygons + + idx_t vert_total = 0; + idx_t line_total = 0; + idx_t vert_start = 0; + idx_t line_start = 0; + + // First pass, figure out how many vertices and lines are in this multilinestring + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, row_idx, true); + continue; + } + + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + // Line count + const auto line_count = reader.Read(); + for (uint32_t line_idx = 0; line_idx < line_count; line_idx++) { + // Skip line metadata + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + // Read vertex count + const auto vert_count = reader.Read(); + // Skip vertices + reader.Skip(sizeof(V) * vert_count); + + vert_total += vert_count; + } + line_total += line_count; + } + + // Reserve space in the target vector + ListVector::Reserve(target_vec, line_total); + ListVector::SetListSize(target_vec, line_total); + + auto &line_vec = ListVector::GetEntry(target_vec); + ListVector::Reserve(line_vec, vert_total); + ListVector::SetListSize(line_vec, vert_total); + + const auto mult_data = ListVector::GetData(target_vec); + const auto line_data = ListVector::GetData(line_vec); + auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(line_vec)); + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + // Second pass, write out the multilinestrings + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + continue; + } + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + const auto line_count = reader.Read(); + + // Set multilinestring entry + auto &mult_entry = mult_data[row_idx]; + mult_entry.offset = line_start; + mult_entry.length = line_count; + + for (uint32_t line_idx = 0; line_idx < line_count; line_idx++) { + // Skip line byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + // Read vertex count + const auto vert_count = reader.Read(); + + // Set line entry + auto &line_entry = line_data[line_start + line_idx]; + line_entry.offset = vert_start; + line_entry.length = vert_count; + + // Read vertices + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + vert_data[dim_idx][vert_start + vert_idx] = reader.Read(); + } + } + + vert_start += vert_count; + } + line_start += line_count; + } + + D_ASSERT(vert_start == vert_total); + D_ASSERT(line_start == line_total); +} + +template +static void FromMultiLineStrings(Vector &source_vec, Vector &target_vec, idx_t row_count, idx_t result_offset) { + // Flatten the source vector to extract all vertices + + source_vec.Flatten(row_count); + + const auto mult_data = ListVector::GetData(source_vec); + const auto line_vec = ListVector::GetEntry(source_vec); + const auto line_data = ListVector::GetData(line_vec); + const auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(line_vec)); + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + const auto out_idx = result_offset + row_idx; + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, out_idx, true); + continue; + } + + const auto &mult_entry = mult_data[row_idx]; + const auto line_count = mult_entry.length; + + // First, compute total size + // byte order + type/meta + line count + idx_t blob_size = sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t); + + for (uint32_t line_idx = 0; line_idx < line_count; line_idx++) { + const auto &line_entry = line_data[mult_entry.offset + line_idx]; + const auto vert_count = line_entry.length; + // line byte order + type/meta + vertex count + blob_size += sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t); + // vertex data + blob_size += vert_count * sizeof(V); + } + + auto blob = StringVector::EmptyString(target_vec, blob_size); + const auto blob_data = blob.GetDataWriteable(); + + FixedSizeBlobWriter writer(blob_data, static_cast(blob_size)); + + const auto meta = + static_cast(GeometryType::MULTILINESTRING) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + + writer.Write(1); // Little-endian + writer.Write(meta); // Type/meta + writer.Write(UnsafeNumericCast(line_count)); // Line count + + for (uint32_t line_idx = 0; line_idx < line_count; line_idx++) { + const auto &line_entry = line_data[mult_entry.offset + line_idx]; + const auto vert_count = line_entry.length; + + // Write line byte order and type/meta + const auto line_meta = + static_cast(GeometryType::LINESTRING) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + writer.Write(1); // Little-endian + writer.Write(line_meta); // Type/meta + writer.Write(UnsafeNumericCast(vert_count)); // Vertex count + + // Write vertex data + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + writer.Write(vert_data[dim_idx][line_entry.offset + vert_idx]); + } + } + } + blob.Finalize(); + FlatVector::GetData(target_vec)[out_idx] = blob; + } +} + +template +static void ToMultiPolygons(Vector &source_vec, Vector &target_vec, idx_t row_count) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + idx_t vert_total = 0; + idx_t ring_total = 0; + idx_t poly_total = 0; + idx_t vert_start = 0; + idx_t ring_start = 0; + idx_t poly_start = 0; + + // First pass, figure out how many vertices, rings and polygons are in this multipolygon + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, row_idx, true); + continue; + } + + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + const auto poly_count = reader.Read(); + for (uint32_t poly_idx = 0; poly_idx < poly_count; poly_idx++) { + // Skip polygon byte order and metadata + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + // Read ring count + const auto ring_count = reader.Read(); + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + // Read vertex count + const auto vert_count = reader.Read(); + // Skip vertices + reader.Skip(sizeof(V) * vert_count); + + vert_total += vert_count; + } + ring_total += ring_count; + } + poly_total += poly_count; + } + + // Reserve space in the target vector + ListVector::Reserve(target_vec, poly_total); + ListVector::SetListSize(target_vec, poly_total); + auto &poly_vec = ListVector::GetEntry(target_vec); + ListVector::Reserve(poly_vec, ring_total); + ListVector::SetListSize(poly_vec, ring_total); + auto &ring_vec = ListVector::GetEntry(poly_vec); + ListVector::Reserve(ring_vec, vert_total); + ListVector::SetListSize(ring_vec, vert_total); + + const auto mult_data = ListVector::GetData(target_vec); + const auto poly_data = ListVector::GetData(poly_vec); + const auto ring_data = ListVector::GetData(ring_vec); + auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(ring_vec)); + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + // Second pass, write out the multipolygons + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + if (FlatVector::IsNull(source_vec, row_idx)) { + continue; + } + const auto &blob = FlatVector::GetData(source_vec)[row_idx]; + const auto blob_data = blob.GetData(); + const auto blob_size = blob.GetSize(); + + BlobReader reader(blob_data, static_cast(blob_size)); + + // Skip byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + const auto poly_count = reader.Read(); + + // Set multipolygon entry + auto &mult_entry = mult_data[row_idx]; + mult_entry.offset = poly_start; + mult_entry.length = poly_count; + + // Read polygons + for (uint32_t poly_idx = 0; poly_idx < poly_count; poly_idx++) { + // Skip polygon byte order and type/meta + reader.Skip(sizeof(uint8_t) + sizeof(uint32_t)); + + // Read ring count + const auto ring_count = reader.Read(); + + // Set polygon entry + auto &poly_entry = poly_data[poly_start + poly_idx]; + poly_entry.offset = ring_start; + poly_entry.length = ring_count; + + // Read rings + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + // Read vertex count + const auto vert_count = reader.Read(); + // Set ring entry + auto &ring_entry = ring_data[ring_start + ring_idx]; + ring_entry.offset = vert_start; + ring_entry.length = vert_count; + + // Read vertices + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + vert_data[dim_idx][vert_start + vert_idx] = reader.Read(); + } + } + vert_start += vert_count; + } + ring_start += ring_count; + } + poly_start += poly_count; + } +} + +template +static void FromMultiPolygons(Vector &source_vec, Vector &target_vec, idx_t row_count, idx_t result_offset) { + // Flatten the source vector to extract all vertices + source_vec.Flatten(row_count); + + const auto mult_data = ListVector::GetData(source_vec); + const auto &poly_vec = ListVector::GetEntry(source_vec); + const auto poly_data = ListVector::GetData(poly_vec); + const auto &ring_vec = ListVector::GetEntry(poly_vec); + const auto ring_data = ListVector::GetData(ring_vec); + const auto &vert_parts = StructVector::GetEntries(ListVector::GetEntry(ring_vec)); + double *vert_data[V::WIDTH]; + for (idx_t i = 0; i < V::WIDTH; i++) { + vert_data[i] = FlatVector::GetData(*vert_parts[i]); + } + + for (idx_t row_idx = 0; row_idx < row_count; row_idx++) { + const auto out_idx = result_offset + row_idx; + if (FlatVector::IsNull(source_vec, row_idx)) { + FlatVector::SetNull(target_vec, out_idx, true); + continue; + } + + const auto &mult_entry = mult_data[row_idx]; + const auto poly_count = mult_entry.length; + + // First, compute total size + // byte order + type/meta + polygon count + idx_t blob_size = sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t); + + for (uint32_t poly_idx = 0; poly_idx < poly_count; poly_idx++) { + const auto &poly_entry = poly_data[mult_entry.offset + poly_idx]; + const auto ring_count = poly_entry.length; + // polygon byte order + type/meta + ring count + blob_size += sizeof(uint8_t) + sizeof(uint32_t) + sizeof(uint32_t); + + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + const auto &ring_entry = ring_data[poly_entry.offset + ring_idx]; + const auto vert_count = ring_entry.length; + // vertex count + blob_size += sizeof(uint32_t); + // vertex data + blob_size += vert_count * sizeof(V); + } + } + + auto blob = StringVector::EmptyString(target_vec, blob_size); + const auto blob_data = blob.GetDataWriteable(); + + FixedSizeBlobWriter writer(blob_data, static_cast(blob_size)); + + const auto meta = + static_cast(GeometryType::MULTIPOLYGON) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + writer.Write(1); // Little-endian + writer.Write(meta); // Type/meta + writer.Write(UnsafeNumericCast(poly_count)); // Polygon count + + for (uint32_t poly_idx = 0; poly_idx < poly_count; poly_idx++) { + const auto &poly_entry = poly_data[mult_entry.offset + poly_idx]; + const auto ring_count = poly_entry.length; + + // Write polygon byte order and type/meta + const auto poly_meta = + static_cast(GeometryType::POLYGON) + (V::HAS_Z ? 1000 : 0) + (V::HAS_M ? 2000 : 0); + writer.Write(1); // Little-endian + writer.Write(poly_meta); // Type/meta + writer.Write(UnsafeNumericCast(ring_count)); // Ring count + + for (uint32_t ring_idx = 0; ring_idx < ring_count; ring_idx++) { + const auto &ring_entry = ring_data[poly_entry.offset + ring_idx]; + const auto vert_count = ring_entry.length; + + writer.Write(UnsafeNumericCast(vert_count)); // Vertex count + + // Write vertex data + for (uint32_t vert_idx = 0; vert_idx < vert_count; vert_idx++) { + for (uint32_t dim_idx = 0; dim_idx < V::WIDTH; dim_idx++) { + writer.Write(vert_data[dim_idx][ring_entry.offset + vert_idx]); + } + } + } + } + + blob.Finalize(); + FlatVector::GetData(target_vec)[out_idx] = blob; + } +} + +template +static void ToVectorizedFormatInternal(Vector &source, Vector &target, idx_t count, GeometryType geom_type) { + switch (geom_type) { + case GeometryType::POINT: + ToPoints(source, target, count); + break; + case GeometryType::LINESTRING: + ToLineStrings(source, target, count); + break; + case GeometryType::POLYGON: + ToPolygons(source, target, count); + break; + case GeometryType::MULTIPOINT: + ToMultiPoints(source, target, count); + break; + case GeometryType::MULTILINESTRING: + ToMultiLineStrings(source, target, count); + break; + case GeometryType::MULTIPOLYGON: + ToMultiPolygons(source, target, count); + break; + default: + throw NotImplementedException("Unsupported geometry type %d", static_cast(geom_type)); + } +} + +void Geometry::ToVectorizedFormat(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + VertexType vert_type) { + switch (vert_type) { + case VertexType::XY: + ToVectorizedFormatInternal(source, target, count, geom_type); + break; + case VertexType::XYZ: + ToVectorizedFormatInternal(source, target, count, geom_type); + break; + case VertexType::XYM: + ToVectorizedFormatInternal(source, target, count, geom_type); + break; + case VertexType::XYZM: + ToVectorizedFormatInternal(source, target, count, geom_type); + break; + default: + throw InvalidInputException("Unsupported vertex type %d", static_cast(vert_type)); + } +} + +template +static void FromVectorizedFormatInternal(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + idx_t result_offset) { + switch (geom_type) { + case GeometryType::POINT: + FromPoints(source, target, count, result_offset); + break; + case GeometryType::LINESTRING: + FromLineStrings(source, target, count, result_offset); + break; + case GeometryType::POLYGON: + FromPolygons(source, target, count, result_offset); + break; + case GeometryType::MULTIPOINT: + FromMultiPoints(source, target, count, result_offset); + break; + case GeometryType::MULTILINESTRING: + FromMultiLineStrings(source, target, count, result_offset); + break; + case GeometryType::MULTIPOLYGON: + FromMultiPolygons(source, target, count, result_offset); + break; + default: + throw NotImplementedException("Unsupported geometry type %d", static_cast(geom_type)); + } +} + +void Geometry::FromVectorizedFormat(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + VertexType vert_type, idx_t result_offset) { + switch (vert_type) { + case VertexType::XY: + FromVectorizedFormatInternal(source, target, count, geom_type, result_offset); + break; + case VertexType::XYZ: + FromVectorizedFormatInternal(source, target, count, geom_type, result_offset); + break; + case VertexType::XYM: + FromVectorizedFormatInternal(source, target, count, geom_type, result_offset); + break; + case VertexType::XYZM: + FromVectorizedFormatInternal(source, target, count, geom_type, result_offset); + break; + default: + throw InvalidInputException("Unsupported vertex type %d", static_cast(vert_type)); + } +} + +static LogicalType GetVectorizedTypeInternal(GeometryType geom_type, LogicalType vertex_type) { + switch (geom_type) { + case GeometryType::POINT: + return vertex_type; + case GeometryType::LINESTRING: + return LogicalType::LIST(vertex_type); + case GeometryType::POLYGON: + return LogicalType::LIST(LogicalType::LIST(vertex_type)); + case GeometryType::MULTIPOINT: + return LogicalType::LIST(vertex_type); + case GeometryType::MULTILINESTRING: + return LogicalType::LIST(LogicalType::LIST(vertex_type)); + case GeometryType::MULTIPOLYGON: + return LogicalType::LIST(LogicalType::LIST(LogicalType::LIST(vertex_type))); + case GeometryType::GEOMETRYCOLLECTION: + throw NotImplementedException("GEOMETRYCOLLECTION vectorized type not implemented"); + default: + throw InvalidInputException("Unsupported geometry type %d", static_cast(geom_type)); + } +} + +LogicalType Geometry::GetVectorizedType(GeometryType geom_type, VertexType vert_type) { + switch (vert_type) { + case VertexType::XY: { + auto vert = LogicalType::STRUCT({{"x", LogicalType::DOUBLE}, {"y", LogicalType::DOUBLE}}); + return GetVectorizedTypeInternal(geom_type, std::move(vert)); + } + case VertexType::XYZ: { + auto vert = + LogicalType::STRUCT({{"x", LogicalType::DOUBLE}, {"y", LogicalType::DOUBLE}, {"z", LogicalType::DOUBLE}}); + return GetVectorizedTypeInternal(geom_type, std::move(vert)); + } + case VertexType::XYM: { + auto vert = + LogicalType::STRUCT({{"x", LogicalType::DOUBLE}, {"y", LogicalType::DOUBLE}, {"m", LogicalType::DOUBLE}}); + return GetVectorizedTypeInternal(geom_type, std::move(vert)); + } + case VertexType::XYZM: { + auto vert = LogicalType::STRUCT({{"x", LogicalType::DOUBLE}, + {"y", LogicalType::DOUBLE}, + {"z", LogicalType::DOUBLE}, + {"m", LogicalType::DOUBLE}}); + return GetVectorizedTypeInternal(geom_type, std::move(vert)); + } + default: + throw InvalidInputException("Unsupported vertex type %d", static_cast(vert_type)); + } +} + } // namespace duckdb diff --git a/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp b/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp index 3c967d448..99e694121 100644 --- a/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp +++ b/src/duckdb/src/common/types/row/tuple_data_scatter_gather.cpp @@ -29,7 +29,7 @@ static void TupleDataValueStore(const T &source, data_t *__restrict const &row_l template <> inline void TupleDataValueStore(const string_t &source, data_t *__restrict const &row_location, const idx_t &offset_in_row, data_ptr_t &heap_location) { -#ifdef D_ASSERT_IS_ENABLED +#ifdef DEBUG source.VerifyCharacters(); #endif if (source.IsInlined()) { @@ -54,7 +54,7 @@ static void TupleDataWithinListValueStore(const T &source, const data_ptr_t &loc template <> inline void TupleDataWithinListValueStore(const string_t &source, const data_ptr_t &location, data_ptr_t &heap_location) { -#ifdef D_ASSERT_IS_ENABLED +#ifdef DEBUG source.VerifyCharacters(); #endif Store(UnsafeNumericCast(source.GetSize()), location); @@ -64,14 +64,14 @@ inline void TupleDataWithinListValueStore(const string_t &source, const data_ptr template void TupleDataValueVerify(const LogicalType &, const T &) { -#ifdef D_ASSERT_IS_ENABLED +#ifdef DEBUG // NOP #endif } template <> inline void TupleDataValueVerify(const LogicalType &type, const string_t &value) { -#ifdef D_ASSERT_IS_ENABLED +#ifdef DEBUG if (type.id() == LogicalTypeId::VARCHAR) { value.Verify(); } @@ -516,7 +516,7 @@ void TupleDataCollection::CollectionWithinCollectionComputeHeapSizes(Vector &hea D_ASSERT(source_format.children.size() == 1); auto &child_format = source_format.children[0]; #ifdef D_ASSERT_IS_ENABLED - // In debug mode this should be deleted by ResetCombinedListData + // Should be deleted by ResetCombinedListData if assertions are enabled D_ASSERT(!child_format.combined_list_data); #endif if (!child_format.combined_list_data) { @@ -647,7 +647,7 @@ static void InitializeValidityMask(const data_ptr_t row_locations[], const idx_t void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const DataChunk &new_chunk, const SelectionVector &append_sel, const idx_t append_count) const { -#ifdef D_ASSERT_IS_ENABLED +#ifdef DEBUG Vector heap_locations_copy(LogicalType::POINTER); if (!layout.AllConstant()) { const auto heap_locations = FlatVector::GetData(chunk_state.heap_locations); @@ -686,7 +686,7 @@ void TupleDataCollection::Scatter(TupleDataChunkState &chunk_state, const DataCh } } -#ifdef D_ASSERT_IS_ENABLED +#ifdef DEBUG // Verify that the size of the data written to the heap is the same as the size we computed it would be if (!layout.AllConstant()) { const auto original_heap_locations = FlatVector::GetData(heap_locations_copy); diff --git a/src/duckdb/src/common/types/type_manager.cpp b/src/duckdb/src/common/types/type_manager.cpp new file mode 100644 index 000000000..255e41c85 --- /dev/null +++ b/src/duckdb/src/common/types/type_manager.cpp @@ -0,0 +1,117 @@ +#include "duckdb/common/types/type_manager.hpp" +#include "duckdb/function/cast/cast_function_set.hpp" +#include "duckdb/parser/parser.hpp" +#include "duckdb/planner/binder.hpp" +#include "duckdb/main/config.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/main/database.hpp" + +namespace duckdb { + +CastFunctionSet &TypeManager::GetCastFunctions() { + return *cast_functions; +} + +static LogicalType TransformStringToUnboundType(const string &str) { + if (StringUtil::Lower(str) == "null") { + return LogicalType::SQLNULL; + } + ColumnList column_list; + try { + column_list = Parser::ParseColumnList("dummy " + str); + } catch (const std::runtime_error &e) { + const vector suggested_types {"BIGINT", + "INT8", + "LONG", + "BIT", + "BITSTRING", + "BLOB", + "BYTEA", + "BINARY,", + "VARBINARY", + "BOOLEAN", + "BOOL", + "LOGICAL", + "DATE", + "DECIMAL(prec, scale)", + "DOUBLE", + "FLOAT8", + "FLOAT", + "FLOAT4", + "REAL", + "HUGEINT", + "INTEGER", + "INT4", + "INT", + "SIGNED", + "INTERVAL", + "SMALLINT", + "INT2", + "SHORT", + "TIME", + "TIMESTAMPTZ", + "TIMESTAMP", + "DATETIME", + "TINYINT", + "INT1", + "UBIGINT", + "UHUGEINT", + "UINTEGER", + "USMALLINT", + "UTINYINT", + "UUID", + "VARCHAR", + "CHAR", + "BPCHAR", + "TEXT", + "STRING", + "MAP(INTEGER, VARCHAR)", + "UNION(num INTEGER, text VARCHAR)"}; + std::ostringstream error; + error << "Value \"" << str << "\" can not be converted to a DuckDB Type." << '\n'; + error << "Possible examples as suggestions: " << '\n'; + auto suggestions = StringUtil::TopNJaroWinkler(suggested_types, str); + for (auto &suggestion : suggestions) { + error << "* " << suggestion << '\n'; + } + throw InvalidInputException(error.str()); + } + return column_list.GetColumn(LogicalIndex(0)).Type(); +} + +// This has to be called with a level of indirection (through "parse_function") in order to avoid being included in +// extensions that statically link the core DuckDB library. +static LogicalType ParseLogicalTypeInternal(const string &type_str, ClientContext &context) { + auto type = TransformStringToUnboundType(type_str); + if (type.IsUnbound()) { + if (!context.transaction.HasActiveTransaction()) { + throw InternalException( + "Context does not have a transaction active, try running ClientContext::BindLogicalType instead"); + } + auto binder = Binder::CreateBinder(context, nullptr); + binder->BindLogicalType(type); + } + return type; +} + +LogicalType TypeManager::ParseLogicalType(const string &type_str, ClientContext &context) const { + return parse_function(type_str, context); +} + +TypeManager &TypeManager::Get(DatabaseInstance &db) { + return DBConfig::GetConfig(db).GetTypeManager(); +} + +TypeManager &TypeManager::Get(ClientContext &context) { + return DBConfig::GetConfig(context).GetTypeManager(); +} + +TypeManager::TypeManager(DBConfig &config_p) { + cast_functions = make_uniq(config_p); + parse_function = ParseLogicalTypeInternal; +} + +TypeManager::~TypeManager() { +} + +} // namespace duckdb diff --git a/src/duckdb/src/common/types/value.cpp b/src/duckdb/src/common/types/value.cpp index acedfe835..0ec8310d3 100644 --- a/src/duckdb/src/common/types/value.cpp +++ b/src/duckdb/src/common/types/value.cpp @@ -26,8 +26,12 @@ #include "duckdb/common/types/bignum.hpp" #include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/common/serializer/binary_serializer.hpp" +#include "duckdb/common/serializer/binary_deserializer.hpp" +#include "duckdb/common/serializer/memory_stream.hpp" #include "duckdb/common/types/string.hpp" #include "duckdb/common/types/value_map.hpp" +#include "duckdb/function/scalar/variant_utils.hpp" #include #include @@ -935,6 +939,25 @@ Value Value::GEOMETRY(const_data_ptr_t data, idx_t len) { return result; } +Value Value::TYPE(const LogicalType &type) { + MemoryStream stream; + BinarySerializer::Serialize(type, stream); + auto data_ptr = const_char_ptr_cast(stream.GetData()); + auto data_len = stream.GetPosition(); + + Value result(LogicalType::TYPE()); + result.is_null = false; + result.value_info_ = make_shared_ptr(string(data_ptr, data_len)); + return result; +} + +Value Value::TYPE(const string_t &serialized_type) { + Value result(LogicalType::TYPE()); + result.is_null = false; + result.value_info_ = make_shared_ptr(serialized_type.GetString()); + return result; +} + Value Value::BLOB(const string &data) { Value result(LogicalType::BLOB); result.is_null = false; @@ -1645,7 +1668,17 @@ string Value::ToSQLString() const { } return "'" + StringUtil::Replace(ToString(), "'", "''") + "'"; } - case LogicalTypeId::VARIANT: + case LogicalTypeId::VARIANT: { + string ret = "VARIANT("; + Vector tmp(*this); + RecursiveUnifiedVectorFormat format; + Vector::RecursiveToUnifiedFormat(tmp, 1, format); + UnifiedVariantVectorData vector_data(format); + auto val = VariantUtils::ConvertVariantToValue(vector_data, 0, 0); + ret += val.ToString(); + ret += ")"; + return ret; + } case LogicalTypeId::STRUCT: { bool is_unnamed = StructType::IsUnnamed(type_); string ret = is_unnamed ? "(" : "{"; @@ -1786,6 +1819,19 @@ const string &StringValue::Get(const Value &value) { return value.value_info_->Get().GetString(); } +LogicalType TypeValue::GetType(const Value &value) { + if (value.is_null) { + throw InternalException("Calling TypeValue::GetType on a NULL value"); + } + D_ASSERT(value.type().id() == LogicalTypeId::TYPE); + D_ASSERT(value.value_info_); + auto &type_str = value.value_info_->Get().GetString(); + auto str = string_t(type_str); + MemoryStream stream(data_ptr_cast(str.GetDataWriteable()), str.GetSize()); + BinaryDeserializer deserializer(stream); + return LogicalType::Deserialize(deserializer); +} + date_t DateValue::Get(const Value &value) { return value.GetValueUnsafe(); } @@ -2034,7 +2080,7 @@ void Value::Reinterpret(LogicalType new_type) { this->type_ = std::move(new_type); } -const LogicalType &GetChildType(const LogicalType &parent_type, idx_t i) { +static const LogicalType &GetChildType(const LogicalType &parent_type, idx_t i) { switch (parent_type.InternalType()) { case PhysicalType::LIST: return ListType::GetChildType(parent_type); @@ -2047,7 +2093,7 @@ const LogicalType &GetChildType(const LogicalType &parent_type, idx_t i) { } } -bool SerializeTypeMatches(const LogicalType &expected_type, const LogicalType &actual_type) { +static bool SerializeTypeMatches(const LogicalType &expected_type, const LogicalType &actual_type) { if (expected_type.id() != actual_type.id()) { // type id needs to be the same return false; @@ -2087,6 +2133,14 @@ void Value::SerializeInternal(Serializer &serializer, bool serialize_type) const if (IsNull()) { return; } + + if (type_.id() == LogicalTypeId::TYPE) { + // special case for TYPE values: serialize the type as a nested object + auto type_value = TypeValue::GetType(*this); + serializer.WriteProperty(102, "value", type_value); + return; + } + switch (type_.InternalType()) { case PhysicalType::BIT: throw InternalException("BIT type should not be serialized"); @@ -2170,6 +2224,13 @@ Value Value::Deserialize(Deserializer &deserializer) { return new_value; } new_value.is_null = false; + + if (type.id() == LogicalTypeId::TYPE) { + // special case for TYPE values: deserialize the type as a nested object + auto type_value = deserializer.ReadProperty(102, "value"); + return Value::TYPE(type_value); + } + switch (type.InternalType()) { case PhysicalType::BIT: throw InternalException("BIT type should not be deserialized"); diff --git a/src/duckdb/src/common/types/vector.cpp b/src/duckdb/src/common/types/vector.cpp index 5ae9d0643..8caaa55b8 100644 --- a/src/duckdb/src/common/types/vector.cpp +++ b/src/duckdb/src/common/types/vector.cpp @@ -804,6 +804,10 @@ Value Vector::GetValueInternal(const Vector &v_p, idx_t index_p) { } return Value::ARRAY(ArrayType::GetChildType(type), std::move(children)); } + case LogicalTypeId::TYPE: { + auto blob = reinterpret_cast(data)[index]; + return Value::TYPE(blob); + } default: throw InternalException("Unimplemented type for value access"); } diff --git a/src/duckdb/src/common/vector_operations/is_distinct_from.cpp b/src/duckdb/src/common/vector_operations/is_distinct_from.cpp index d08a2d276..538f5f394 100644 --- a/src/duckdb/src/common/vector_operations/is_distinct_from.cpp +++ b/src/duckdb/src/common/vector_operations/is_distinct_from.cpp @@ -1,6 +1,8 @@ #include "duckdb/common/uhugeint.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/common/operator/comparison_operators.hpp" +#include "duckdb/common/value_operations/value_operations.hpp" +#include "duckdb/function/scalar/variant_utils.hpp" namespace duckdb { @@ -862,6 +864,101 @@ idx_t DistinctSelectArray(Vector &left, Vector &right, idx_t count, const Select return match_count; } +template +idx_t DistinctSelectVariant(Vector &left, Vector &right, idx_t count, const SelectionVector &sel, + OptionalSelection &true_opt, OptionalSelection &false_opt, + optional_ptr null_mask) { + idx_t true_count = 0; + idx_t false_count = 0; + + // Convert vectors to unified format for easier access + RecursiveUnifiedVectorFormat left_recursive_data, right_recursive_data; + Vector::RecursiveToUnifiedFormat(left, count, left_recursive_data); + Vector::RecursiveToUnifiedFormat(right, count, right_recursive_data); + + UnifiedVariantVectorData left_variant(left_recursive_data); + UnifiedVariantVectorData right_variant(right_recursive_data); + + auto &left_data = left_recursive_data.unified; + auto &right_data = right_recursive_data.unified; + for (idx_t i = 0; i < count; i++) { + auto result_idx = sel.get_index(i); + auto left_idx = left_data.sel->get_index(i); + auto right_idx = right_data.sel->get_index(i); + + // Check for NULL values + bool left_null = !left_data.validity.RowIsValid(left_idx); + bool right_null = !right_data.validity.RowIsValid(right_idx); + + bool comparison_result; + if (left_null || right_null) { + // Handle NULL semantics based on operation type + if (std::is_same::value) { + comparison_result = !(left_null && right_null); + } else if (std::is_same::value) { + comparison_result = (left_null && right_null); + } else { + // For ordering operations, NULLs are treated as maximal + if (left_null && right_null) { + comparison_result = false; // NULL == NULL for ordering + } else if (left_null) { + // NULL > anything, so left_null means left is greater + comparison_result = std::is_same::value || + std::is_same::value; + } else { + // right_null, so right is greater + comparison_result = std::is_same::value || + std::is_same::value; + } + } + } else { + // Both non-NULL, convert to Values and use appropriate Value operation + auto left_val = VariantUtils::ConvertVariantToValue(left_variant, i, 0); + auto right_val = VariantUtils::ConvertVariantToValue(right_variant, i, 0); + + LogicalType max_logical_type; + auto res = LogicalType::TryGetMaxLogicalTypeUnchecked(left_val.type(), right_val.type(), max_logical_type); + if (!res) { + throw InvalidInputException( + "Can't compare values of type %s (%s) and type %s (%s) - an explicit cast is required", + left_val.type().ToString(), left_val.ToString(), right_val.type().ToString(), right_val.ToString()); + } + + if (std::is_same::value) { + comparison_result = ValueOperations::DistinctFrom(left_val, right_val); + } else if (std::is_same::value) { + comparison_result = ValueOperations::NotDistinctFrom(left_val, right_val); + } else if (std::is_same::value) { + comparison_result = ValueOperations::DistinctGreaterThan(left_val, right_val); + } else if (std::is_same::value) { + comparison_result = ValueOperations::DistinctGreaterThanEquals(left_val, right_val); + } else if (std::is_same::value) { + comparison_result = ValueOperations::DistinctLessThan(left_val, right_val); + } else if (std::is_same::value) { + comparison_result = ValueOperations::DistinctLessThanEquals(left_val, right_val); + } else { + throw InternalException("Unsupported operation for VARIANT comparison"); + } + } + + if (comparison_result) { + true_opt.Append(true_count, result_idx); + } else { + false_opt.Append(false_count, result_idx); + } + + // Set null mask if needed + if (null_mask && (left_null || right_null)) { + null_mask->SetInvalid(result_idx); + } + } + + true_opt.Advance(true_count); + false_opt.Advance(false_count); + + return true_count; +} + template idx_t DistinctSelectNested(Vector &left, Vector &right, optional_ptr sel, const idx_t count, optional_ptr true_sel, optional_ptr false_sel, @@ -899,10 +996,16 @@ idx_t DistinctSelectNested(Vector &left, Vector &right, optional_ptr(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt, null_mask); break; - case PhysicalType::STRUCT: + case PhysicalType::STRUCT: { + if (left_type.id() == LogicalTypeId::VARIANT) { + match_count += + DistinctSelectVariant(l_not_null, r_not_null, unknown, *sel, true_opt, false_opt, null_mask); + break; + } match_count += DistinctSelectStruct(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt, null_mask); break; + } case PhysicalType::ARRAY: match_count += DistinctSelectArray(l_not_null, r_not_null, unknown, maybe_vec, true_opt, false_opt, null_mask); diff --git a/src/duckdb/src/common/virtual_file_system.cpp b/src/duckdb/src/common/virtual_file_system.cpp index 6374ec963..0746f9a24 100644 --- a/src/duckdb/src/common/virtual_file_system.cpp +++ b/src/duckdb/src/common/virtual_file_system.cpp @@ -6,16 +6,112 @@ #include "duckdb/common/string_util.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/storage/caching_file_system_wrapper.hpp" +#include "duckdb/common/multi_file/multi_file_list.hpp" namespace duckdb { +struct FileSystemHandle { + explicit FileSystemHandle(unique_ptr fs) : file_system(std::move(fs)) { + } + + unique_ptr file_system; +}; + +//! The FileSystemRegistry holds the set of file systems that are registered. +//! Note that it should be treated as read-only. +//! When a change is made (e.g. by registering new file system) a copy of the registry is made +struct FileSystemRegistry { + explicit FileSystemRegistry(unique_ptr fs) + : default_fs(make_shared_ptr(std::move(fs))) { + } + + vector> sub_systems; + map> compressed_fs; + const shared_ptr default_fs; + unordered_set disabled_file_systems; + +public: + shared_ptr RegisterSubSystem(unique_ptr fs) const; + shared_ptr RegisterSubSystem(FileCompressionType compression_type, + unique_ptr fs) const; + shared_ptr SetDisabledFileSystems(const vector &names) const; + shared_ptr ExtractSubSystem(const string &name, unique_ptr &result) const; +}; + +shared_ptr FileSystemRegistry::RegisterSubSystem(unique_ptr fs) const { + auto new_registry = make_shared_ptr(*this); + const auto &name = fs->GetName(); + for (auto &sub_system : new_registry->sub_systems) { + if (sub_system->file_system->GetName() == name) { + throw InvalidInputException("Filesystem with name %s has already been registered, cannot re-register!", + name); + } + } + new_registry->sub_systems.push_back(make_shared_ptr(std::move(fs))); + return new_registry; +} + +shared_ptr FileSystemRegistry::RegisterSubSystem(FileCompressionType compression_type, + unique_ptr fs) const { + auto new_registry = make_shared_ptr(*this); + new_registry->compressed_fs[compression_type] = make_shared_ptr(std::move(fs)); + return new_registry; +} + +shared_ptr FileSystemRegistry::SetDisabledFileSystems(const vector &names) const { + auto new_registry = make_shared_ptr(*this); + unordered_set new_disabled_file_systems; + for (auto &name : names) { + if (name.empty()) { + continue; + } + if (new_disabled_file_systems.find(name) != new_disabled_file_systems.end()) { + throw InvalidInputException("Duplicate disabled file system \"%s\"", name); + } + new_disabled_file_systems.insert(name); + } + for (auto &disabled_fs : disabled_file_systems) { + if (new_disabled_file_systems.find(disabled_fs) == new_disabled_file_systems.end()) { + throw InvalidInputException("File system \"%s\" has been disabled previously, it cannot be re-enabled", + disabled_fs); + } + } + new_registry->disabled_file_systems = std::move(new_disabled_file_systems); + return new_registry; +} + +shared_ptr FileSystemRegistry::ExtractSubSystem(const string &name, + unique_ptr &result) const { + auto new_registry = make_shared_ptr(*this); + // If the subsystem has been disabled, we don't allow extraction and return nullptr here. + if (disabled_file_systems.find(name) != disabled_file_systems.end()) { + return nullptr; + } + + for (auto iter = new_registry->sub_systems.begin(); iter != new_registry->sub_systems.end(); ++iter) { + auto &cur_filesystem = (*iter)->file_system; + if (cur_filesystem->GetName() == name) { + result = std::move(cur_filesystem); + new_registry->sub_systems.erase(iter); + return new_registry; + } + } + + // Requested subfilesystem is not registered. + return nullptr; +} + VirtualFileSystem::VirtualFileSystem() : VirtualFileSystem(FileSystem::CreateLocal()) { } -VirtualFileSystem::VirtualFileSystem(unique_ptr &&inner) : default_fs(std::move(inner)) { +VirtualFileSystem::VirtualFileSystem(unique_ptr &&inner) + : file_system_registry(make_shared_ptr(std::move(inner))) { VirtualFileSystem::RegisterSubSystem(FileCompressionType::GZIP, make_uniq()); } +VirtualFileSystem::~VirtualFileSystem() { +} + unique_ptr VirtualFileSystem::OpenFileExtended(const OpenFileInfo &file, FileOpenFlags flags, optional_ptr opener) { auto compression = flags.Compression(); @@ -38,7 +134,8 @@ unique_ptr VirtualFileSystem::OpenFileExtended(const OpenFileInfo &f // open the base file handle in UNCOMPRESSED mode flags.SetCompression(FileCompressionType::UNCOMPRESSED); - auto &internal_filesystem = FindFileSystem(file.path, opener); + auto registry = file_system_registry.atomic_load(); + auto &internal_filesystem = FindFileSystem(registry, file.path, opener); // File handle gets created. unique_ptr file_handle = nullptr; @@ -61,8 +158,8 @@ unique_ptr VirtualFileSystem::OpenFileExtended(const OpenFileInfo &f if (file_handle->GetType() == FileType::FILE_TYPE_FIFO) { file_handle = PipeFileSystem::OpenPipe(context, std::move(file_handle)); } else if (compression != FileCompressionType::UNCOMPRESSED) { - auto entry = compressed_fs.find(compression); - if (entry == compressed_fs.end()) { + auto entry = registry->compressed_fs.find(compression); + if (entry == registry->compressed_fs.end()) { if (compression == FileCompressionType::ZSTD) { throw NotImplementedException( "Attempting to open a compressed file, but the compression type is not supported.\nConsider " @@ -71,7 +168,8 @@ unique_ptr VirtualFileSystem::OpenFileExtended(const OpenFileInfo &f throw NotImplementedException( "Attempting to open a compressed file, but the compression type is not supported"); } - file_handle = entry->second->OpenCompressedFile(context, std::move(file_handle), flags.OpenForWriting()); + auto &compressed_fs = *entry->second->file_system; + file_handle = compressed_fs.OpenCompressedFile(context, std::move(file_handle), flags.OpenForWriting()); } return file_handle; } @@ -118,14 +216,14 @@ void VirtualFileSystem::FileSync(FileHandle &handle) { // need to look up correct fs for this bool VirtualFileSystem::DirectoryExists(const string &directory, optional_ptr opener) { - return FindFileSystem(directory).DirectoryExists(directory, opener); + return FindFileSystem(directory, opener).DirectoryExists(directory, opener); } void VirtualFileSystem::CreateDirectory(const string &directory, optional_ptr opener) { - FindFileSystem(directory).CreateDirectory(directory, opener); + FindFileSystem(directory, opener).CreateDirectory(directory, opener); } void VirtualFileSystem::RemoveDirectory(const string &directory, optional_ptr opener) { - FindFileSystem(directory).RemoveDirectory(directory, opener); + FindFileSystem(directory, opener).RemoveDirectory(directory, opener); } bool VirtualFileSystem::ListFilesExtended(const string &directory, @@ -135,7 +233,7 @@ bool VirtualFileSystem::ListFilesExtended(const string &directory, } void VirtualFileSystem::MoveFile(const string &source, const string &target, optional_ptr opener) { - FindFileSystem(source).MoveFile(source, target, opener); + FindFileSystem(source, opener).MoveFile(source, target, opener); } bool VirtualFileSystem::FileExists(const string &filename, optional_ptr opener) { @@ -143,21 +241,21 @@ bool VirtualFileSystem::FileExists(const string &filename, optional_ptr opener) { - return FindFileSystem(filename).IsPipe(filename, opener); + return FindFileSystem(filename, opener).IsPipe(filename, opener); } void VirtualFileSystem::RemoveFile(const string &filename, optional_ptr opener) { - FindFileSystem(filename).RemoveFile(filename, opener); + FindFileSystem(filename, opener).RemoveFile(filename, opener); } bool VirtualFileSystem::TryRemoveFile(const string &filename, optional_ptr opener) { - return FindFileSystem(filename).TryRemoveFile(filename, opener); + return FindFileSystem(filename, opener).TryRemoveFile(filename, opener); } void VirtualFileSystem::RemoveFiles(const vector &filenames, optional_ptr opener) { reference_map_t> files_by_fs; for (const auto &filename : filenames) { - auto &fs = FindFileSystem(filename); + auto &fs = FindFileSystem(filename, opener); files_by_fs[fs].push_back(filename); } for (auto &entry : files_by_fs) { @@ -166,63 +264,54 @@ void VirtualFileSystem::RemoveFiles(const vector &filenames, optional_pt } string VirtualFileSystem::PathSeparator(const string &path) { - return FindFileSystem(path).PathSeparator(path); + return FindFileSystem(path, nullptr).PathSeparator(path); } -vector VirtualFileSystem::Glob(const string &path, FileOpener *opener) { - return FindFileSystem(path, opener).Glob(path, opener); +unique_ptr VirtualFileSystem::GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener) { + return FindFileSystem(path, opener).Glob(path, input, opener); } void VirtualFileSystem::RegisterSubSystem(unique_ptr fs) { - // Sub-filesystem number is not expected to be huge, also filesystem registration should be called infrequently. - const auto &name = fs->GetName(); - for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) { - if (sub_system->get()->GetName() == name) { - throw InvalidInputException("Filesystem with name %s has already been registered, cannot re-register!", - name); - } - } - sub_systems.push_back(std::move(fs)); + lock_guard guard(registry_lock); + auto new_registry = file_system_registry->RegisterSubSystem(std::move(fs)); + file_system_registry.atomic_store(new_registry); } -void VirtualFileSystem::UnregisterSubSystem(const string &name) { - for (auto sub_system = sub_systems.begin(); sub_system != sub_systems.end(); sub_system++) { - if (sub_system->get()->GetName() == name) { - sub_systems.erase(sub_system); - return; - } - } - throw InvalidInputException("Could not find filesystem with name %s", name); +void VirtualFileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr fs) { + lock_guard guard(registry_lock); + auto new_registry = file_system_registry->RegisterSubSystem(compression_type, std::move(fs)); + file_system_registry.atomic_store(new_registry); } -void VirtualFileSystem::RegisterSubSystem(FileCompressionType compression_type, unique_ptr fs) { - compressed_fs[compression_type] = std::move(fs); +void VirtualFileSystem::UnregisterSubSystem(const string &name) { + auto sub_system = ExtractSubSystem(name); + + lock_guard guard(registry_lock); + unregistered_file_systems.push_back(std::move(sub_system)); } +void VirtualFileSystem::SetDisabledFileSystems(const vector &names) { + lock_guard guard(registry_lock); + auto new_registry = file_system_registry->SetDisabledFileSystems(names); + file_system_registry.atomic_store(new_registry); +} unique_ptr VirtualFileSystem::ExtractSubSystem(const string &name) { - // If the subsystem has been disabled, we don't allow extraction and return nullptr here. - if (disabled_file_systems.find(name) != disabled_file_systems.end()) { - return nullptr; - } - - unique_ptr extracted_filesystem; - for (auto iter = sub_systems.begin(); iter != sub_systems.end(); ++iter) { - auto &cur_filesystem = *iter; - if (cur_filesystem->GetName() == name) { - extracted_filesystem = std::move(cur_filesystem); - sub_systems.erase(iter); - return extracted_filesystem; - } + lock_guard guard(registry_lock); + unique_ptr result; + auto new_registry = file_system_registry->ExtractSubSystem(name, result); + if (new_registry) { + file_system_registry.atomic_store(new_registry); } - - // Requested subfilesystem is not registered. - return nullptr; + return result; } vector VirtualFileSystem::ListSubSystems() { - vector names(sub_systems.size()); - for (idx_t i = 0; i < sub_systems.size(); i++) { - names[i] = sub_systems[i]->GetName(); + auto registry = file_system_registry.atomic_load(); + auto &sub_systems = registry->sub_systems; + vector names; + for (auto &sub_system : sub_systems) { + names.push_back(sub_system->file_system->GetName()); } return names; } @@ -231,47 +320,34 @@ std::string VirtualFileSystem::GetName() const { return "VirtualFileSystem"; } -void VirtualFileSystem::SetDisabledFileSystems(const vector &names) { - unordered_set new_disabled_file_systems; - for (auto &name : names) { - if (name.empty()) { - continue; - } - if (new_disabled_file_systems.find(name) != new_disabled_file_systems.end()) { - throw InvalidInputException("Duplicate disabled file system \"%s\"", name); - } - new_disabled_file_systems.insert(name); - } - for (auto &disabled_fs : disabled_file_systems) { - if (new_disabled_file_systems.find(disabled_fs) == new_disabled_file_systems.end()) { - throw InvalidInputException("File system \"%s\" has been disabled previously, it cannot be re-enabled", - disabled_fs); - } - } - disabled_file_systems = std::move(new_disabled_file_systems); -} - bool VirtualFileSystem::SubSystemIsDisabled(const string &name) { + auto registry = file_system_registry.atomic_load(); + auto &disabled_file_systems = registry->disabled_file_systems; return disabled_file_systems.find(name) != disabled_file_systems.end(); } bool VirtualFileSystem::IsDisabledForPath(const string &path) { + auto registry = file_system_registry.atomic_load(); + auto &disabled_file_systems = registry->disabled_file_systems; if (disabled_file_systems.empty()) { return false; } - auto fs = FindFileSystemInternal(path); + auto fs = FindFileSystemInternal(*registry, path); if (!fs) { - fs = default_fs.get(); + fs = registry->default_fs->file_system; } return disabled_file_systems.find(fs->GetName()) != disabled_file_systems.end(); } FileSystem &VirtualFileSystem::FindFileSystem(const string &path, optional_ptr opener) { - return FindFileSystem(path, FileOpener::TryGetDatabase(opener)); + auto registry = file_system_registry.atomic_load(); + return FindFileSystem(registry, path, opener); } -FileSystem &VirtualFileSystem::FindFileSystem(const string &path, optional_ptr db_instance) { - auto fs = FindFileSystemInternal(path); +FileSystem &VirtualFileSystem::FindFileSystem(shared_ptr ®istry, const string &path, + optional_ptr opener) { + auto db_instance = FileOpener::TryGetDatabase(opener); + auto fs = FindFileSystemInternal(*registry, path); if (!fs && db_instance) { string required_extension; @@ -282,9 +358,8 @@ FileSystem &VirtualFileSystem::FindFileSystem(const string &path, optional_ptrExtensionIsLoaded(required_extension)) { - auto &dbconfig = DBConfig::GetConfig(*db_instance); if (!ExtensionHelper::CanAutoloadExtension(required_extension) || - !dbconfig.options.autoload_known_extensions) { + !Settings::Get(*db_instance)) { auto error_message = "File " + path + " requires the extension " + required_extension + " to be loaded"; error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(*db_instance, error_message, required_extension); @@ -293,48 +368,35 @@ FileSystem &VirtualFileSystem::FindFileSystem(const string &path, optional_ptrdefault_fs->file_system; } + auto &disabled_file_systems = registry->disabled_file_systems; if (!disabled_file_systems.empty() && disabled_file_systems.find(fs->GetName()) != disabled_file_systems.end()) { throw PermissionException("File system %s has been disabled by configuration", fs->GetName()); } return *fs; } -FileSystem &VirtualFileSystem::FindFileSystem(const string &path) { - auto fs = FindFileSystemInternal(path); - if (!fs) { - fs = default_fs; - } - if (!disabled_file_systems.empty() && disabled_file_systems.find(fs->GetName()) != disabled_file_systems.end()) { - throw PermissionException("File system %s has been disabled by configuration", fs->GetName()); - } - return *fs; -} - -optional_ptr VirtualFileSystem::FindFileSystemInternal(const string &path) { - FileSystem *fs = nullptr; - - for (auto &sub_system : sub_systems) { - if (sub_system->CanHandleFile(path)) { - if (sub_system->IsManuallySet()) { - return *sub_system; +optional_ptr VirtualFileSystem::FindFileSystemInternal(FileSystemRegistry ®istry, const string &path) { + optional_ptr fs; + for (auto &sub_system : registry.sub_systems) { + auto &sub_fs = *sub_system->file_system; + if (sub_fs.CanHandleFile(path)) { + if (sub_fs.IsManuallySet()) { + return sub_fs; } - fs = sub_system.get(); + fs = sub_fs; } } - if (fs) { - return *fs; - } - - // We could use default_fs, that's on the caller - return nullptr; + return fs; } } // namespace duckdb diff --git a/src/duckdb/src/execution/expression_executor.cpp b/src/duckdb/src/execution/expression_executor.cpp index 0278df506..ac803eca2 100644 --- a/src/duckdb/src/execution/expression_executor.cpp +++ b/src/duckdb/src/execution/expression_executor.cpp @@ -11,7 +11,7 @@ namespace duckdb { ExpressionExecutor::ExpressionExecutor(ClientContext &context) : context(&context) { - debug_vector_verification = DBConfig::GetSetting(context); + debug_vector_verification = Settings::Get(context); } ExpressionExecutor::ExpressionExecutor(ClientContext &context, const Expression *expression) diff --git a/src/duckdb/src/execution/expression_executor/execute_function.cpp b/src/duckdb/src/execution/expression_executor/execute_function.cpp index d3610dae2..4b3272edd 100644 --- a/src/duckdb/src/execution/expression_executor/execute_function.cpp +++ b/src/duckdb/src/execution/expression_executor/execute_function.cpp @@ -116,6 +116,16 @@ bool ExecuteFunctionState::TryExecuteDictionaryExpression(const BoundFunctionExp return true; } +void ExecuteFunctionState::ResetDictionaryStates() { + // Clear the cached dictionary information + current_input_dictionary_id.clear(); + output_dictionary.reset(); + + for (const auto &child_state : child_states) { + child_state->ResetDictionaryStates(); + } +} + unique_ptr ExpressionExecutor::InitializeState(const BoundFunctionExpression &expr, ExpressionExecutorState &root) { auto result = make_uniq(expr, root); diff --git a/src/duckdb/src/execution/expression_executor/execute_operator.cpp b/src/duckdb/src/execution/expression_executor/execute_operator.cpp index 527178d36..8d3cfee46 100644 --- a/src/duckdb/src/execution/expression_executor/execute_operator.cpp +++ b/src/duckdb/src/execution/expression_executor/execute_operator.cpp @@ -133,12 +133,19 @@ void ExpressionExecutor::Execute(const BoundOperatorExpression &expr, Expression throw; } } + + // On error, evaluate per row SelectionVector selvec(1); DataChunk intermediate; intermediate.Initialize(GetAllocator(), {result.GetType()}, 1); for (idx_t i = 0; i < count; i++) { intermediate.Reset(); intermediate.SetCardinality(1); + + // Make sure to clear any dictionary states in the child expression, so that it actually + // gets executed anew for every row + child_state.ResetDictionaryStates(); + selvec.set_index(0, sel ? sel->get_index(i) : i); Value val(result.GetType()); try { diff --git a/src/duckdb/src/execution/expression_executor_state.cpp b/src/duckdb/src/execution/expression_executor_state.cpp index 070a399db..fcac6065b 100644 --- a/src/duckdb/src/execution/expression_executor_state.cpp +++ b/src/duckdb/src/execution/expression_executor_state.cpp @@ -52,6 +52,12 @@ void ExpressionState::Verify(ExpressionExecutorState &root_executor) { } } +void ExpressionState::ResetDictionaryStates() { + for (const auto &child : child_states) { + child->ResetDictionaryStates(); + } +} + void ExpressionExecutorState::Verify() { D_ASSERT(executor); root_state->Verify(*this); diff --git a/src/duckdb/src/execution/index/art/art.cpp b/src/duckdb/src/execution/index/art/art.cpp index 800135f0d..2e4e49f87 100644 --- a/src/duckdb/src/execution/index/art/art.cpp +++ b/src/duckdb/src/execution/index/art/art.cpp @@ -49,7 +49,7 @@ ART::ART(const string &name, const IndexConstraintType index_constraint_type, co const shared_ptr, ALLOCATOR_COUNT>> &allocators_ptr, const IndexStorageInfo &info) : BoundIndex(name, ART::TYPE_NAME, index_constraint_type, column_ids, table_io_manager, unbound_expressions, db), - allocators(allocators_ptr), owns_data(false), verify_max_key_len(false) { + allocators(allocators_ptr), owns_data(false) { // FIXME: Use the new byte representation function to support nested types. for (idx_t i = 0; i < types.size(); i++) { switch (types[i]) { @@ -73,12 +73,6 @@ ART::ART(const string &name, const IndexConstraintType index_constraint_type, co } } - if (types.size() > 1) { - verify_max_key_len = true; - } else if (types[0] == PhysicalType::VARCHAR) { - verify_max_key_len = true; - } - // Initialize the allocators. SetPrefixCount(info); if (!allocators) { @@ -393,25 +387,11 @@ void GenerateKeysInternal(ArenaAllocator &allocator, DataChunk &input, unsafe_ve template <> void ART::GenerateKeys<>(ArenaAllocator &allocator, DataChunk &input, unsafe_vector &keys) { GenerateKeysInternal(allocator, input, keys); - if (!verify_max_key_len) { - return; - } - auto max_len = MAX_KEY_LEN * idx_t(prefix_count); - for (idx_t i = 0; i < input.size(); i++) { - keys[i].VerifyKeyLength(max_len); - } } template <> void ART::GenerateKeys(ArenaAllocator &allocator, DataChunk &input, unsafe_vector &keys) { GenerateKeysInternal(allocator, input, keys); - if (!verify_max_key_len) { - return; - } - auto max_len = MAX_KEY_LEN * idx_t(prefix_count); - for (idx_t i = 0; i < input.size(); i++) { - keys[i].VerifyKeyLength(max_len); - } } void ART::GenerateKeyVectors(ArenaAllocator &allocator, DataChunk &input, Vector &row_ids, unsafe_vector &keys, @@ -705,8 +685,6 @@ bool ART::Scan(IndexScanState &state, const idx_t max_count, set &row_ids D_ASSERT(scan_state.values[0].type().InternalType() == types[0]); ArenaAllocator arena_allocator(Allocator::Get(db)); auto key = ARTKey::CreateKey(arena_allocator, types[0], scan_state.values[0]); - auto max_len = MAX_KEY_LEN * prefix_count; - key.VerifyKeyLength(max_len); lock_guard l(lock); if (scan_state.values[1].IsNull()) { @@ -730,7 +708,6 @@ bool ART::Scan(IndexScanState &state, const idx_t max_count, set &row_ids // Two predicates. D_ASSERT(scan_state.values[1].type().InternalType() == types[0]); auto upper_bound = ARTKey::CreateKey(arena_allocator, types[0], scan_state.values[1]); - upper_bound.VerifyKeyLength(max_len); bool left_equal = scan_state.expressions[0] == ExpressionType ::COMPARE_GREATERTHANOREQUALTO; bool right_equal = scan_state.expressions[1] == ExpressionType ::COMPARE_LESSTHANOREQUALTO; @@ -1032,9 +1009,6 @@ void ART::Deserialize(const BlockPointer &pointer) { } void ART::SetPrefixCount(const IndexStorageInfo &info) { - auto numeric_max = NumericLimits().Maximum(); - auto max_aligned = AlignValueFloor(numeric_max - Prefix::METADATA_SIZE); - if (info.IsValid() && info.root_block_ptr.IsValid()) { prefix_count = Prefix::DEPRECATED_COUNT; return; @@ -1051,13 +1025,18 @@ void ART::SetPrefixCount(const IndexStorageInfo &info) { compound_size += GetTypeIdSize(type); } - auto aligned = AlignValue(compound_size) - 1; - if (aligned > NumericCast(max_aligned)) { - prefix_count = max_aligned; - return; - } + // Get the maximum possible prefix size. + // Minus one to index the prefix count (last byte). + auto numeric_max = NumericLimits().Maximum(); + uint8_t max_aligned = AlignValueFloor(numeric_max - Prefix::METADATA_SIZE) - 1; + + // Ceiling of compound size, + // minus one to index the prefix count (last byte). + idx_t key_aligned = AlignValue(compound_size) - 1; - prefix_count = NumericCast(aligned); + // Set the prefix size to the maximum of the (compound) key size and the maximum prefix size. + bool exceeds_max = key_aligned > NumericCast(max_aligned); + prefix_count = exceeds_max ? max_aligned : NumericCast(key_aligned); } idx_t ART::GetInMemorySize(IndexLock &index_lock) { diff --git a/src/duckdb/src/execution/index/art/art_key.cpp b/src/duckdb/src/execution/index/art/art_key.cpp index 7a6df37ce..0d380701f 100644 --- a/src/duckdb/src/execution/index/art/art_key.cpp +++ b/src/duckdb/src/execution/index/art/art_key.cpp @@ -16,13 +16,6 @@ ARTKey::ARTKey(ArenaAllocator &allocator, idx_t len) : len(len) { data = allocator.Allocate(len); } -void ARTKey::VerifyKeyLength(const idx_t max_len) const { - if (len > max_len) { - throw InvalidInputException("key size of %d bytes exceeds the maximum size of %d bytes for this ART", len, - max_len); - } -} - template <> ARTKey ARTKey::CreateARTKey(ArenaAllocator &allocator, string_t value) { auto string_data = const_data_ptr_cast(value.GetData()); diff --git a/src/duckdb/src/execution/index/art/node.cpp b/src/duckdb/src/execution/index/art/node.cpp index fec9c9c70..917504777 100644 --- a/src/duckdb/src/execution/index/art/node.cpp +++ b/src/duckdb/src/execution/index/art/node.cpp @@ -359,32 +359,57 @@ bool Node::IsAnyLeaf() const { // TransformToDeprecated //===--------------------------------------------------------------------===// +template +static void TransformToDeprecatedPushChildren(ART &art, Node &node, NType type, vector> &stack) { + auto ptr = Node::InMemoryRef(art, node, type); + if (ptr) { + NODE::Iterator(*ptr, [&](Node &child) { stack.emplace_back(child); }); + } +} + void Node::TransformToDeprecated(ART &art, Node &node, TransformToDeprecatedState &state) { - D_ASSERT(node.HasMetadata()); + vector> stack; + stack.emplace_back(node); - if (node.GetGateStatus() == GateStatus::GATE_SET) { - D_ASSERT(node.GetType() != NType::LEAF_INLINED); - return Leaf::TransformToDeprecated(art, node); - } + while (!stack.empty()) { + Node ¤t = stack.back().get(); + stack.pop_back(); - auto type = node.GetType(); - switch (type) { - case NType::PREFIX: - return PrefixHandle::TransformToDeprecated(art, node, state); - case NType::LEAF_INLINED: - return; - case NType::LEAF: - return; - case NType::NODE_4: - return TransformToDeprecatedInternal(art, InMemoryRef(art, node, type), state); - case NType::NODE_16: - return TransformToDeprecatedInternal(art, InMemoryRef(art, node, type), state); - case NType::NODE_48: - return TransformToDeprecatedInternal(art, InMemoryRef(art, node, type), state); - case NType::NODE_256: - return TransformToDeprecatedInternal(art, InMemoryRef(art, node, type), state); - default: - throw InternalException("invalid node type for TransformToDeprecated: %d", type); + D_ASSERT(current.HasMetadata()); + + if (current.GetGateStatus() == GateStatus::GATE_SET) { + D_ASSERT(current.GetType() != NType::LEAF_INLINED); + Leaf::TransformToDeprecated(art, current); + continue; + } + + auto type = current.GetType(); + switch (type) { + case NType::PREFIX: { + auto child = PrefixHandle::TransformToDeprecated(art, current, state); + if (child) { + stack.emplace_back(*child); + } + break; + } + case NType::LEAF_INLINED: + case NType::LEAF: + break; + case NType::NODE_4: + TransformToDeprecatedPushChildren(art, current, type, stack); + break; + case NType::NODE_16: + TransformToDeprecatedPushChildren(art, current, type, stack); + break; + case NType::NODE_48: + TransformToDeprecatedPushChildren(art, current, type, stack); + break; + case NType::NODE_256: + TransformToDeprecatedPushChildren(art, current, type, stack); + break; + default: + throw InternalException("invalid node type for TransformToDeprecated: %d", type); + } } } diff --git a/src/duckdb/src/execution/index/art/prefix_handle.cpp b/src/duckdb/src/execution/index/art/prefix_handle.cpp index a8d954988..b52a5690e 100644 --- a/src/duckdb/src/execution/index/art/prefix_handle.cpp +++ b/src/duckdb/src/execution/index/art/prefix_handle.cpp @@ -48,19 +48,19 @@ PrefixHandle PrefixHandle::NewDeprecated(FixedSizeAllocator &allocator, Node &no return handle; } -void PrefixHandle::TransformToDeprecated(ART &art, Node &node, TransformToDeprecatedState &state) { +optional_ptr PrefixHandle::TransformToDeprecated(ART &art, Node &node, TransformToDeprecatedState &state) { // Early-out, if we do not need any transformations. if (!state.HasAllocator()) { reference ref(node); while (ref.get().GetType() == PREFIX && ref.get().GetGateStatus() == GateStatus::GATE_NOT_SET) { auto &alloc = Node::GetAllocator(art, PREFIX); if (!alloc.LoadedFromStorage(ref)) { - return; + return nullptr; } PrefixHandle handle(art, ref); ref = *handle.child; } - return Node::TransformToDeprecated(art, ref, state); + return ref.get(); } // We need to create a new prefix (chain) in the deprecated format. @@ -72,7 +72,7 @@ void PrefixHandle::TransformToDeprecated(ART &art, Node &node, TransformToDeprec while (current_node.GetType() == PREFIX && current_node.GetGateStatus() == GateStatus::GATE_NOT_SET) { auto &alloc = Node::GetAllocator(art, PREFIX); if (!alloc.LoadedFromStorage(current_node)) { - return; + return nullptr; } PrefixHandle current_handle(art, current_node); @@ -87,7 +87,7 @@ void PrefixHandle::TransformToDeprecated(ART &art, Node &node, TransformToDeprec } node = new_node; - return Node::TransformToDeprecated(art, *new_handle.child, state); + return new_handle.child; } PrefixHandle PrefixHandle::TransformToDeprecatedAppend(ART &art, FixedSizeAllocator &allocator, const uint8_t byte) { diff --git a/src/duckdb/src/execution/join_hashtable.cpp b/src/duckdb/src/execution/join_hashtable.cpp index ef2fe68ac..82d58290d 100644 --- a/src/duckdb/src/execution/join_hashtable.cpp +++ b/src/duckdb/src/execution/join_hashtable.cpp @@ -1,13 +1,14 @@ #include "duckdb/execution/join_hashtable.hpp" +#include "duckdb/common/enums/join_type.hpp" #include "duckdb/common/exception.hpp" #include "duckdb/common/radix_partitioning.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/execution/ht_entry.hpp" +#include "duckdb/logging/log_manager.hpp" #include "duckdb/main/client_context.hpp" -#include "duckdb/storage/buffer_manager.hpp" #include "duckdb/main/settings.hpp" -#include "duckdb/logging/log_manager.hpp" +#include "duckdb/storage/buffer_manager.hpp" namespace duckdb { @@ -109,7 +110,7 @@ JoinHashTable::JoinHashTable(ClientContext &context_p, const PhysicalOperator &o memset(dead_end.get(), 0, layout_ptr->GetRowWidth()); if (join_type == JoinType::SINGLE) { - single_join_error_on_multiple_rows = DBConfig::GetSetting(context); + single_join_error_on_multiple_rows = Settings::Get(context); } if (conditions.size() == 1 && @@ -1136,25 +1137,35 @@ void ScanStructure::NextRightSemiOrAntiJoin(DataChunk &keys) { // resolve the equality_predicates for this set of keys idx_t result_count = ResolvePredicates(keys, chain_match_sel_vector, nullptr); - // for each match, fully follow the chain - for (idx_t i = 0; i < result_count; i++) { - const auto idx = chain_match_sel_vector.get_index(i); - auto &ptr = ptrs[idx]; - if (Load(ptr + ht.tuple_size)) { // Early out: chain has been fully marked as found before - ptr = ht.dead_end.get(); - continue; - } + if (ht.non_equality_predicates.empty()) { + // we only have equality predicates - the match is found for the entire chain + for (idx_t i = 0; i < result_count; i++) { + const auto idx = chain_match_sel_vector.get_index(i); + auto &ptr = ptrs[idx]; + if (Load(ptr + ht.tuple_size)) { // Early out: chain has been fully marked as found before + ptr = ht.dead_end.get(); + continue; + } - // Fully mark chain as found - while (true) { - // NOTE: threadsan reports this as a data race because this can be set concurrently by separate threads - // Technically it is, but it does not matter, since the only value that can be written is "true" - Store(true, ptr + ht.tuple_size); - auto next_ptr = LoadPointer(ptr + ht.pointer_offset); - if (!next_ptr) { - break; + // Fully mark chain as found + while (true) { + // NOTE: threadsan reports this as a data race because this can be set concurrently by separate + // threads Technically it is, but it does not matter, since the only value that can be written is + // "true" + Store(true, ptr + ht.tuple_size); + auto next_ptr = LoadPointer(ptr + ht.pointer_offset); + if (!next_ptr) { + break; + } + ptr = next_ptr; } - ptr = next_ptr; + } + } else { + // we have non-equality predicates - we need to evaluate the join condition for every row + // for each match found in the current pass - mark the match as found + for (idx_t i = 0; i < result_count; i++) { + auto idx = chain_match_sel_vector.get_index(i); + Store(true, ptrs[idx] + ht.tuple_size); } } diff --git a/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp b/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp index 097994855..3f7082de4 100644 --- a/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp +++ b/src/duckdb/src/execution/operator/aggregate/physical_streaming_window.cpp @@ -185,16 +185,16 @@ class StreamingWindowState : public OperatorState { // Special case when we have buffered enough values for the output if (count < buffered) { // Shift down incomplete buffers - // Copy prev[buffered-count, buffered] => temp[0, count] + // Copy prev[count, buffered] => temp[0, buffered-count] source_count = buffered - count; FlatVector::Validity(temp).Reset(); - VectorOperations::Copy(prev, temp, buffered, source_count, 0); + VectorOperations::Copy(prev, temp, buffered, count, 0); - // Copy temp[0, count] => prev[0, count] + // Copy temp[0, buffered-count] => prev[0, buffered-count] FlatVector::Validity(prev).Reset(); - VectorOperations::Copy(temp, prev, count, 0, 0); - // Copy curr[0, buffered-count] => prev[count, buffered] - VectorOperations::Copy(curr, prev, source_count, 0, count); + VectorOperations::Copy(temp, prev, source_count, 0, 0); + // Copy curr[0, count] => prev[buffered-count, buffered] + VectorOperations::Copy(curr, prev, count, 0, source_count); } else { // Copy input values beyond what we have buffered source_count = count - buffered; diff --git a/src/duckdb/src/execution/operator/aggregate/physical_window.cpp b/src/duckdb/src/execution/operator/aggregate/physical_window.cpp index 5e23c8cd3..67a9bf5e2 100644 --- a/src/duckdb/src/execution/operator/aggregate/physical_window.cpp +++ b/src/duckdb/src/execution/operator/aggregate/physical_window.cpp @@ -280,7 +280,7 @@ static unique_ptr WindowExecutorFactory(BoundWindowExpression &w case ExpressionType::WINDOW_LAG: return make_uniq(wexpr, shared); case ExpressionType::WINDOW_FILL: - return make_uniq(wexpr, shared); + return make_uniq(wexpr, client, shared); case ExpressionType::WINDOW_FIRST_VALUE: return make_uniq(wexpr, shared); case ExpressionType::WINDOW_LAST_VALUE: @@ -298,7 +298,7 @@ WindowGlobalSinkState::WindowGlobalSinkState(const PhysicalWindow &op, ClientCon D_ASSERT(op.select_list[op.order_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW); auto &wexpr = op.select_list[op.order_idx]->Cast(); - const auto mode = DBConfig::GetSetting(client); + const auto mode = Settings::Get(client); for (idx_t expr_idx = 0; expr_idx < op.select_list.size(); ++expr_idx) { D_ASSERT(op.select_list[expr_idx]->GetExpressionClass() == ExpressionClass::BOUND_WINDOW); auto &wexpr = op.select_list[expr_idx]->Cast(); diff --git a/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp b/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp index 75a680b3b..bd71f73ca 100644 --- a/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp +++ b/src/duckdb/src/execution/operator/csv_scanner/util/csv_reader_options.cpp @@ -742,7 +742,7 @@ void CSVReaderOptions::ParseOption(ClientContext &context, const string &key, co sql_type_list.reserve(sql_type_names.size()); for (auto &sql_type : sql_type_names) { auto def_type = TransformStringToLogicalType(sql_type, context); - if (def_type.id() == LogicalTypeId::USER) { + if (def_type.id() == LogicalTypeId::UNBOUND) { throw BinderException("Unrecognized type \"%s\" for read_csv %s definition", sql_type, key); } sql_type_list.push_back(std::move(def_type)); diff --git a/src/duckdb/src/execution/operator/helper/physical_reset.cpp b/src/duckdb/src/execution/operator/helper/physical_reset.cpp index 4402d6e3e..d549d633b 100644 --- a/src/duckdb/src/execution/operator/helper/physical_reset.cpp +++ b/src/duckdb/src/execution/operator/helper/physical_reset.cpp @@ -1,4 +1,5 @@ #include "duckdb/execution/operator/helper/physical_reset.hpp" +#include "duckdb/execution/operator/helper/physical_set.hpp" #include "duckdb/common/string_util.hpp" #include "duckdb/main/database.hpp" @@ -12,10 +13,11 @@ void PhysicalReset::ResetExtensionVariable(ExecutionContext &context, DBConfig & extension_option.set_function(context.client, scope, extension_option.default_value); } if (scope == SetScope::GLOBAL) { - config.ResetOption(name); + config.ResetOption(extension_option); } else { auto &client_config = ClientConfig::GetConfig(context.client); - client_config.set_variables[name.ToStdString()] = extension_option.default_value; + auto setting_index = extension_option.setting_index.GetIndex(); + client_config.user_settings.SetUserSetting(setting_index, extension_option.default_value); } } @@ -29,32 +31,21 @@ SourceResultType PhysicalReset::GetDataInternal(ExecutionContext &context, DataC auto &config = DBConfig::GetConfig(context.client); config.CheckLock(name); auto option = DBConfig::GetOptionByName(name); - if (!option) { // check if this is an extra extension variable - auto entry = config.extension_parameters.find(name.ToStdString()); - if (entry == config.extension_parameters.end()) { + ExtensionOption extension_option; + if (!config.TryGetExtensionOption(name, extension_option)) { auto extension_name = Catalog::AutoloadExtensionByConfigName(context.client, name); - entry = config.extension_parameters.find(name.ToStdString()); - if (entry == config.extension_parameters.end()) { + if (!config.TryGetExtensionOption(name, extension_option)) { throw InvalidInputException("Extension parameter %s was not found after autoloading", name); } } - ResetExtensionVariable(context, config, entry->second); + ResetExtensionVariable(context, config, extension_option); return SourceResultType::FINISHED; } // Transform scope - SetScope variable_scope = scope; - if (variable_scope == SetScope::AUTOMATIC) { - if (option->set_local) { - variable_scope = SetScope::SESSION; - } else if (option->set_global) { - variable_scope = SetScope::GLOBAL; - } else { - variable_scope = option->default_scope; - } - } + SetScope variable_scope = PhysicalSet::GetSettingScope(*option, scope); if (option->default_value) { if (option->set_callback) { @@ -63,11 +54,12 @@ SourceResultType PhysicalReset::GetDataInternal(ExecutionContext &context, DataC Value reset_val = Value(option->default_value).CastAs(context.client, parameter_type); option->set_callback(info, reset_val); } + auto setting_index = option->setting_idx.GetIndex(); if (variable_scope == SetScope::SESSION) { auto &client_config = ClientConfig::GetConfig(context.client); - client_config.set_variables.erase(option->name); + client_config.user_settings.ClearSetting(setting_index); } else { - config.ResetGenericOption(option->name); + config.ResetGenericOption(setting_index); } return SourceResultType::FINISHED; } diff --git a/src/duckdb/src/execution/operator/helper/physical_set.cpp b/src/duckdb/src/execution/operator/helper/physical_set.cpp index 82f505113..c9d65340e 100644 --- a/src/duckdb/src/execution/operator/helper/physical_set.cpp +++ b/src/duckdb/src/execution/operator/helper/physical_set.cpp @@ -6,13 +6,13 @@ namespace duckdb { -void PhysicalSet::SetGenericVariable(ClientContext &context, const String &name, SetScope scope, Value target_value) { +void PhysicalSet::SetGenericVariable(ClientContext &context, idx_t setting_index, SetScope scope, Value target_value) { if (scope == SetScope::GLOBAL) { auto &config = DBConfig::GetConfig(context); - config.SetOption(name, std::move(target_value)); + config.SetOption(setting_index, std::move(target_value)); } else { auto &client_config = ClientConfig::GetConfig(context); - client_config.set_variables[name.ToStdString()] = std::move(target_value); + client_config.user_settings.SetUserSetting(setting_index, std::move(target_value)); } } @@ -26,7 +26,39 @@ void PhysicalSet::SetExtensionVariable(ClientContext &context, ExtensionOption & if (scope == SetScope::AUTOMATIC) { scope = extension_option.default_scope; } - SetGenericVariable(context, name, scope, std::move(target_value)); + auto setting_index = extension_option.setting_index.GetIndex(); + SetGenericVariable(context, setting_index, scope, std::move(target_value)); +} + +SetScope PhysicalSet::GetSettingScope(const ConfigurationOption &option, SetScope variable_scope) { + if (variable_scope == SetScope::AUTOMATIC) { + if (option.set_local) { + return SetScope::SESSION; + } + if (option.set_global) { + return SetScope::GLOBAL; + } + // generic setting + switch (option.scope) { + case SettingScopeTarget::LOCAL_ONLY: + case SettingScopeTarget::LOCAL_DEFAULT: + return SetScope::SESSION; + case SettingScopeTarget::GLOBAL_ONLY: + case SettingScopeTarget::GLOBAL_DEFAULT: + return SetScope::GLOBAL; + default: + throw InvalidInputException("Setting \"%s\" does not have a valid scope defined", option.name); + } + } + if (variable_scope == SetScope::SESSION && option.scope == SettingScopeTarget::GLOBAL_ONLY) { + throw InvalidInputException("Setting \"%s\" cannot be set as a session variable - it can only be set globally", + option.name); + } + if (variable_scope == SetScope::GLOBAL && option.scope == SettingScopeTarget::LOCAL_ONLY) { + throw InvalidInputException( + "Setting \"%s\" cannot be set as a global variable - it can only be set per session", option.name); + } + return variable_scope; } SourceResultType PhysicalSet::GetDataInternal(ExecutionContext &context, DataChunk &chunk, @@ -36,28 +68,18 @@ SourceResultType PhysicalSet::GetDataInternal(ExecutionContext &context, DataChu config.CheckLock(name); auto option = DBConfig::GetOptionByName(name); if (!option) { + ExtensionOption extension_option; // check if this is an extra extension variable - auto entry = config.extension_parameters.find(name.ToStdString()); - if (entry == config.extension_parameters.end()) { + if (!config.TryGetExtensionOption(name, extension_option)) { auto extension_name = Catalog::AutoloadExtensionByConfigName(context.client, name); - entry = config.extension_parameters.find(name.ToStdString()); - if (entry == config.extension_parameters.end()) { + if (!config.TryGetExtensionOption(name, extension_option)) { throw InvalidInputException("Extension parameter %s was not found after autoloading", name); } } - SetExtensionVariable(context.client, entry->second, name, scope, value); + SetExtensionVariable(context.client, extension_option, name, scope, value); return SourceResultType::FINISHED; } - SetScope variable_scope = scope; - if (variable_scope == SetScope::AUTOMATIC) { - if (option->set_local) { - variable_scope = SetScope::SESSION; - } else if (option->set_global) { - variable_scope = SetScope::GLOBAL; - } else { - variable_scope = option->default_scope; - } - } + SetScope variable_scope = GetSettingScope(*option, scope); Value input_val = value.CastAs(context.client, DBConfig::ParseLogicalType(option->parameter_type)); if (option->default_value) { @@ -65,7 +87,8 @@ SourceResultType PhysicalSet::GetDataInternal(ExecutionContext &context, DataChu SettingCallbackInfo info(context.client, variable_scope); option->set_callback(info, input_val); } - SetGenericVariable(context.client, option->name, variable_scope, std::move(input_val)); + auto setting_index = option->setting_idx.GetIndex(); + SetGenericVariable(context.client, setting_index, variable_scope, std::move(input_val)); return SourceResultType::FINISHED; } switch (variable_scope) { diff --git a/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp b/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp index 82dcdbe79..a88ed7269 100644 --- a/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp +++ b/src/duckdb/src/execution/operator/helper/physical_streaming_limit.cpp @@ -54,6 +54,9 @@ OperatorResultType PhysicalStreamingLimit::Execute(ExecutionContext &context, Da if (PhysicalLimit::HandleOffset(input, current_offset, offset.GetIndex(), limit.GetIndex())) { chunk.Reference(input); } + if (current_offset >= limit.GetIndex() + offset.GetIndex()) { + return chunk.size() == 0 ? OperatorResultType::FINISHED : OperatorResultType::HAVE_MORE_OUTPUT; + } return OperatorResultType::NEED_MORE_INPUT; } diff --git a/src/duckdb/src/execution/operator/helper/physical_transaction.cpp b/src/duckdb/src/execution/operator/helper/physical_transaction.cpp index 8e34f10b7..2e75990ca 100644 --- a/src/duckdb/src/execution/operator/helper/physical_transaction.cpp +++ b/src/duckdb/src/execution/operator/helper/physical_transaction.cpp @@ -32,7 +32,7 @@ SourceResultType PhysicalTransaction::GetDataInternal(ExecutionContext &context, if (info->modifier == TransactionModifierType::TRANSACTION_READ_ONLY) { client.transaction.SetReadOnly(); } - if (DBConfig::GetSetting(context.client)) { + if (Settings::Get(context.client)) { // if immediate transaction mode is enabled then start all transactions immediately auto databases = DatabaseManager::Get(client).GetDatabases(client); for (auto &db : databases) { diff --git a/src/duckdb/src/execution/operator/join/physical_hash_join.cpp b/src/duckdb/src/execution/operator/join/physical_hash_join.cpp index 12ec306b8..e7fb060b1 100644 --- a/src/duckdb/src/execution/operator/join/physical_hash_join.cpp +++ b/src/duckdb/src/execution/operator/join/physical_hash_join.cpp @@ -707,7 +707,7 @@ class HashJoinRepartitionEvent : public BasePipelineEvent { bool JoinFilterPushdownInfo::CanUseInFilter(const ClientContext &context, optional_ptr ht, const ExpressionType &cmp) const { - auto dynamic_or_filter_threshold = DBConfig::GetSetting(context); + auto dynamic_or_filter_threshold = Settings::Get(context); return ht && ht->Count() > 1 && ht->Count() <= dynamic_or_filter_threshold && cmp == ExpressionType::COMPARE_EQUAL; } diff --git a/src/duckdb/src/execution/operator/join/physical_iejoin.cpp b/src/duckdb/src/execution/operator/join/physical_iejoin.cpp index 5d26425e3..18e6e8c72 100644 --- a/src/duckdb/src/execution/operator/join/physical_iejoin.cpp +++ b/src/duckdb/src/execution/operator/join/physical_iejoin.cpp @@ -1,6 +1,7 @@ #include "duckdb/execution/operator/join/physical_iejoin.hpp" #include "duckdb/common/atomic.hpp" +#include "duckdb/common/bit_utils.hpp" #include "duckdb/common/row_operations/row_operations.hpp" #include "duckdb/common/sorting/sort_key.hpp" #include "duckdb/main/client_context.hpp" @@ -446,7 +447,7 @@ struct IEJoinUnion { IEJoinGlobalSourceState &gsource; //! Inverted loop - idx_t JoinComplexBlocks(vector &lsel, vector &rsel); + idx_t JoinComplexBlocks(idx_t *lsel, idx_t *rsel); //! B vector bit_array; @@ -672,11 +673,7 @@ static idx_t NextValid(const ValidityMask &bits, idx_t j, const idx_t n) { // Check the non-ragged entries for (const auto entry_count = bits.EntryCount(n); entry_idx < entry_count; ++entry_idx) { if (entry) { - for (; idx_in_entry < bits.BITS_PER_VALUE; ++idx_in_entry, ++j) { - if (bits.RowIsValid(entry, idx_in_entry)) { - return j; - } - } + return j + CountZeros::Trailing(entry) - idx_in_entry; } else { j += bits.BITS_PER_VALUE - idx_in_entry; } @@ -686,22 +683,14 @@ static idx_t NextValid(const ValidityMask &bits, idx_t j, const idx_t n) { } // Check the final entry - for (; j < n; ++idx_in_entry, ++j) { - if (bits.RowIsValid(entry, idx_in_entry)) { - return j; - } - } - - return j; + return MinValue(j + CountZeros::Trailing(entry) - idx_in_entry, n); } -idx_t IEJoinUnion::JoinComplexBlocks(vector &lsel, vector &rsel) { - auto &li = gsource.li; +idx_t IEJoinUnion::JoinComplexBlocks(idx_t *lsel, idx_t *rsel) { + auto li = gsource.li.data(); // 8. initialize join result as an empty list for tuple pairs idx_t result_count = 0; - lsel.resize(0); - rsel.resize(0); // 11. for(i←1 to n) do while (i < n) { @@ -731,8 +720,8 @@ idx_t IEJoinUnion::JoinComplexBlocks(vector &lsel, vector &rsel) { D_ASSERT(lrid > 0 && rrid < 0); // 15. add tuples w.r.t. (L1[j], L1[i]) to join result - lsel.emplace_back(idx_t(+lrid - 1)); - rsel.emplace_back(idx_t(-rrid - 1)); + lsel[result_count] = idx_t(+lrid - 1); + rsel[result_count] = idx_t(-rrid - 1); ++result_count; if (result_count == STANDARD_VECTOR_SIZE) { // out of space! @@ -1181,7 +1170,7 @@ void IEJoinLocalSourceState::ResolveComplexJoin(ExecutionContext &context, DataC auto &right_table = *ie_sink.tables[1]; do { - auto result_count = joiner->JoinComplexBlocks(lsel, rsel); + auto result_count = joiner->JoinComplexBlocks(lsel.data(), rsel.data()); if (result_count == 0) { // exhausted this pair joiner.reset(); diff --git a/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp b/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp index a96ea4d6d..220dc4503 100644 --- a/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp +++ b/src/duckdb/src/execution/operator/persistent/physical_copy_to_file.cpp @@ -51,7 +51,7 @@ class CopyToFunctionGlobalState : public GlobalSinkState { explicit CopyToFunctionGlobalState(ClientContext &context_p) : context(context_p), finalized(false), initialized(false), rows_copied(0), last_file_offset(0), file_write_lock_if_rotating(make_uniq()) { - max_open_files = DBConfig::GetSetting(context); + max_open_files = Settings::Get(context); } ~CopyToFunctionGlobalState() override; @@ -120,7 +120,11 @@ class CopyToFunctionGlobalState : public GlobalSinkState { string p_dir; p_dir += HivePartitioning::Escape(partition_col_name); p_dir += "="; - p_dir += HivePartitioning::Escape(partition_value.ToString()); + if (partition_value.IsNull()) { + p_dir += "__HIVE_DEFAULT_PARTITION__"; + } else { + p_dir += HivePartitioning::Escape(partition_value.ToString()); + } path = fs.JoinPath(path, p_dir); CreateDir(path, fs); } @@ -275,7 +279,7 @@ class CopyToFunctionLocalState : public LocalSinkState { public: explicit CopyToFunctionLocalState(ClientContext &context, unique_ptr local_state) : local_state(std::move(local_state)) { - partitioned_write_flush_threshold = DBConfig::GetSetting(context); + partitioned_write_flush_threshold = Settings::Get(context); } unique_ptr global_state; unique_ptr local_state; @@ -410,11 +414,6 @@ void CheckDirectory(FileSystem &fs, const string &file_path, CopyOverwriteMode o // with overwrite or ignore we fully ignore the presence of any files instead of erasing them return; } - if (fs.IsRemoteFile(file_path) && overwrite_mode == CopyOverwriteMode::COPY_OVERWRITE) { - // we can only remove files for local file systems currently - // as remote file systems (e.g. S3) do not support RemoveFile - throw NotImplementedException("OVERWRITE is not supported for remote file systems"); - } vector file_list; vector directory_list; directory_list.push_back(file_path); diff --git a/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp b/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp index c38036e1b..5ac221ec0 100644 --- a/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp +++ b/src/duckdb/src/execution/operator/scan/physical_table_scan.cpp @@ -30,8 +30,7 @@ PhysicalTableScan::PhysicalTableScan(PhysicalPlan &physical_plan, vector(context); + physical_table_scan_execution_strategy = Settings::Get(context); if (op.dynamic_filters && op.dynamic_filters->HasFilters()) { table_filters = op.dynamic_filters->GetFinalTableFilters(op, op.table_filters.get()); @@ -285,10 +284,26 @@ void AddProjectionNames(const ColumnIndex &index, const string &name, const Logi result += name; return; } - auto &child_types = StructType::GetChildTypes(type); - for (auto &child_index : index.GetChildIndexes()) { - auto &ele = child_types[child_index.GetPrimaryIndex()]; - AddProjectionNames(child_index, name + "." + ele.first, ele.second, result); + + if (type.id() == LogicalTypeId::STRUCT) { + auto &child_types = StructType::GetChildTypes(type); + for (auto &child_index : index.GetChildIndexes()) { + if (child_index.HasPrimaryIndex()) { + auto &ele = child_types[child_index.GetPrimaryIndex()]; + AddProjectionNames(child_index, name + "." + ele.first, ele.second, result); + } else { + auto field_type = child_index.HasType() ? child_index.GetType() : LogicalType::VARIANT(); + AddProjectionNames(child_index, name + "." + child_index.GetFieldName(), field_type, result); + } + } + } else if (type.id() == LogicalTypeId::VARIANT) { + for (auto &child_index : index.GetChildIndexes()) { + D_ASSERT(!child_index.HasPrimaryIndex()); + auto field_type = child_index.HasType() ? child_index.GetType() : LogicalType::VARIANT(); + AddProjectionNames(child_index, name + "." + child_index.GetFieldName(), field_type, result); + } + } else { + throw InternalException("Unexpected type (%s) in AddProjectionNames", type.ToString()); } } diff --git a/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp b/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp index 8bd9837bd..647ffad19 100644 --- a/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp @@ -217,7 +217,7 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate bits_per_group.push_back(required_bits); perfect_hash_bits += required_bits; // check if we have exceeded the bits for the hash - if (perfect_hash_bits > DBConfig::GetSetting(context)) { + if (perfect_hash_bits > Settings::Get(context)) { // too many bits for perfect hash return false; } diff --git a/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp b/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp index 3d84506fa..fba7600f2 100644 --- a/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_asof_join.cpp @@ -9,7 +9,7 @@ #include "duckdb/function/aggregate/distributive_function_utils.hpp" #include "duckdb/execution/physical_plan_generator.hpp" #include "duckdb/function/function_binder.hpp" -#include "duckdb/main/client_context.hpp" +#include "duckdb/planner/binder.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" #include "duckdb/planner/expression/bound_reference_expression.hpp" #include "duckdb/planner/expression/bound_window_expression.hpp" @@ -292,9 +292,9 @@ PhysicalOperator &PhysicalPlanGenerator::PlanAsOfJoin(LogicalComparisonJoin &op) // If there is a non-comparison predicate, we have to use NLJ. const bool has_predicate = op.predicate.get(); - const bool force_asof_join = DBConfig::GetSetting(context); + const bool force_asof_join = Settings::Get(context); if (!force_asof_join || has_predicate) { - const idx_t asof_join_threshold = DBConfig::GetSetting(context); + const idx_t asof_join_threshold = Settings::Get(context); if (has_predicate || (op.children[0]->has_estimated_cardinality && lhs_cardinality < asof_join_threshold)) { auto result = PlanAsOfLoopJoin(op, left, right); if (result) { diff --git a/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp b/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp index aeb77a800..8e8c19ed9 100644 --- a/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp @@ -51,7 +51,7 @@ PhysicalOperator &PhysicalPlanGenerator::PlanComparisonJoin(LogicalComparisonJoi break; } // TODO: Extend PWMJ to handle all comparisons and projection maps - bool prefer_range_joins = DBConfig::GetSetting(context); + bool prefer_range_joins = Settings::Get(context); prefer_range_joins = prefer_range_joins && can_iejoin; if (has_equality && !prefer_range_joins) { // Equality join with small number of keys : possible perfect join optimization @@ -63,7 +63,7 @@ PhysicalOperator &PhysicalPlanGenerator::PlanComparisonJoin(LogicalComparisonJoi } D_ASSERT(op.left_projection_map.empty()); - idx_t nested_loop_join_threshold = DBConfig::GetSetting(context); + idx_t nested_loop_join_threshold = Settings::Get(context); if (left.estimated_cardinality < nested_loop_join_threshold || right.estimated_cardinality < nested_loop_join_threshold) { can_iejoin = false; @@ -71,7 +71,7 @@ PhysicalOperator &PhysicalPlanGenerator::PlanComparisonJoin(LogicalComparisonJoi } if (can_merge && can_iejoin) { - idx_t merge_join_threshold = DBConfig::GetSetting(context); + idx_t merge_join_threshold = Settings::Get(context); if (left.estimated_cardinality < merge_join_threshold || right.estimated_cardinality < merge_join_threshold) { can_iejoin = false; } diff --git a/src/duckdb/src/execution/physical_plan/plan_explain.cpp b/src/duckdb/src/execution/physical_plan/plan_explain.cpp index 2bb227077..e9227b657 100644 --- a/src/duckdb/src/execution/physical_plan/plan_explain.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_explain.cpp @@ -3,8 +3,8 @@ #include "duckdb/execution/operator/helper/physical_explain_analyze.hpp" #include "duckdb/execution/operator/scan/physical_column_data_scan.hpp" #include "duckdb/execution/physical_plan_generator.hpp" -#include "duckdb/main/client_context.hpp" #include "duckdb/planner/operator/logical_explain.hpp" +#include "duckdb/main/settings.hpp" namespace duckdb { @@ -21,7 +21,7 @@ PhysicalOperator &PhysicalPlanGenerator::CreatePlan(LogicalExplain &op) { // Format the plan and set the output of the EXPLAIN. op.physical_plan = plan.ToString(op.explain_format); vector keys, values; - switch (ClientConfig::GetConfig(context).explain_output_type) { + switch (Settings::Get(context)) { case ExplainOutputType::OPTIMIZED_ONLY: keys = {"logical_opt"}; values = {logical_plan_opt}; diff --git a/src/duckdb/src/execution/physical_plan/plan_insert.cpp b/src/duckdb/src/execution/physical_plan/plan_insert.cpp index ab8df5393..bc7eda78c 100644 --- a/src/duckdb/src/execution/physical_plan/plan_insert.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_insert.cpp @@ -44,7 +44,7 @@ bool PhysicalPlanGenerator::PreserveInsertionOrder(ClientContext &context, Physi return false; } // preserve insertion order - check flags - if (!DBConfig::GetSetting(context)) { + if (!Settings::Get(context)) { // preserving insertion order is disabled by config return false; } diff --git a/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp b/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp index ee71c5509..cf4796d14 100644 --- a/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp +++ b/src/duckdb/src/execution/physical_plan/plan_set_operation.cpp @@ -1,4 +1,5 @@ #include "duckdb/execution/physical_plan_generator.hpp" + #include "duckdb/execution/operator/aggregate/physical_hash_aggregate.hpp" #include "duckdb/execution/operator/aggregate/physical_window.hpp" #include "duckdb/execution/operator/join/physical_hash_join.hpp" @@ -6,11 +7,13 @@ #include "duckdb/execution/operator/set/physical_union.hpp" #include "duckdb/planner/expression/bound_reference_expression.hpp" #include "duckdb/planner/expression/bound_window_expression.hpp" +#include "duckdb/planner/expression_binder.hpp" #include "duckdb/planner/operator/logical_set_operation.hpp" namespace duckdb { -static vector> CreatePartitionedRowNumExpression(const vector &types) { +static vector> CreatePartitionedRowNumExpression(ClientContext &client, + const vector &types) { vector> res; auto expr = make_uniq(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT, nullptr, nullptr); @@ -18,6 +21,7 @@ static vector> CreatePartitionedRowNumExpression(const ve expr->end = WindowBoundary::UNBOUNDED_FOLLOWING; for (idx_t i = 0; i < types.size(); i++) { expr->partitions.push_back(make_uniq(types[i], i)); + ExpressionBinder::PushCollation(client, expr->partitions.back(), types[i]); } res.push_back(std::move(expr)); return res; @@ -71,13 +75,13 @@ PhysicalOperator &PhysicalPlanGenerator::CreatePlan(LogicalSetOperation &op) { vector window_types = types; window_types.push_back(LogicalType::BIGINT); - auto select_list = CreatePartitionedRowNumExpression(types); + auto select_list = CreatePartitionedRowNumExpression(context, types); auto &left_window = Make(window_types, std::move(select_list), left.get().estimated_cardinality); left_window.children.push_back(left); left = left_window; - select_list = CreatePartitionedRowNumExpression(types); + select_list = CreatePartitionedRowNumExpression(context, types); auto &right_window = Make(window_types, std::move(select_list), right.get().estimated_cardinality); right_window.children.push_back(right); diff --git a/src/duckdb/src/execution/physical_plan_generator.cpp b/src/duckdb/src/execution/physical_plan_generator.cpp index 30a28ea70..c5d583bec 100644 --- a/src/duckdb/src/execution/physical_plan_generator.cpp +++ b/src/duckdb/src/execution/physical_plan_generator.cpp @@ -57,7 +57,7 @@ unique_ptr PhysicalPlanGenerator::PlanInternal(LogicalOperator &op physical_plan->SetRoot(CreatePlan(op)); physical_plan->Root().estimated_cardinality = op.estimated_cardinality; - auto debug_verify_vector = DBConfig::GetSetting(context); + auto debug_verify_vector = Settings::Get(context); if (debug_verify_vector != DebugVectorVerification::NONE) { if (debug_verify_vector != DebugVectorVerification::DICTIONARY_EXPRESSION && debug_verify_vector != DebugVectorVerification::VARIANT_VECTOR) { diff --git a/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp b/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp index 0eed72d84..2b6b3bdf8 100644 --- a/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp +++ b/src/duckdb/src/function/aggregate/distributive/first_last_any.cpp @@ -1,5 +1,4 @@ #include "duckdb/common/exception.hpp" -#include "duckdb/common/vector_operations/vector_operations.hpp" #include "duckdb/function/aggregate/distributive_functions.hpp" #include "duckdb/function/aggregate/distributive_function_utils.hpp" #include "duckdb/function/create_sort_key.hpp" @@ -222,16 +221,38 @@ template void FirstFunctionSimpleUpdate(Vector inputs[], AggregateInputData &aggregate_input_data, idx_t input_count, data_ptr_t state, idx_t count) { auto agg_state = reinterpret_cast *>(state); - if (LAST || !agg_state->is_set) { + if (LAST) { + // For LAST, iterate backward within each batch to find the last value + // This saves iterating through all elements when we only need the last one + D_ASSERT(input_count == 1); + UnifiedVectorFormat idata; + inputs[0].ToUnifiedFormat(count, idata); + auto input_data = UnifiedVectorFormat::GetData(idata); + + for (idx_t i = count; i-- > 0;) { + const auto idx = idata.sel->get_index(i); + const auto row_valid = idata.validity.RowIsValid(idx); + if (SKIP_NULLS && !row_valid) { + continue; + } + // Found the last value in this batch - update state and exit + agg_state->is_set = true; + agg_state->is_null = !row_valid; + if (row_valid) { + agg_state->value = input_data[idx]; + } + break; + } + // If we get here with SKIP_NULLS, all values were NULL - keep previous state + } else if (!agg_state->is_set) { // For FIRST, this skips looping over the input once the aggregate state has been set - // FIXME: for LAST we could loop from the back of the Vector instead AggregateFunction::UnaryUpdate, T, FirstFunction>(inputs, aggregate_input_data, input_count, state, count); } } template -AggregateFunction GetFirstAggregateTemplated(LogicalType type) { +AggregateFunction GetFirstAggregateTemplated(const LogicalType &type) { auto result = AggregateFunction::UnaryAggregate, T, T, FirstFunction>(type, type); result.SetStateSimpleUpdateCallback(FirstFunctionSimpleUpdate); return result; diff --git a/src/duckdb/src/function/aggregate/distributive/minmax.cpp b/src/duckdb/src/function/aggregate/distributive/minmax.cpp index ce8f80aea..40c96d412 100644 --- a/src/duckdb/src/function/aggregate/distributive/minmax.cpp +++ b/src/duckdb/src/function/aggregate/distributive/minmax.cpp @@ -335,7 +335,7 @@ unique_ptr BindMinMax(ClientContext &context, AggregateFunction &f vector> &arguments) { if (arguments[0]->return_type.id() == LogicalTypeId::VARCHAR) { auto str_collation = StringType::GetCollation(arguments[0]->return_type); - if (!str_collation.empty() || !DBConfig::GetSetting(context).empty()) { + if (!str_collation.empty() || !Settings::Get(context).empty()) { // If aggr function is min/max and uses collations, replace bound_function with arg_min/arg_max // to make sure the result's correctness. string function_name = function.name == "min" ? "arg_min" : "arg_max"; diff --git a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp b/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp index ea78de81b..9f08f7189 100644 --- a/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp +++ b/src/duckdb/src/function/aggregate/sorted_aggregate_function.cpp @@ -24,7 +24,7 @@ struct SortedAggregateBindData : public FunctionData { SortedAggregateBindData(ClientContext &context, Expressions &children, AggregateFunction &aggregate, BindInfoPtr &bind_info, OrderBys &order_bys) : context(context), function(aggregate), bind_info(std::move(bind_info)), - threshold(DBConfig::GetSetting(context)) { + threshold(Settings::Get(context)) { // Describe the arguments. for (const auto &child : children) { buffered_cols.emplace_back(buffered_cols.size()); diff --git a/src/duckdb/src/function/cast/cast_function_set.cpp b/src/duckdb/src/function/cast/cast_function_set.cpp index 606fa9010..ae4ac3846 100644 --- a/src/duckdb/src/function/cast/cast_function_set.cpp +++ b/src/duckdb/src/function/cast/cast_function_set.cpp @@ -179,9 +179,9 @@ int64_t CastFunctionSet::ImplicitCastCost(optional_ptr context, c if (score < 0 && source.id() != LogicalTypeId::BLOB && target.id() == LogicalTypeId::VARCHAR) { bool old_implicit_casting = false; if (context) { - old_implicit_casting = DBConfig::GetSetting(*context); + old_implicit_casting = Settings::Get(*context); } else if (config) { - old_implicit_casting = DBConfig::GetSetting(*config); + old_implicit_casting = Settings::Get(*config); } if (old_implicit_casting) { // very high cost to avoid choosing this cast if any other option is available diff --git a/src/duckdb/src/function/cast/default_casts.cpp b/src/duckdb/src/function/cast/default_casts.cpp index 558329f70..9ee5f6957 100644 --- a/src/duckdb/src/function/cast/default_casts.cpp +++ b/src/duckdb/src/function/cast/default_casts.cpp @@ -164,6 +164,8 @@ BoundCastInfo DefaultCasts::GetDefaultCastFunction(BindCastInput &input, const L return ArrayCastSwitch(input, source, target); case LogicalTypeId::GEOMETRY: return GeoCastSwitch(input, source, target); + case LogicalTypeId::TYPE: + return TypeCastSwitch(input, source, target); case LogicalTypeId::BIGNUM: return BignumCastSwitch(input, source, target); case LogicalTypeId::AGGREGATE_STATE: diff --git a/src/duckdb/src/function/cast/list_casts.cpp b/src/duckdb/src/function/cast/list_casts.cpp index 156b43143..bf9fcea0b 100644 --- a/src/duckdb/src/function/cast/list_casts.cpp +++ b/src/duckdb/src/function/cast/list_casts.cpp @@ -98,7 +98,7 @@ static bool ListToVarcharCast(Vector &source, Vector &result, idx_t count, CastP static constexpr const idx_t SEP_LENGTH = 2; static constexpr const idx_t NULL_LENGTH = 4; unsafe_unique_array needs_quotes; - idx_t needs_quotes_length; + idx_t needs_quotes_length = DConstants::INVALID_INDEX; for (idx_t i = 0; i < count; i++) { if (!validity.RowIsValid(i)) { diff --git a/src/duckdb/src/function/cast/map_cast.cpp b/src/duckdb/src/function/cast/map_cast.cpp index ee8a4b11a..a8ea727a4 100644 --- a/src/duckdb/src/function/cast/map_cast.cpp +++ b/src/duckdb/src/function/cast/map_cast.cpp @@ -64,7 +64,7 @@ static bool MapToVarcharCast(Vector &source, Vector &result, idx_t count, CastPa auto result_data = FlatVector::GetData(result); unsafe_unique_array key_needs_quotes; unsafe_unique_array value_needs_quotes; - idx_t needs_quotes_length; + idx_t needs_quotes_length = DConstants::INVALID_INDEX; for (idx_t i = 0; i < count; i++) { if (!validity.RowIsValid(i)) { FlatVector::SetNull(result, i, true); diff --git a/src/duckdb/src/function/cast/type_cast.cpp b/src/duckdb/src/function/cast/type_cast.cpp new file mode 100644 index 000000000..3984e79f1 --- /dev/null +++ b/src/duckdb/src/function/cast/type_cast.cpp @@ -0,0 +1,15 @@ +#include "duckdb/function/cast/default_casts.hpp" +#include "duckdb/function/cast/vector_cast_helpers.hpp" + +namespace duckdb { + +BoundCastInfo DefaultCasts::TypeCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target) { + // now switch on the result type + if (target == LogicalType::VARCHAR) { + // type to varchar + return BoundCastInfo(&VectorCastHelpers::StringCast); + } + return nullptr; +} + +} // namespace duckdb diff --git a/src/duckdb/src/function/cast/variant/from_variant.cpp b/src/duckdb/src/function/cast/variant/from_variant.cpp index a70e65683..65f8acbd4 100644 --- a/src/duckdb/src/function/cast/variant/from_variant.cpp +++ b/src/duckdb/src/function/cast/variant/from_variant.cpp @@ -203,9 +203,18 @@ static bool ConvertVariantToList(FromVariantConversionData &conversion_data, Vec child_data = reinterpret_cast(owned_child_data.get()); } - auto collection_result = - VariantUtils::CollectNestedData(conversion_data.variant, VariantLogicalType::ARRAY, sel, count, row, offset, - child_data, FlatVector::Validity(result)); + //! Initialize the validity with that of the result (in case some rows are already set to invalid, we need to + //! respect that) + auto &result_validity = FlatVector::Validity(result); + ValidityMask validity(count); + for (idx_t i = 0; i < count; i++) { + if (!result_validity.RowIsValid(offset + i)) { + validity.SetInvalid(i); + } + } + + auto collection_result = VariantUtils::CollectNestedData(conversion_data.variant, VariantLogicalType::ARRAY, sel, + count, row, offset, child_data, validity); if (!collection_result.success) { conversion_data.error = StringUtil::Format("Expected to find VARIANT(ARRAY), found VARIANT(%s) instead, can't convert", @@ -216,7 +225,7 @@ static bool ConvertVariantToList(FromVariantConversionData &conversion_data, Vec idx_t max_children = 0; for (idx_t i = 0; i < count; i++) { auto &child_data_entry = child_data[i]; - if (child_data_entry.is_null) { + if (!validity.RowIsValid(i)) { continue; } if (child_data_entry.child_count > max_children) { @@ -239,7 +248,7 @@ static bool ConvertVariantToList(FromVariantConversionData &conversion_data, Vec auto row_index = row.IsValid() ? row.GetIndex() : i; auto &child_data_entry = child_data[i]; - if (child_data_entry.is_null) { + if (!validity.RowIsValid(i)) { FlatVector::SetNull(result, offset + i, true); continue; } @@ -269,9 +278,18 @@ static bool ConvertVariantToArray(FromVariantConversionData &conversion_data, Ve child_data = reinterpret_cast(owned_child_data.get()); } - auto collection_result = - VariantUtils::CollectNestedData(conversion_data.variant, VariantLogicalType::ARRAY, sel, count, row, offset, - child_data, FlatVector::Validity(result)); + //! Initialize the validity with that of the result (in case some rows are already set to invalid, we need to + //! respect that) + auto &result_validity = FlatVector::Validity(result); + ValidityMask validity(count); + for (idx_t i = 0; i < count; i++) { + if (!result_validity.RowIsValid(offset + i)) { + validity.SetInvalid(i); + } + } + + auto collection_result = VariantUtils::CollectNestedData(conversion_data.variant, VariantLogicalType::ARRAY, sel, + count, row, offset, child_data, validity); if (!collection_result.success) { conversion_data.error = StringUtil::Format("Expected to find VARIANT(ARRAY), found VARIANT(%s) instead, can't convert", @@ -282,7 +300,7 @@ static bool ConvertVariantToArray(FromVariantConversionData &conversion_data, Ve const auto array_size = ArrayType::GetSize(result.GetType()); for (idx_t i = 0; i < count; i++) { auto &child_data_entry = child_data[i]; - if (child_data_entry.is_null) { + if (!validity.RowIsValid(i)) { continue; } if (child_data_entry.child_count != array_size) { @@ -302,7 +320,7 @@ static bool ConvertVariantToArray(FromVariantConversionData &conversion_data, Ve auto row_index = row.IsValid() ? row.GetIndex() : i; auto &child_data_entry = child_data[i]; - if (child_data_entry.is_null) { + if (!validity.RowIsValid(i)) { FlatVector::SetNull(result, offset + i, true); total_offset += array_size; continue; @@ -327,9 +345,18 @@ static bool ConvertVariantToStruct(FromVariantConversionData &conversion_data, V child_data = reinterpret_cast(owned_child_data.get()); } - auto collection_result = - VariantUtils::CollectNestedData(conversion_data.variant, VariantLogicalType::OBJECT, sel, count, row, offset, - child_data, FlatVector::Validity(result)); + //! Initialize the validity with that of the result (in case some rows are already set to invalid, we need to + //! respect that) + auto &result_validity = FlatVector::Validity(result); + ValidityMask validity(count); + for (idx_t i = 0; i < count; i++) { + if (!result_validity.RowIsValid(offset + i)) { + validity.SetInvalid(i); + } + } + + auto collection_result = VariantUtils::CollectNestedData(conversion_data.variant, VariantLogicalType::OBJECT, sel, + count, row, offset, child_data, validity); if (!collection_result.success) { conversion_data.error = StringUtil::Format("Expected to find VARIANT(OBJECT), found VARIANT(%s) instead, can't convert", @@ -338,7 +365,7 @@ static bool ConvertVariantToStruct(FromVariantConversionData &conversion_data, V } for (idx_t i = 0; i < count; i++) { - if (child_data[i].is_null) { + if (!validity.RowIsValid(i)) { FlatVector::SetNull(result, offset + i, true); } } @@ -367,7 +394,7 @@ static bool ConvertVariantToStruct(FromVariantConversionData &conversion_data, V component.lookup_mode = VariantChildLookupMode::BY_KEY; ValidityMask lookup_validity(count); VariantUtils::FindChildValues(conversion_data.variant, component, row_sel, child_values_sel, lookup_validity, - child_data, count); + child_data, validity, count); if (!lookup_validity.AllValid()) { optional_idx nested_index; for (idx_t i = 0; i < count; i++) { diff --git a/src/duckdb/src/function/function_binder.cpp b/src/duckdb/src/function/function_binder.cpp index 8521dfe71..2d5b8366b 100644 --- a/src/duckdb/src/function/function_binder.cpp +++ b/src/duckdb/src/function/function_binder.cpp @@ -14,6 +14,7 @@ #include "duckdb/planner/expression/bound_constant_expression.hpp" #include "duckdb/planner/expression/bound_function_expression.hpp" #include "duckdb/planner/expression_binder.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/function/function_list.cpp b/src/duckdb/src/function/function_list.cpp index 4e269f060..4ceb3d555 100644 --- a/src/duckdb/src/function/function_list.cpp +++ b/src/duckdb/src/function/function_list.cpp @@ -110,6 +110,7 @@ static const StaticFunctionDefinition function[] = { DUCKDB_AGGREGATE_FUNCTION_SET(FirstFun), DUCKDB_SCALAR_FUNCTION(GetVariableFun), DUCKDB_SCALAR_FUNCTION(IlikeEscapeFun), + DUCKDB_SCALAR_FUNCTION(InvokeFun), DUCKDB_AGGREGATE_FUNCTION_SET(LastFun), DUCKDB_SCALAR_FUNCTION_ALIAS(LcaseFun), DUCKDB_SCALAR_FUNCTION_SET_ALIAS(LenFun), diff --git a/src/duckdb/src/function/pragma/pragma_queries.cpp b/src/duckdb/src/function/pragma/pragma_queries.cpp index 62ce195df..7f4f80bbc 100644 --- a/src/duckdb/src/function/pragma/pragma_queries.cpp +++ b/src/duckdb/src/function/pragma/pragma_queries.cpp @@ -202,7 +202,7 @@ static string PragmaDatabaseSize(ClientContext &context, const FunctionParameter } static string PragmaStorageInfo(ClientContext &context, const FunctionParameters ¶meters) { - return StringUtil::Format("SELECT * FROM pragma_storage_info('%s');", parameters.values[0].ToString()); + return StringUtil::Format("SELECT * FROM pragma_storage_info(%s);", SQLString(parameters.values[0].ToString())); } static string PragmaMetadataInfo(ClientContext &context, const FunctionParameters ¶meters) { diff --git a/src/duckdb/src/function/scalar/generic/invoke.cpp b/src/duckdb/src/function/scalar/generic/invoke.cpp new file mode 100644 index 000000000..9595a7757 --- /dev/null +++ b/src/duckdb/src/function/scalar/generic/invoke.cpp @@ -0,0 +1,105 @@ +#include "duckdb/function/scalar/generic_functions.hpp" +#include "duckdb/function/lambda_functions.hpp" +#include "duckdb/common/serializer/serializer.hpp" +#include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/planner/expression/bound_lambda_expression.hpp" + +namespace duckdb { + +namespace { + +struct LambdaInvokeData final : public LambdaFunctionData { + unique_ptr lambda_expr; + + explicit LambdaInvokeData(unique_ptr lambda_expr_p) : lambda_expr(std::move(lambda_expr_p)) { + } + + unique_ptr Copy() const override { + auto lambda_expr_copy = lambda_expr ? lambda_expr->Copy() : nullptr; + return make_uniq(std::move(lambda_expr_copy)); + } + + bool Equals(const FunctionData &other_p) const override { + auto &other = other_p.Cast(); + return Expression::Equals(lambda_expr, other.lambda_expr); + } + + //! Serializes a lambda function's bind data + static void Serialize(Serializer &serializer, const optional_ptr bind_data_p, + const ScalarFunction &function) { + auto &bind_data = bind_data_p->Cast(); + serializer.WritePropertyWithDefault(101, "lambda_expr", bind_data.lambda_expr, unique_ptr()); + } + + //! Deserializes a lambda function's bind data + static unique_ptr Deserialize(Deserializer &deserializer, ScalarFunction &) { + auto lambda_expr = deserializer.ReadPropertyWithExplicitDefault>( + 101, "lambda_expr", unique_ptr()); + return make_uniq(std::move(lambda_expr)); + } + + const unique_ptr &GetLambdaExpression() const override { + return lambda_expr->Cast().lambda_expr; + } +}; + +struct LambdaInvokeState final : public FunctionLocalState { + unique_ptr executor; + + explicit LambdaInvokeState(unique_ptr executor_p) : executor(std::move(executor_p)) { + } + + static unique_ptr Init(ExpressionState &state, const BoundFunctionExpression &expr, + FunctionData *bind_data) { + auto &bdata = bind_data->Cast(); + auto &bound_lambda_expr = bdata.lambda_expr->Cast(); + auto executor = make_uniq(state.GetContext(), *bound_lambda_expr.lambda_expr); + return make_uniq(std::move(executor)); + } +}; + +void LambdaInvokeFunction(DataChunk &args, ExpressionState &state, Vector &result) { + auto &lstate = ExecuteFunctionState::GetFunctionState(state)->Cast(); + lstate.executor->ExecuteExpression(args, result); +} + +unique_ptr LambdaInvokeBind(ClientContext &context, ScalarFunction &bound_function, + vector> &arguments) { + // the list column and the bound lambda expression + if (arguments[0]->GetExpressionClass() != ExpressionClass::BOUND_LAMBDA) { + throw BinderException("Invalid lambda expression passed to 'invoke' function."); + } + + auto &bound_lambda_expr = arguments[0]->Cast(); + if (bound_lambda_expr.parameter_count != arguments.size() - 1) { + throw BinderException("The number of lambda parameters does not match the number of arguments passed to the " + "'invoke' function, expected %d, got %d.", + bound_lambda_expr.parameter_count, arguments.size() - 1); + } + + bound_function.SetReturnType(bound_lambda_expr.lambda_expr->return_type); + + return make_uniq(bound_lambda_expr.Copy()); +} + +LogicalType LambdaInvokeBindParameters(ClientContext &context, const vector &function_child_types, + const idx_t parameter_idx) { + // The first parameter is always the lambda + return function_child_types[1 + parameter_idx]; +} + +} // namespace + +ScalarFunction InvokeFun::GetFunction() { + ScalarFunction fun("invoke", {LogicalType::LAMBDA, LogicalType::ANY}, LogicalType::ANY, LambdaInvokeFunction); + fun.bind = LambdaInvokeBind; + fun.varargs = LogicalType::ANY; + fun.SetNullHandling(FunctionNullHandling::SPECIAL_HANDLING); + fun.SetBindLambdaCallback(LambdaInvokeBindParameters); + fun.SetInitStateCallback(LambdaInvokeState::Init); + fun.SetSerializeCallback(LambdaInvokeData::Serialize); + fun.SetDeserializeCallback(LambdaInvokeData::Deserialize); + return fun; +} + +} // namespace duckdb diff --git a/src/duckdb/src/function/scalar/operator/arithmetic.cpp b/src/duckdb/src/function/scalar/operator/arithmetic.cpp index 83224332b..e47b59dab 100644 --- a/src/duckdb/src/function/scalar/operator/arithmetic.cpp +++ b/src/duckdb/src/function/scalar/operator/arithmetic.cpp @@ -5,6 +5,7 @@ #include "duckdb/common/operator/add.hpp" #include "duckdb/common/operator/interpolate.hpp" #include "duckdb/common/operator/multiply.hpp" +#include "duckdb/common/operator/negate.hpp" #include "duckdb/common/operator/numeric_binary_operators.hpp" #include "duckdb/common/operator/subtract.hpp" #include "duckdb/common/serializer/deserializer.hpp" @@ -531,35 +532,6 @@ ScalarFunctionSet OperatorAddFun::GetFunctions() { //===--------------------------------------------------------------------===// // - [subtract] //===--------------------------------------------------------------------===// -namespace { - -struct NegateOperator { - template - static bool CanNegate(T input) { - using Limits = NumericLimits; - return !(Limits::IsSigned() && Limits::Minimum() == input); - } - - template - static inline TR Operation(TA input) { - auto cast = (TR)input; - if (!CanNegate(cast)) { - throw OutOfRangeException("Overflow in negation of integer!"); - } - return -cast; - } -}; - -template <> -bool NegateOperator::CanNegate(float input) { - return true; -} - -template <> -bool NegateOperator::CanNegate(double input) { - return true; -} - template <> interval_t NegateOperator::Operation(interval_t input) { interval_t result; @@ -670,8 +642,6 @@ unique_ptr NegateBindStatistics(ClientContext &context, Function return stats.ToUnique(); } -} // namespace - ScalarFunction SubtractFunction::GetFunction(const LogicalType &type) { if (type.id() == LogicalTypeId::INTERVAL) { ScalarFunction func("-", {type}, type, ScalarFunction::UnaryFunction); @@ -1100,7 +1070,7 @@ scalar_function_t GetBinaryFunctionIgnoreZero(PhysicalType type) { template unique_ptr BindBinaryFloatingPoint(ClientContext &context, ScalarFunction &bound_function, vector> &arguments) { - if (DBConfig::GetSetting(context)) { + if (Settings::Get(context)) { bound_function.SetFunctionCallback(GetScalarBinaryFunction(bound_function.GetReturnType().InternalType())); } else { bound_function.SetFunctionCallback( diff --git a/src/duckdb/src/function/scalar/string/caseconvert.cpp b/src/duckdb/src/function/scalar/string/caseconvert.cpp index 0309b79f7..0a9f50f4a 100644 --- a/src/duckdb/src/function/scalar/string/caseconvert.cpp +++ b/src/duckdb/src/function/scalar/string/caseconvert.cpp @@ -30,21 +30,21 @@ template static idx_t GetResultLength(const char *input_data, idx_t input_length) { idx_t output_length = 0; for (idx_t i = 0; i < input_length;) { - if (input_data[i] & 0x80) { - // unicode - int sz = 0; - auto codepoint = Utf8Proc::UTF8ToCodepoint(input_data + i, sz); - auto converted_codepoint = - IS_UPPER ? Utf8Proc::CodepointToUpper(codepoint) : Utf8Proc::CodepointToLower(codepoint); - auto new_sz = Utf8Proc::CodepointLength(converted_codepoint); - D_ASSERT(new_sz >= 0); - output_length += UnsafeNumericCast(new_sz); - i += UnsafeNumericCast(sz); - } else { - // ascii + if (!(input_data[i] & 0x80)) { + // ASCII. output_length++; i++; + continue; } + + // UTF-8. + int sz = 0; + auto codepoint = Utf8Proc::UTF8ToCodepoint(input_data + i, sz); + auto converted = IS_UPPER ? Utf8Proc::CodepointToUpper(codepoint) : Utf8Proc::CodepointToLower(codepoint); + auto new_sz = Utf8Proc::CodepointLength(converted); + output_length += UnsafeNumericCast(new_sz); + D_ASSERT(sz != 0); + i += UnsafeNumericCast(sz); } return output_length; } diff --git a/src/duckdb/src/function/scalar/variant/variant_extract.cpp b/src/duckdb/src/function/scalar/variant/variant_extract.cpp index 118175004..05bcd6351 100644 --- a/src/duckdb/src/function/scalar/variant/variant_extract.cpp +++ b/src/duckdb/src/function/scalar/variant/variant_extract.cpp @@ -8,42 +8,21 @@ namespace duckdb { -namespace { - -struct BindData : public FunctionData { -public: - explicit BindData(const string &str); - explicit BindData(uint32_t index); - BindData(const BindData &other) = default; - -public: - unique_ptr Copy() const override; - bool Equals(const FunctionData &other) const override; - -public: - VariantPathComponent component; -}; - -} // namespace - -BindData::BindData(const string &str) : FunctionData() { - component.lookup_mode = VariantChildLookupMode::BY_KEY; - component.key = str; +VariantExtractBindData::VariantExtractBindData(const string &str) : FunctionData(), component(str) { } -BindData::BindData(uint32_t index) : FunctionData() { +VariantExtractBindData::VariantExtractBindData(uint32_t index) : FunctionData() { if (index == 0) { throw BinderException("Extracting index 0 from VARIANT(ARRAY) is invalid, indexes are 1-based"); } - component.lookup_mode = VariantChildLookupMode::BY_INDEX; - component.index = index - 1; + component = VariantPathComponent(index - 1); } -unique_ptr BindData::Copy() const { - return make_uniq(*this); +unique_ptr VariantExtractBindData::Copy() const { + return make_uniq(*this); } -bool BindData::Equals(const FunctionData &other) const { - auto &bind_data = other.Cast(); +bool VariantExtractBindData::Equals(const FunctionData &other) const { + auto &bind_data = other.Cast(); if (bind_data.component.lookup_mode != component.lookup_mode) { return false; } @@ -68,62 +47,26 @@ static bool GetConstantArgument(ClientContext &context, Expression &expr, Value return false; } -optional_ptr FindShreddedStats(const BaseStatistics &shredded, - const VariantPathComponent &component) { - D_ASSERT(shredded.GetType().id() == LogicalTypeId::STRUCT); - D_ASSERT(StructType::GetChildTypes(shredded.GetType()).size() == 2); - - auto &typed_value_type = StructType::GetChildTypes(shredded.GetType())[1].second; - auto &typed_value_stats = StructStats::GetChildStats(shredded, 1); - switch (component.lookup_mode) { - case VariantChildLookupMode::BY_INDEX: { - if (typed_value_type.id() != LogicalTypeId::LIST) { - return nullptr; - } - auto &child_stats = ListStats::GetChildStats(typed_value_stats); - return child_stats; - } - case VariantChildLookupMode::BY_KEY: { - if (typed_value_type.id() != LogicalTypeId::STRUCT) { - return nullptr; - } - auto &object_fields = StructType::GetChildTypes(typed_value_type); - for (idx_t i = 0; i < object_fields.size(); i++) { - auto &object_field = object_fields[i]; - if (StringUtil::CIEquals(object_field.first, component.key)) { - return StructStats::GetChildStats(typed_value_stats, i); - } - } - return nullptr; - } - default: - throw InternalException("VariantChildLookupMode::%s not implemented for FindShreddedStats", - EnumUtil::ToString(component.lookup_mode)); - } -} - static unique_ptr VariantExtractPropagateStats(ClientContext &context, FunctionStatisticsInput &input) { auto &child_stats = input.child_stats; auto &bind_data = input.bind_data; - auto &info = bind_data->Cast(); + auto &info = bind_data->Cast(); auto &variant_stats = child_stats[0]; const bool is_shredded = VariantStats::IsShredded(variant_stats); if (!is_shredded) { return nullptr; } auto &shredded_stats = VariantStats::GetShreddedStats(variant_stats); - auto found_stats = FindShreddedStats(shredded_stats, info.component); - if (!found_stats) { + if (!VariantShreddedStats::IsFullyShredded(shredded_stats)) { + return nullptr; + } + auto found_stats = VariantShreddedStats::FindChildStats(shredded_stats, info.component); + if (!found_stats || !VariantShreddedStats::IsFullyShredded(*found_stats)) { return nullptr; } - auto &unshredded_stats = VariantStats::GetUnshreddedStats(variant_stats); - auto child_variant_stats = VariantStats::CreateShredded(found_stats->GetType()); - VariantStats::SetUnshreddedStats(child_variant_stats, unshredded_stats); - VariantStats::SetShreddedStats(child_variant_stats, *found_stats); - - return child_variant_stats.ToUnique(); + return VariantStats::WrapExtractedFieldAsVariant(variant_stats, *found_stats); } static unique_ptr VariantExtractBind(ClientContext &context, ScalarFunction &bound_function, @@ -143,29 +86,16 @@ static unique_ptr VariantExtractBind(ClientContext &context, Scala } if (constant_arg.type().id() == LogicalTypeId::VARCHAR) { - return make_uniq(constant_arg.GetValue()); + return make_uniq(constant_arg.GetValue()); } else if (constant_arg.type().id() == LogicalTypeId::UINTEGER) { - return make_uniq(constant_arg.GetValue()); + return make_uniq(constant_arg.GetValue()); } else { throw InternalException("Constant-folded argument was not of type UINTEGER or VARCHAR"); } } -//! FIXME: it could make sense to allow a third argument: 'default' -//! This can currently be achieved with COALESCE(TRY(), 'default') -static void VariantExtractFunction(DataChunk &input, ExpressionState &state, Vector &result) { - auto count = input.size(); - - D_ASSERT(input.ColumnCount() == 2); - auto &variant_vec = input.data[0]; - D_ASSERT(variant_vec.GetType() == LogicalType::VARIANT()); - - auto &path = input.data[1]; - D_ASSERT(path.GetVectorType() == VectorType::CONSTANT_VECTOR); - (void)path; - - auto &func_expr = state.expr.Cast(); - auto &info = func_expr.bind_info->Cast(); +void VariantUtils::VariantExtract(Vector &variant_vec, const vector &components, Vector &result, + idx_t count) { auto &allocator = Allocator::DefaultAllocator(); RecursiveUnifiedVectorFormat source_format; @@ -176,58 +106,48 @@ static void VariantExtractFunction(DataChunk &input, ExpressionState &state, Vec //! Extract always starts by looking at value_index 0 SelectionVector value_index_sel; value_index_sel.Initialize(count); - for (idx_t i = 0; i < count; i++) { - value_index_sel[i] = 0; - } SelectionVector new_value_index_sel; new_value_index_sel.Initialize(count); + for (idx_t i = 0; i < count; i++) { + value_index_sel[i] = 0; + } + auto owned_nested_data = allocator.Allocate(sizeof(VariantNestedData) * count); auto nested_data = reinterpret_cast(owned_nested_data.get()); - auto &component = info.component; - auto expected_type = component.lookup_mode == VariantChildLookupMode::BY_INDEX ? VariantLogicalType::ARRAY - : VariantLogicalType::OBJECT; - auto collection_result = VariantUtils::CollectNestedData( - variant, expected_type, value_index_sel, count, optional_idx(), 0, nested_data, FlatVector::Validity(result)); - if (!collection_result.success) { - if (expected_type == VariantLogicalType::ARRAY) { - throw InvalidInputException("Can't extract index %d from a VARIANT(%s)", component.index, - EnumUtil::ToString(collection_result.wrong_type)); - } else { - D_ASSERT(expected_type == VariantLogicalType::OBJECT); - throw InvalidInputException("Can't extract key '%s' from a VARIANT(%s)", component.key, - EnumUtil::ToString(collection_result.wrong_type)); - } - } - - //! Look up the value_index of the child we're extracting - ValidityMask lookup_validity(count); - VariantUtils::FindChildValues(variant, component, nullptr, new_value_index_sel, lookup_validity, nested_data, - count); - if (!lookup_validity.AllValid()) { - optional_idx index; - for (idx_t i = 0; i < count; i++) { - if (!lookup_validity.RowIsValid(i)) { - index = i; - break; + //! Perform the extract + ValidityMask validity(count); + for (idx_t i = 0; i < components.size(); i++) { + auto &component = components[i]; + auto &input_indices = i % 2 == 0 ? value_index_sel : new_value_index_sel; + auto &output_indices = i % 2 == 0 ? new_value_index_sel : value_index_sel; + + auto expected_type = component.lookup_mode == VariantChildLookupMode::BY_INDEX ? VariantLogicalType::ARRAY + : VariantLogicalType::OBJECT; + + (void)VariantUtils::CollectNestedData(variant, expected_type, input_indices, count, optional_idx(), 0, + nested_data, validity); + //! Look up the value_index of the child we're extracting + ValidityMask lookup_validity(count); + VariantUtils::FindChildValues(variant, component, nullptr, output_indices, lookup_validity, nested_data, + validity, count); + + for (idx_t j = 0; j < count; j++) { + if (!validity.RowIsValid(j)) { + continue; + } + if (!lookup_validity.AllValid() && !lookup_validity.RowIsValid(j)) { + //! No child could be extracted, set to NULL + validity.SetInvalid(j); + continue; + } + //! Get the index into 'values' + auto type_id = variant.GetTypeId(j, output_indices[j]); + if (type_id == VariantLogicalType::VARIANT_NULL) { + validity.SetInvalid(j); } - } - D_ASSERT(index.IsValid()); - switch (component.lookup_mode) { - case VariantChildLookupMode::BY_INDEX: { - auto nested_index = index.GetIndex(); - throw InvalidInputException("VARIANT(ARRAY(%d)) is missing index %d", nested_data[nested_index].child_count, - component.index); - } - case VariantChildLookupMode::BY_KEY: { - auto nested_index = index.GetIndex(); - auto row_index = nested_index; - auto object_keys = VariantUtils::GetObjectKeys(variant, row_index, nested_data[nested_index]); - throw InvalidInputException("VARIANT(OBJECT(%s)) is missing key '%s'", StringUtil::Join(object_keys, ","), - component.key); - } } } @@ -252,18 +172,25 @@ static void VariantExtractFunction(DataChunk &input, ExpressionState &state, Vec ListVector::Reserve(result_values, values_list_size); ListVector::SetListSize(result_values, values_list_size); auto result_values_data = FlatVector::GetData(result_values); + auto &result_values_validity = FlatVector::Validity(result_values); for (idx_t i = 0; i < count; i++) { + if (!validity.RowIsValid(i)) { + result_values_validity.SetInvalid(i); + continue; + } result_values_data[i] = values_data[values.sel->get_index(i)]; } + auto &result_indices = components.size() % 2 == 0 ? value_index_sel : new_value_index_sel; + //! Prepare the selection vector to remap index 0 of each row SelectionVector new_sel(0, values_list_size); for (idx_t i = 0; i < count; i++) { - if (nested_data[i].is_null) { + if (!validity.RowIsValid(i)) { continue; } auto &list_entry = values_data[values.sel->get_index(i)]; - new_sel.set_index(list_entry.offset, list_entry.offset + new_value_index_sel[i]); + new_sel.set_index(list_entry.offset, list_entry.offset + result_indices[i]); } auto &result_type_id = VariantVector::GetValuesTypeId(result); @@ -273,17 +200,42 @@ static void VariantExtractFunction(DataChunk &input, ExpressionState &state, Vec result_byte_offset.Dictionary(VariantVector::GetValuesByteOffset(variant_vec), values_list_size, new_sel, values_list_size); - auto value_is_null = VariantUtils::ValueIsNull(variant, new_value_index_sel, count, optional_idx()); - if (!value_is_null.empty()) { - result.Flatten(count); - for (auto &i : value_is_null) { - FlatVector::SetNull(result, i, true); + if (!validity.AllValid()) { + //! Create a copy of the vector, because we used Reference before, and we now need to adjust the data + //! Which is a problem if we're still sharing the memory with 'input' + Vector other(result.GetType(), count); + VectorOperations::Copy(result, other, count, 0, 0); + result.Reference(other); + + for (idx_t i = 0; i < count; i++) { + if (!validity.RowIsValid(i)) { + FlatVector::SetNull(result, i, true); + } } } - if (input.AllConstant()) { + if (variant_vec.GetVectorType() == VectorType::CONSTANT_VECTOR) { result.SetVectorType(VectorType::CONSTANT_VECTOR); } + result.Verify(count); +} + +//! FIXME: it could make sense to allow a third argument: 'default' +//! This can currently be achieved with COALESCE(TRY(), 'default') +static void VariantExtractFunction(DataChunk &input, ExpressionState &state, Vector &result) { + auto count = input.size(); + + D_ASSERT(input.ColumnCount() == 2); + auto &variant_vec = input.data[0]; + D_ASSERT(variant_vec.GetType() == LogicalType::VARIANT()); + + auto &path = input.data[1]; + D_ASSERT(path.GetVectorType() == VectorType::CONSTANT_VECTOR); + (void)path; + + auto &func_expr = state.expr.Cast(); + auto &info = func_expr.bind_info->Cast(); + VariantUtils::VariantExtract(variant_vec, {info.component}, result, count); } ScalarFunctionSet VariantExtractFun::GetFunctions() { diff --git a/src/duckdb/src/function/scalar/variant/variant_utils.cpp b/src/duckdb/src/function/scalar/variant/variant_utils.cpp index 5160d9381..ec75966bc 100644 --- a/src/duckdb/src/function/scalar/variant/variant_utils.cpp +++ b/src/duckdb/src/function/scalar/variant/variant_utils.cpp @@ -56,7 +56,6 @@ VariantNestedData VariantUtils::DecodeNestedData(const UnifiedVariantVectorData auto ptr = data + byte_offset; VariantNestedData result; - result.is_null = false; result.child_count = VarintDecode(ptr); if (result.child_count) { result.children_idx = VarintDecode(ptr); @@ -78,14 +77,15 @@ vector VariantUtils::GetObjectKeys(const UnifiedVariantVectorData &varia void VariantUtils::FindChildValues(const UnifiedVariantVectorData &variant, const VariantPathComponent &component, optional_ptr sel, SelectionVector &res, - ValidityMask &res_validity, VariantNestedData *nested_data, idx_t count) { + ValidityMask &res_validity, const VariantNestedData *nested_data, + const ValidityMask &validity, idx_t count) { for (idx_t i = 0; i < count; i++) { auto row_index = sel ? sel->get_index(i) : i; - auto &nested_data_entry = nested_data[i]; - if (nested_data_entry.is_null) { + if (!validity.RowIsValid(i)) { continue; } + auto &nested_data_entry = nested_data[i]; if (component.lookup_mode == VariantChildLookupMode::BY_INDEX) { auto child_idx = component.index; if (child_idx >= nested_data_entry.child_count) { @@ -139,26 +139,41 @@ vector VariantUtils::ValueIsNull(const UnifiedVariantVectorData &varia VariantNestedDataCollectionResult VariantUtils::CollectNestedData(const UnifiedVariantVectorData &variant, VariantLogicalType expected_type, - const SelectionVector &sel, idx_t count, optional_idx row, idx_t offset, + const SelectionVector &value_index_sel, idx_t count, optional_idx row, idx_t offset, VariantNestedData *child_data, ValidityMask &validity) { + VariantLogicalType wrong_type = VariantLogicalType::VARIANT_NULL; for (idx_t i = 0; i < count; i++) { auto row_index = row.IsValid() ? row.GetIndex() : i; //! NOTE: the validity is assumed to be from a FlatVector - if (!variant.RowIsValid(row_index) || !validity.RowIsValid(offset + i)) { - child_data[i].is_null = true; + //! Is the input row NULL ? + if (!variant.RowIsValid(row_index) || !validity.RowIsValid(i)) { + validity.SetInvalid(i); continue; } - auto type_id = variant.GetTypeId(row_index, sel[i]); + + //! Is the variant value NULL ? + auto type_id = variant.GetTypeId(row_index, value_index_sel[i]); if (type_id == VariantLogicalType::VARIANT_NULL) { - child_data[i].is_null = true; + validity.SetInvalid(i); continue; } + //! Is the type of the VARIANT correct? if (type_id != expected_type) { - return VariantNestedDataCollectionResult(type_id); + if (wrong_type == VariantLogicalType::VARIANT_NULL) { + //! Record the type of the first row that doesn't have the expected type + wrong_type = type_id; + } + validity.SetInvalid(i); + continue; } - child_data[i] = DecodeNestedData(variant, row_index, sel[i]); + + child_data[i] = DecodeNestedData(variant, row_index, value_index_sel[i]); + } + + if (wrong_type != VariantLogicalType::VARIANT_NULL) { + return VariantNestedDataCollectionResult(wrong_type); } return VariantNestedDataCollectionResult(); } diff --git a/src/duckdb/src/function/table/copy_csv.cpp b/src/duckdb/src/function/table/copy_csv.cpp index 1ffd6e7ee..15f82dc93 100644 --- a/src/duckdb/src/function/table/copy_csv.cpp +++ b/src/duckdb/src/function/table/copy_csv.cpp @@ -1,6 +1,7 @@ #include "duckdb/common/bind_helpers.hpp" #include "duckdb/common/csv_writer.hpp" #include "duckdb/common/file_system.hpp" +#include "duckdb/common/multi_file/multi_file_function.hpp" #include "duckdb/common/multi_file/multi_file_reader.hpp" #include "duckdb/common/serializer/memory_stream.hpp" #include "duckdb/common/serializer/write_stream.hpp" @@ -8,8 +9,8 @@ #include "duckdb/common/types/column/column_data_collection.hpp" #include "duckdb/common/types/string_type.hpp" #include "duckdb/common/vector_operations/vector_operations.hpp" -#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp" #include "duckdb/execution/operator/csv_scanner/csv_multi_file_info.hpp" +#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp" #include "duckdb/function/copy_function.hpp" #include "duckdb/function/scalar/string_functions.hpp" #include "duckdb/function/table/read_csv.hpp" @@ -18,8 +19,9 @@ #include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/parser/expression/function_expression.hpp" #include "duckdb/parser/parsed_data/copy_info.hpp" +#include "duckdb/planner/binder.hpp" #include "duckdb/planner/expression/bound_reference_expression.hpp" -#include "duckdb/common/multi_file/multi_file_function.hpp" +#include "duckdb/planner/expression_binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/function/table/glob.cpp b/src/duckdb/src/function/table/glob.cpp index de1099258..3933a6fa4 100644 --- a/src/duckdb/src/function/table/glob.cpp +++ b/src/duckdb/src/function/table/glob.cpp @@ -41,6 +41,7 @@ static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, Dat auto &bind_data = data_p.bind_data->Cast(); auto &state = data_p.global_state->Cast(); + state.file_list_scan.scan_type = MultiFileListScanType::ALWAYS_FETCH; idx_t count = 0; while (count < STANDARD_VECTOR_SIZE) { OpenFileInfo file; @@ -48,6 +49,7 @@ static void GlobFunction(ClientContext &context, TableFunctionInput &data_p, Dat break; } output.data[0].SetValue(count++, file.path); + state.file_list_scan.scan_type = MultiFileListScanType::FETCH_IF_AVAILABLE; } output.SetCardinality(count); } diff --git a/src/duckdb/src/function/table/sniff_csv.cpp b/src/duckdb/src/function/table/sniff_csv.cpp index 7b133bccd..f428d77b3 100644 --- a/src/duckdb/src/function/table/sniff_csv.cpp +++ b/src/duckdb/src/function/table/sniff_csv.cpp @@ -133,9 +133,9 @@ static void CSVSniffFunction(ClientContext &context, TableFunctionInput &data_p, return; } const CSVSniffFunctionData &data = data_p.bind_data->Cast(); - auto &fs = duckdb::FileSystem::GetFileSystem(context); - auto files = fs.GlobFiles(data.path, context, FileGlobOptions::DISALLOW_EMPTY); + auto &fs = FileSystem::GetFileSystem(context); + auto files = fs.GlobFiles(data.path, FileGlobOptions::DISALLOW_EMPTY); if (files.size() > 1) { throw NotImplementedException("sniff_csv does not operate on more than one file yet"); } diff --git a/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp b/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp index c3ec4f39a..d48b8debb 100644 --- a/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp +++ b/src/duckdb/src/function/table/system/duckdb_log_contexts.cpp @@ -3,10 +3,11 @@ #include "duckdb/catalog/catalog.hpp" #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp" #include "duckdb/common/exception.hpp" -#include "duckdb/main/client_context.hpp" -#include "duckdb/main/client_data.hpp" #include "duckdb/logging/log_manager.hpp" #include "duckdb/logging/log_storage.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/main/client_data.hpp" +#include "duckdb/parser/tableref.hpp" namespace duckdb { diff --git a/src/duckdb/src/function/table/system/duckdb_secrets.cpp b/src/duckdb/src/function/table/system/duckdb_secrets.cpp index ae7f3104a..29365b3e9 100644 --- a/src/duckdb/src/function/table/system/duckdb_secrets.cpp +++ b/src/duckdb/src/function/table/system/duckdb_secrets.cpp @@ -1,12 +1,8 @@ #include "duckdb/function/table/system_functions.hpp" -#include "duckdb/common/file_system.hpp" -#include "duckdb/common/map.hpp" -#include "duckdb/common/string_util.hpp" #include "duckdb/function/function_set.hpp" #include "duckdb/main/client_context.hpp" -#include "duckdb/main/database.hpp" -#include "duckdb/main/extension_helper.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/main/secret/secret_manager.hpp" namespace duckdb { @@ -47,8 +43,7 @@ static unique_ptr DuckDBSecretsBind(ClientContext &context, TableF } } - if (!DBConfig::GetConfig(context).options.allow_unredacted_secrets && - result->redact == SecretDisplayType::UNREDACTED) { + if (!Settings::Get(context) && result->redact == SecretDisplayType::UNREDACTED) { throw InvalidInputException("Displaying unredacted secrets is disabled"); } diff --git a/src/duckdb/src/function/table/system/duckdb_settings.cpp b/src/duckdb/src/function/table/system/duckdb_settings.cpp index 9908854bd..75da7b495 100644 --- a/src/duckdb/src/function/table/system/duckdb_settings.cpp +++ b/src/duckdb/src/function/table/system/duckdb_settings.cpp @@ -91,7 +91,7 @@ unique_ptr DuckDBSettingsInit(ClientContext &context, } result->settings.push_back(std::move(value)); } - for (auto &ext_param : config.extension_parameters) { + for (auto &ext_param : config.GetExtensionSettings()) { Value setting_val; auto scope = SettingScope::GLOBAL; auto lookup_result = context.TryGetCurrentSetting(ext_param.first, setting_val); diff --git a/src/duckdb/src/function/table/system/enable_profiling.cpp b/src/duckdb/src/function/table/system/enable_profiling.cpp index a7a8cdac2..2aec20fde 100644 --- a/src/duckdb/src/function/table/system/enable_profiling.cpp +++ b/src/duckdb/src/function/table/system/enable_profiling.cpp @@ -64,8 +64,6 @@ static unique_ptr BindEnableProfiling(ClientContext &context, Tabl auto bind_data = make_uniq(); - auto config = ClientConfig::GetConfig(context); - bool metrics_set = false; for (const auto &named_param : input.named_parameters) { @@ -78,7 +76,7 @@ static unique_ptr BindEnableProfiling(ClientContext &context, Tabl bind_data->coverage = StringUtil::Lower(named_param.second.ToString()); break; case ProfilingParameterNames::SAVE_LOCATION: - bind_data->save_location = StringUtil::Lower(named_param.second.ToString()); + bind_data->save_location = named_param.second.ToString(); break; case ProfilingParameterNames::MODE: bind_data->mode = StringUtil::Lower(named_param.second.ToString()); diff --git a/src/duckdb/src/function/table/table_scan.cpp b/src/duckdb/src/function/table/table_scan.cpp index 7e0999dea..ca1173402 100644 --- a/src/duckdb/src/function/table/table_scan.cpp +++ b/src/duckdb/src/function/table/table_scan.cpp @@ -676,8 +676,8 @@ unique_ptr TableScanInitGlobal(ClientContext &context, return DuckTableScanInitGlobal(context, input, storage, bind_data); } - auto scan_percentage = DBConfig::GetSetting(context); - auto scan_max_count = DBConfig::GetSetting(context); + auto scan_percentage = Settings::Get(context); + auto scan_max_count = Settings::Get(context); auto total_rows = storage.GetTotalRows(); auto total_rows_from_percentage = LossyNumericCast(double(total_rows) * scan_percentage); @@ -823,7 +823,7 @@ static bool TableSupportsPushdownExtract(const FunctionData &bind_data_ref, cons return false; } auto column_type = column.GetType(); - if (column_type.id() != LogicalTypeId::STRUCT) { + if (column_type.id() != LogicalTypeId::STRUCT && column_type.id() != LogicalTypeId::VARIANT) { return false; } return true; diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp index 494b967cb..47e1f1f1c 100644 --- a/src/duckdb/src/function/table/version/pragma_version.cpp +++ b/src/duckdb/src/function/table/version/pragma_version.cpp @@ -1,5 +1,5 @@ #ifndef DUCKDB_PATCH_VERSION -#define DUCKDB_PATCH_VERSION "0-dev5469" +#define DUCKDB_PATCH_VERSION "0-dev6344" #endif #ifndef DUCKDB_MINOR_VERSION #define DUCKDB_MINOR_VERSION 5 @@ -8,10 +8,10 @@ #define DUCKDB_MAJOR_VERSION 1 #endif #ifndef DUCKDB_VERSION -#define DUCKDB_VERSION "v1.5.0-dev5469" +#define DUCKDB_VERSION "v1.5.0-dev6344" #endif #ifndef DUCKDB_SOURCE_ID -#define DUCKDB_SOURCE_ID "f5174f0d6d" +#define DUCKDB_SOURCE_ID "cc7c620e58" #endif #include "duckdb/function/table/system_functions.hpp" #include "duckdb/main/database.hpp" diff --git a/src/duckdb/src/function/table_function.cpp b/src/duckdb/src/function/table_function.cpp index db6829ce4..1290dc9ef 100644 --- a/src/duckdb/src/function/table_function.cpp +++ b/src/duckdb/src/function/table_function.cpp @@ -39,8 +39,8 @@ TableFunction::TableFunction(string name, const vector &arguments, pushdown_expression(nullptr), to_string(nullptr), dynamic_to_string(nullptr), table_scan_progress(nullptr), get_partition_data(nullptr), get_bind_info(nullptr), type_pushdown(nullptr), get_multi_file_reader(nullptr), supports_pushdown_type(nullptr), supports_pushdown_extract(nullptr), get_partition_info(nullptr), - get_partition_stats(nullptr), get_virtual_columns(nullptr), get_row_id_columns(nullptr), serialize(nullptr), - deserialize(nullptr), projection_pushdown(false), filter_pushdown(false), filter_prune(false), + get_partition_stats(nullptr), get_virtual_columns(nullptr), get_row_id_columns(nullptr), set_scan_order(nullptr), + serialize(nullptr), deserialize(nullptr), projection_pushdown(false), filter_pushdown(false), filter_prune(false), sampling_pushdown(false), late_materialization(false) { } diff --git a/src/duckdb/src/function/variant/variant_shredding.cpp b/src/duckdb/src/function/variant/variant_shredding.cpp index ee69da0e9..416618d39 100644 --- a/src/duckdb/src/function/variant/variant_shredding.cpp +++ b/src/duckdb/src/function/variant/variant_shredding.cpp @@ -198,8 +198,9 @@ void VariantShredding::WriteTypedObjectValues(UnifiedVariantVectorData &variant, path_component.key = key; ValidityMask lookup_validity(count); + ValidityMask all_valid_validity(count); VariantUtils::FindChildValues(variant, path_component, sel, child_values_indexes, lookup_validity, - nested_data.get(), count); + nested_data.get(), all_valid_validity, count); if (!lookup_validity.AllValid()) { auto &child_variant_vectors = StructVector::GetEntries(child_vec); diff --git a/src/duckdb/src/function/window/window_value_function.cpp b/src/duckdb/src/function/window/window_value_function.cpp index 276b99fad..ff987575b 100644 --- a/src/duckdb/src/function/window/window_value_function.cpp +++ b/src/duckdb/src/function/window/window_value_function.cpp @@ -194,9 +194,8 @@ unique_ptr WindowValueExecutor::GetLocalState(ExecutionContext & class WindowLeadLagGlobalState : public WindowValueGlobalState { public: - explicit WindowLeadLagGlobalState(ClientContext &client, const WindowValueExecutor &executor, - const idx_t payload_count, const ValidityMask &partition_mask, - const ValidityMask &order_mask) + WindowLeadLagGlobalState(ClientContext &client, const WindowValueExecutor &executor, const idx_t payload_count, + const ValidityMask &partition_mask, const ValidityMask &order_mask) : WindowValueGlobalState(client, executor, payload_count, partition_mask, order_mask) { if (value_tree) { use_framing = true; @@ -231,7 +230,7 @@ class WindowLeadLagGlobalState : public WindowValueGlobalState { //===--------------------------------------------------------------------===// class WindowLeadLagLocalState : public WindowValueLocalState { public: - explicit WindowLeadLagLocalState(ExecutionContext &context, const WindowLeadLagGlobalState &gstate) + WindowLeadLagLocalState(ExecutionContext &context, const WindowLeadLagGlobalState &gstate) : WindowValueLocalState(context, gstate) { if (gstate.row_tree) { local_row = gstate.row_tree->GetLocalState(context); @@ -841,8 +840,17 @@ static fill_value_t GetFillValueFunction(const LogicalType &type) { } } -WindowFillExecutor::WindowFillExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared) +WindowFillExecutor::WindowFillExecutor(BoundWindowExpression &wexpr, ClientContext &client, + WindowSharedExpressions &shared) : WindowValueExecutor(wexpr, shared) { + // If the argument order is prefix of the partition ordering, + // then we can just use the partition ordering. + auto &arg_orders = wexpr.arg_orders; + const auto optimize = ClientConfig::GetConfig(client).enable_optimizer; + if (optimize && BoundWindowExpression::GetSharedOrders(wexpr.orders, arg_orders) == arg_orders.size()) { + arg_order_idx.clear(); + } + // We need the sort values for interpolation, so either use the range or the secondary ordering expression if (arg_order_idx.empty()) { // We use the range ordering, even if it has not been defined @@ -871,8 +879,8 @@ static void WindowFillCopy(WindowCursor &cursor, Vector &result, idx_t count, id class WindowFillGlobalState : public WindowLeadLagGlobalState { public: - explicit WindowFillGlobalState(ClientContext &client, const WindowFillExecutor &executor, const idx_t payload_count, - const ValidityMask &partition_mask, const ValidityMask &order_mask) + WindowFillGlobalState(ClientContext &client, const WindowFillExecutor &executor, const idx_t payload_count, + const ValidityMask &partition_mask, const ValidityMask &order_mask) : WindowLeadLagGlobalState(client, executor, payload_count, partition_mask, order_mask), order_idx(executor.order_idx) { } @@ -885,6 +893,11 @@ class WindowFillLocalState : public WindowLeadLagLocalState { public: WindowFillLocalState(ExecutionContext &context, const WindowLeadLagGlobalState &gvstate) : WindowLeadLagLocalState(context, gvstate) { + // If we optimised the ordering, force computation of the validity range. + if (!gvstate.value_tree) { + state.required.insert(VALID_BEGIN); + state.required.insert(VALID_END); + } } //! Finish the sinking and prepare to scan @@ -1007,6 +1020,9 @@ void WindowFillExecutor::EvaluateInternal(ExecutionContext &context, DataChunk & if (prev_valid == DConstants::INVALID_INDEX) { // Skip to the next partition i += partition_end[i] - row_idx - 1; + if (i >= count) { + return; + } row_idx = partition_end[i] - 1; continue; } @@ -1099,7 +1115,7 @@ void WindowFillExecutor::EvaluateInternal(ExecutionContext &context, DataChunk & } } - // If there is nothing beind us (missing early value) then scan forward + // If there is nothing behind us (missing early value) then scan forward if (prev_valid == DConstants::INVALID_INDEX) { for (idx_t j = row_idx + 1; j < valid_end[i]; ++j) { if (!order_value_func(j, order_cursor)) { @@ -1116,6 +1132,9 @@ void WindowFillExecutor::EvaluateInternal(ExecutionContext &context, DataChunk & if (prev_valid == DConstants::INVALID_INDEX) { // Skip to the next partition i += partition_end[i] - row_idx - 1; + if (i >= count) { + break; + } row_idx = partition_end[i] - 1; continue; } diff --git a/src/duckdb/src/include/duckdb.h b/src/duckdb/src/include/duckdb.h index 30e240159..d7be565c6 100644 --- a/src/duckdb/src/include/duckdb.h +++ b/src/duckdb/src/include/duckdb.h @@ -903,7 +903,7 @@ struct duckdb_extension_access { //! Indicate that an error has occurred. void (*set_error)(duckdb_extension_info info, const char *error); //! Fetch the database on which to register the extension. - duckdb_database (*get_database)(duckdb_extension_info info); + duckdb_database *(*get_database)(duckdb_extension_info info); //! Fetch the API struct pointer. const void *(*get_api)(duckdb_extension_info info, const char *version); }; @@ -3471,7 +3471,8 @@ DUCKDB_C_API duckdb_error_data duckdb_vector_safe_assign_string_element(duckdb_v const char *str); /*! -Assigns a string element in the vector at the specified location. +Assigns a string element in the vector at the specified location. The vector type must be VARCHAR and the input must be +valid UTF-8. Otherwise, undefined behavior is expected at later stages. * @param vector The vector to alter * @param index The row position in the vector to assign the string to @@ -3480,7 +3481,8 @@ Assigns a string element in the vector at the specified location. DUCKDB_C_API void duckdb_vector_assign_string_element(duckdb_vector vector, idx_t index, const char *str); /*! -Assigns a string element in the vector at the specified location. You may also use this function to assign BLOBs. +Assigns a string element in the vector at the specified location. The vector type can be VARCHAR or BLOB. In the case of +VARCHAR, you must pass valid UTF-8. Otherwise, undefined behavior is expected at later stages. * @param vector The vector to alter * @param index The row position in the vector to assign the string to diff --git a/src/duckdb/src/include/duckdb/catalog/catalog.hpp b/src/duckdb/src/include/duckdb/catalog/catalog.hpp index 9817f6c03..58513a186 100644 --- a/src/duckdb/src/include/duckdb/catalog/catalog.hpp +++ b/src/duckdb/src/include/duckdb/catalog/catalog.hpp @@ -328,6 +328,7 @@ class Catalog { virtual string GetEncryptionCipher() const { return string(); } + virtual ErrorData SupportsCreateTable(BoundCreateTableInfo &info); //! Whether or not this catalog should search a specific type with the standard priority DUCKDB_API virtual CatalogLookupBehavior CatalogTypeLookupRule(CatalogType type) const { diff --git a/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp b/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp index 925c4a076..3c8465184 100644 --- a/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp +++ b/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp @@ -10,11 +10,10 @@ #include "duckdb/catalog/catalog_entry/function_entry.hpp" #include "duckdb/catalog/catalog_set.hpp" -#include "duckdb/function/function.hpp" -#include "duckdb/parser/parsed_data/create_aggregate_function_info.hpp" -#include "duckdb/main/attached_database.hpp" +#include "duckdb/function/function_set.hpp" namespace duckdb { +struct CreateAggregateFunctionInfo; //! An aggregate function in the catalog class AggregateFunctionCatalogEntry : public FunctionEntry { @@ -23,13 +22,7 @@ class AggregateFunctionCatalogEntry : public FunctionEntry { static constexpr const char *Name = "aggregate function"; public: - AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateAggregateFunctionInfo &info) - : FunctionEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, catalog, schema, info), functions(info.functions) { - for (auto &function : functions.functions) { - function.catalog_name = catalog.GetAttached().GetName(); - function.schema_name = schema.name; - } - } + AggregateFunctionCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateAggregateFunctionInfo &info); //! The aggregate functions AggregateFunctionSet functions; diff --git a/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp b/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp deleted file mode 100644 index f3a71b594..000000000 --- a/src/duckdb/src/include/duckdb/catalog/default/builtin_types/types.hpp +++ /dev/null @@ -1,104 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/catalog/default/builtin_types/types.hpp -// -// -//===----------------------------------------------------------------------===// -// This file is generated by scripts/generate_builtin_types.py - -#pragma once - -#include "duckdb/common/types.hpp" -#include "duckdb/common/array.hpp" - -namespace duckdb { - -struct DefaultType { - const char *name; - LogicalTypeId type; -}; - -using builtin_type_array = std::array; - -static constexpr const builtin_type_array BUILTIN_TYPES{{ - {"decimal", LogicalTypeId::DECIMAL}, - {"dec", LogicalTypeId::DECIMAL}, - {"numeric", LogicalTypeId::DECIMAL}, - {"time", LogicalTypeId::TIME}, - {"time_ns", LogicalTypeId::TIME_NS}, - {"date", LogicalTypeId::DATE}, - {"timestamp", LogicalTypeId::TIMESTAMP}, - {"datetime", LogicalTypeId::TIMESTAMP}, - {"timestamp_us", LogicalTypeId::TIMESTAMP}, - {"timestamp_ms", LogicalTypeId::TIMESTAMP_MS}, - {"timestamp_ns", LogicalTypeId::TIMESTAMP_NS}, - {"timestamp_s", LogicalTypeId::TIMESTAMP_SEC}, - {"timestamptz", LogicalTypeId::TIMESTAMP_TZ}, - {"timetz", LogicalTypeId::TIME_TZ}, - {"interval", LogicalTypeId::INTERVAL}, - {"varchar", LogicalTypeId::VARCHAR}, - {"bpchar", LogicalTypeId::VARCHAR}, - {"string", LogicalTypeId::VARCHAR}, - {"char", LogicalTypeId::VARCHAR}, - {"nvarchar", LogicalTypeId::VARCHAR}, - {"text", LogicalTypeId::VARCHAR}, - {"blob", LogicalTypeId::BLOB}, - {"bytea", LogicalTypeId::BLOB}, - {"varbinary", LogicalTypeId::BLOB}, - {"binary", LogicalTypeId::BLOB}, - {"hugeint", LogicalTypeId::HUGEINT}, - {"int128", LogicalTypeId::HUGEINT}, - {"uhugeint", LogicalTypeId::UHUGEINT}, - {"uint128", LogicalTypeId::UHUGEINT}, - {"bigint", LogicalTypeId::BIGINT}, - {"oid", LogicalTypeId::BIGINT}, - {"long", LogicalTypeId::BIGINT}, - {"int8", LogicalTypeId::BIGINT}, - {"int64", LogicalTypeId::BIGINT}, - {"ubigint", LogicalTypeId::UBIGINT}, - {"uint64", LogicalTypeId::UBIGINT}, - {"integer", LogicalTypeId::INTEGER}, - {"int", LogicalTypeId::INTEGER}, - {"int4", LogicalTypeId::INTEGER}, - {"signed", LogicalTypeId::INTEGER}, - {"integral", LogicalTypeId::INTEGER}, - {"int32", LogicalTypeId::INTEGER}, - {"uinteger", LogicalTypeId::UINTEGER}, - {"uint32", LogicalTypeId::UINTEGER}, - {"smallint", LogicalTypeId::SMALLINT}, - {"int2", LogicalTypeId::SMALLINT}, - {"short", LogicalTypeId::SMALLINT}, - {"int16", LogicalTypeId::SMALLINT}, - {"usmallint", LogicalTypeId::USMALLINT}, - {"uint16", LogicalTypeId::USMALLINT}, - {"tinyint", LogicalTypeId::TINYINT}, - {"int1", LogicalTypeId::TINYINT}, - {"utinyint", LogicalTypeId::UTINYINT}, - {"uint8", LogicalTypeId::UTINYINT}, - {"struct", LogicalTypeId::STRUCT}, - {"row", LogicalTypeId::STRUCT}, - {"list", LogicalTypeId::LIST}, - {"map", LogicalTypeId::MAP}, - {"union", LogicalTypeId::UNION}, - {"bit", LogicalTypeId::BIT}, - {"bitstring", LogicalTypeId::BIT}, - {"variant", LogicalTypeId::VARIANT}, - {"bignum", LogicalTypeId::BIGNUM}, - {"varint", LogicalTypeId::BIGNUM}, - {"boolean", LogicalTypeId::BOOLEAN}, - {"bool", LogicalTypeId::BOOLEAN}, - {"logical", LogicalTypeId::BOOLEAN}, - {"uuid", LogicalTypeId::UUID}, - {"guid", LogicalTypeId::UUID}, - {"enum", LogicalTypeId::ENUM}, - {"null", LogicalTypeId::SQLNULL}, - {"float", LogicalTypeId::FLOAT}, - {"real", LogicalTypeId::FLOAT}, - {"float4", LogicalTypeId::FLOAT}, - {"double", LogicalTypeId::DOUBLE}, - {"float8", LogicalTypeId::DOUBLE}, - {"geometry", LogicalTypeId::GEOMETRY} -}}; - -} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp index 02480084a..88161f7c4 100644 --- a/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp +++ b/src/duckdb/src/include/duckdb/catalog/default/default_generator.hpp @@ -28,6 +28,12 @@ class DefaultGenerator { virtual unique_ptr CreateDefaultEntry(CatalogTransaction transaction, const string &entry_name); //! Get a list of all default entries in the generator virtual vector GetDefaultEntries() = 0; + //! Whether or not we should keep the lock while calling CreateDefaultEntry + //! If this is set to false, CreateDefaultEntry might be called multiple times in parallel also for the same entry + //! Otherwise it will be called exactly once per entry + virtual bool LockDuringCreate() const { + return false; + } }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp b/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp index 83d90982b..5d58a8299 100644 --- a/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp +++ b/src/duckdb/src/include/duckdb/catalog/default/default_types.hpp @@ -22,6 +22,7 @@ class DefaultTypeGenerator : public DefaultGenerator { public: DUCKDB_API static LogicalTypeId GetDefaultType(const string &name); + DUCKDB_API static LogicalType TryDefaultBind(const string &name, const vector> ¶ms); unique_ptr CreateDefaultEntry(ClientContext &context, const string &entry_name) override; vector GetDefaultEntries() override; diff --git a/src/duckdb/src/include/duckdb/common/column_index.hpp b/src/duckdb/src/include/duckdb/common/column_index.hpp index d1c3c672d..ea5607833 100644 --- a/src/duckdb/src/include/duckdb/common/column_index.hpp +++ b/src/duckdb/src/include/duckdb/common/column_index.hpp @@ -25,19 +25,37 @@ enum class ColumnIndexType : uint8_t { struct ColumnIndex { public: //! FIXME: this initializes the index to COLUMN_IDENTIFIER_ROW_ID (same numeric representation as INVALID_INDEX) - ColumnIndex() : index(DConstants::INVALID_INDEX), index_type(ColumnIndexType::INVALID) { + ColumnIndex() : has_index(true), index(DConstants::INVALID_INDEX), index_type(ColumnIndexType::FULL_READ) { } explicit ColumnIndex(idx_t index) - : index(index), type(LogicalType::INVALID), index_type(ColumnIndexType::FULL_READ) { + : has_index(true), index(index), type(LogicalType::INVALID), index_type(ColumnIndexType::FULL_READ) { } + explicit ColumnIndex(const string &field) + : has_index(false), field(field), type(LogicalType::INVALID), index_type(ColumnIndexType::FULL_READ) { + } + ColumnIndex(idx_t index, vector child_indexes_p) - : index(index), index_type(ColumnIndexType::FULL_READ), child_indexes(std::move(child_indexes_p)) { + : has_index(true), index(index), index_type(ColumnIndexType::FULL_READ), + child_indexes(std::move(child_indexes_p)) { + } + ColumnIndex(const string &field, vector child_indexes_p) + : has_index(false), field(field), index_type(ColumnIndexType::FULL_READ), + child_indexes(std::move(child_indexes_p)) { } inline bool operator==(const ColumnIndex &rhs) const { - if (index != rhs.index) { + if (has_index != rhs.has_index) { return false; } + if (has_index) { + if (index != rhs.index) { + return false; + } + } else { + if (field != rhs.field) { + return false; + } + } if (type != rhs.type) { return false; } @@ -66,11 +84,27 @@ struct ColumnIndex { } public: + bool HasPrimaryIndex() const { + return has_index; + } idx_t GetPrimaryIndex() const { + if (!has_index) { + throw InternalException("Attempted to get the primary index (numeric) for an index that consists of a " + "field identifier (string: %s)", + field); + } return index; } + const string &GetFieldName() const { + if (has_index) { + throw InternalException("Attempted to get the field identifier (string) for an index that consists of a " + "primary index (numeric: %d)", + index); + } + return field; + } LogicalIndex ToLogical() const { - return LogicalIndex(index); + return LogicalIndex(GetPrimaryIndex()); } bool HasChildren() const { return !child_indexes.empty(); @@ -100,23 +134,38 @@ struct ColumnIndex { void SetType(const LogicalType &type_information) { type = type_information; } - void SetPushdownExtractType(const LogicalType &type_information, optional_ptr cast_type = nullptr) { + void SetPushdownExtractType(const LogicalType &type_information, + optional_ptr cast_type = nullptr) { //! We can upgrade the optional prune hint to a PUSHDOWN_EXTRACT, which is no longer optional index_type = ColumnIndexType::PUSHDOWN_EXTRACT; type = type_information; D_ASSERT(child_indexes.size() == 1); auto &child = child_indexes[0]; - auto &child_types = StructType::GetChildTypes(type); - auto &child_type = child_types[child.GetPrimaryIndex()].second; - if (child.child_indexes.empty()) { - if (cast_type) { - child.SetType(*cast_type); + if (child.HasPrimaryIndex()) { + auto &child_types = StructType::GetChildTypes(type); + auto &child_type = child_types[child.GetPrimaryIndex()].second; + if (child.child_indexes.empty()) { + if (cast_type) { + child.SetType(*cast_type); + } else { + child.SetType(child_type); + } } else { - child.SetType(child_type); + child.SetPushdownExtractType(child_type, cast_type); } } else { - child.SetPushdownExtractType(child_type, cast_type); + D_ASSERT(type_information.id() == LogicalTypeId::VARIANT); + if (child.child_indexes.empty()) { + if (cast_type) { + child.SetType(*cast_type); + } else { + //! Without a cast, the child will always be VARIANT + child.SetType(type_information); + } + } else { + child.SetPushdownExtractType(type_information, cast_type); + } } } const LogicalType &GetScanType() const { @@ -134,12 +183,21 @@ struct ColumnIndex { this->child_indexes.push_back(std::move(new_index)); } bool IsRowIdColumn() const { + if (!has_index) { + return false; + } return index == COLUMN_IDENTIFIER_ROW_ID; } bool IsEmptyColumn() const { + if (!has_index) { + return false; + } return index == COLUMN_IDENTIFIER_EMPTY; } bool IsVirtualColumn() const { + if (!has_index) { + return false; + } return index >= VIRTUAL_COLUMN_START; } void VerifySinglePath() const { @@ -160,8 +218,20 @@ struct ColumnIndex { reference b(path); while (true) { - if (a.get().GetPrimaryIndex() != b.get().GetPrimaryIndex()) { - return false; + if (a.get().HasPrimaryIndex()) { + if (!b.get().HasPrimaryIndex()) { + return false; + } + if (a.get().GetPrimaryIndex() != b.get().GetPrimaryIndex()) { + return false; + } + } else { + if (b.get().HasPrimaryIndex()) { + return false; + } + if (a.get().GetFieldName() != b.get().GetFieldName()) { + return false; + } } const bool a_has_children = a.get().HasChildren(); const bool b_has_children = b.get().HasChildren(); @@ -187,7 +257,12 @@ struct ColumnIndex { static ColumnIndex Deserialize(Deserializer &deserializer); private: + //! The column/field index (if structured type) + bool has_index = true; idx_t index; + //! The column/field name (if semi-structured type) + string field; + //! The logical type of the column this references (if pushdown extract) LogicalType type = LogicalType::INVALID; //! The type of index, controlling how it's interpreted diff --git a/src/duckdb/src/include/duckdb/common/column_index_map.hpp b/src/duckdb/src/include/duckdb/common/column_index_map.hpp index 713351c8b..7c9e0a8eb 100644 --- a/src/duckdb/src/include/duckdb/common/column_index_map.hpp +++ b/src/duckdb/src/include/duckdb/common/column_index_map.hpp @@ -9,7 +9,8 @@ namespace duckdb { struct ColumnIndexHashFunction { uint64_t operator()(const ColumnIndex &index) const { - auto hasher = std::hash(); + auto index_hasher = std::hash(); + auto field_hasher = std::hash(); queue> to_hash; hash_t result = 0; @@ -20,7 +21,12 @@ struct ColumnIndexHashFunction { for (auto &child : children) { to_hash.push(child); } - result ^= hasher(current.get().GetPrimaryIndex()); + + if (current.get().HasPrimaryIndex()) { + result ^= index_hasher(current.get().GetPrimaryIndex()); + } else { + result ^= field_hasher(current.get().GetFieldName()); + } to_hash.pop(); } return result; diff --git a/src/duckdb/src/include/duckdb/common/encryption_key_manager.hpp b/src/duckdb/src/include/duckdb/common/encryption_key_manager.hpp index cec709f4e..dd1970662 100644 --- a/src/duckdb/src/include/duckdb/common/encryption_key_manager.hpp +++ b/src/duckdb/src/include/duckdb/common/encryption_key_manager.hpp @@ -32,6 +32,10 @@ class EncryptionKey { return key; } + data_ptr_t GetData() { + return key; + } + public: static void LockEncryptionKey(data_ptr_t key, idx_t key_len = MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); static void UnlockEncryptionKey(data_ptr_t key, idx_t key_len = MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); @@ -50,6 +54,8 @@ class EncryptionKeyManager : public ObjectCacheEntry { void AddKey(const string &key_name, data_ptr_t key); bool HasKey(const string &key_name) const; void DeleteKey(const string &key_name); + void ClearKey(const string &key_name); + void EraseKey(const string &key_name); const_data_ptr_t GetKey(const string &key_name) const; public: diff --git a/src/duckdb/src/include/duckdb/common/encryption_state.hpp b/src/duckdb/src/include/duckdb/common/encryption_state.hpp index 4aece4a2f..6503e83c8 100644 --- a/src/duckdb/src/include/duckdb/common/encryption_state.hpp +++ b/src/duckdb/src/include/duckdb/common/encryption_state.hpp @@ -18,11 +18,13 @@ class EncryptionTypes { enum CipherType : uint8_t { INVALID = 0, GCM = 1, CTR = 2, CBC = 3 }; enum KeyDerivationFunction : uint8_t { DEFAULT = 0, SHA256 = 1, PBKDF2 = 2 }; enum Mode { ENCRYPT, DECRYPT }; + enum EncryptionVersion : uint8_t { V0_0 = 0, V0_1 = 1, NONE = 127 }; static string CipherToString(CipherType cipher_p); static CipherType StringToCipher(const string &encryption_cipher_p); static string KDFToString(KeyDerivationFunction kdf_p); static KeyDerivationFunction StringToKDF(const string &key_derivation_function_p); + static EncryptionVersion StringToVersion(const string &encryption_version_p); }; class EncryptionState { diff --git a/src/duckdb/src/include/duckdb/common/enum_util.hpp b/src/duckdb/src/include/duckdb/common/enum_util.hpp index d1b35028c..76c318975 100644 --- a/src/duckdb/src/include/duckdb/common/enum_util.hpp +++ b/src/duckdb/src/include/duckdb/common/enum_util.hpp @@ -50,6 +50,8 @@ enum class AggregateOrderDependent : uint8_t; enum class AggregateType : uint8_t; +enum class AllowParserOverride : uint8_t; + enum class AlterDatabaseType : uint8_t; enum class AlterForeignKeyType : uint8_t; @@ -190,6 +192,8 @@ enum class ExtensionUpdateResultTag : uint8_t; enum class ExtraDropInfoType : uint8_t; +enum class ExtraPersistentColumnDataType : uint8_t; + enum class ExtraTypeInfoType : uint8_t; enum class FileBufferType : uint8_t; @@ -516,6 +520,9 @@ const char* EnumUtil::ToChars(AggregateOrderDependent v template<> const char* EnumUtil::ToChars(AggregateType value); +template<> +const char* EnumUtil::ToChars(AllowParserOverride value); + template<> const char* EnumUtil::ToChars(AlterDatabaseType value); @@ -726,6 +733,9 @@ const char* EnumUtil::ToChars(ExtensionUpdateResultTag template<> const char* EnumUtil::ToChars(ExtraDropInfoType value); +template<> +const char* EnumUtil::ToChars(ExtraPersistentColumnDataType value); + template<> const char* EnumUtil::ToChars(ExtraTypeInfoType value); @@ -1201,6 +1211,9 @@ AggregateOrderDependent EnumUtil::FromString(const char template<> AggregateType EnumUtil::FromString(const char *value); +template<> +AllowParserOverride EnumUtil::FromString(const char *value); + template<> AlterDatabaseType EnumUtil::FromString(const char *value); @@ -1411,6 +1424,9 @@ ExtensionUpdateResultTag EnumUtil::FromString(const ch template<> ExtraDropInfoType EnumUtil::FromString(const char *value); +template<> +ExtraPersistentColumnDataType EnumUtil::FromString(const char *value); + template<> ExtraTypeInfoType EnumUtil::FromString(const char *value); diff --git a/src/duckdb/src/include/duckdb/common/enums/allow_parser_override.hpp b/src/duckdb/src/include/duckdb/common/enums/allow_parser_override.hpp new file mode 100644 index 000000000..f342cf224 --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/enums/allow_parser_override.hpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/enums/allow_parser_override.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/constants.hpp" + +namespace duckdb { + +enum class AllowParserOverride : uint8_t { + DEFAULT_OVERRIDE, + FALLBACK_OVERRIDE, + STRICT_OVERRIDE, + STRICT_WHEN_SUPPORTED +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp b/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp index 5198f7627..988667145 100644 --- a/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/compression_type.hpp @@ -79,7 +79,6 @@ struct CompressionAvailabilityResult { CompressionAvailabilityResult CompressionTypeIsAvailable(CompressionType compression_type, optional_ptr storage_manager = nullptr); vector ListCompressionTypes(void); -CompressionType CompressionTypeFromString(const string &str); string CompressionTypeToString(CompressionType type); } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp b/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp index 0a5728aa6..8a6f38eae 100644 --- a/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp @@ -138,6 +138,7 @@ enum class ExpressionType : uint8_t { FUNCTION_REF = 204, TABLE_REF = 205, LAMBDA_REF = 206, + TYPE = 207, // ----------------------------- // Miscellaneous @@ -180,6 +181,7 @@ enum class ExpressionClass : uint8_t { POSITIONAL_REFERENCE = 18, BETWEEN = 19, LAMBDA_REF = 20, + TYPE = 21, //===--------------------------------------------------------------------===// // Bound Expressions //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/include/duckdb/common/enums/lambda_syntax.hpp b/src/duckdb/src/include/duckdb/common/enums/lambda_syntax.hpp new file mode 100644 index 000000000..c729b953e --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/enums/lambda_syntax.hpp @@ -0,0 +1,17 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/common/enums/lambda_syntax.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/constants.hpp" + +namespace duckdb { + +enum class LambdaSyntax : uint8_t { DEFAULT = 0, ENABLE_SINGLE_ARROW = 1, DISABLE_SINGLE_ARROW = 2 }; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp b/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp index 55dc0b62e..775f8e702 100644 --- a/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp +++ b/src/duckdb/src/include/duckdb/common/enums/memory_tag.hpp @@ -27,9 +27,12 @@ enum class MemoryTag : uint8_t { EXTENSION = 11, TRANSACTION = 12, EXTERNAL_FILE_CACHE = 13, - WINDOW = 14 + WINDOW = 14, + OBJECT_CACHE = 15, + // Intentionally left as the end, used to indicate memory tag type count. + UNKNOWN = 16, }; -static constexpr const idx_t MEMORY_TAG_COUNT = 15; +static constexpr const idx_t MEMORY_TAG_COUNT = static_cast(MemoryTag::UNKNOWN); } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/extra_type_info.hpp b/src/duckdb/src/include/duckdb/common/extra_type_info.hpp index 152e37d15..6fe9e1d00 100644 --- a/src/duckdb/src/include/duckdb/common/extra_type_info.hpp +++ b/src/duckdb/src/include/duckdb/common/extra_type_info.hpp @@ -15,6 +15,8 @@ namespace duckdb { +class ParsedExpression; + //! Extra Type Info Type enum class ExtraTypeInfoType : uint8_t { INVALID_TYPE_INFO = 0, @@ -24,13 +26,13 @@ enum class ExtraTypeInfoType : uint8_t { LIST_TYPE_INFO = 4, STRUCT_TYPE_INFO = 5, ENUM_TYPE_INFO = 6, - USER_TYPE_INFO = 7, + UNBOUND_TYPE_INFO = 7, AGGREGATE_STATE_TYPE_INFO = 8, ARRAY_TYPE_INFO = 9, ANY_TYPE_INFO = 10, INTEGER_LITERAL_TYPE_INFO = 11, TEMPLATE_TYPE_INFO = 12, - GEO_TYPE_INFO = 13 + GEO_TYPE_INFO = 13, }; struct ExtraTypeInfo { @@ -158,28 +160,6 @@ struct AggregateStateTypeInfo : public ExtraTypeInfo { AggregateStateTypeInfo(); }; -struct UserTypeInfo : public ExtraTypeInfo { - explicit UserTypeInfo(string name_p); - UserTypeInfo(string name_p, vector modifiers_p); - UserTypeInfo(string catalog_p, string schema_p, string name_p, vector modifiers_p); - - string catalog; - string schema; - string user_type_name; - vector user_type_modifiers; - -public: - void Serialize(Serializer &serializer) const override; - static shared_ptr Deserialize(Deserializer &source); - shared_ptr Copy() const override; - -protected: - bool EqualsInternal(ExtraTypeInfo *other_p) const override; - -private: - UserTypeInfo(); -}; - // If this type is primarily stored in the catalog or not. Enums from Pandas/Factors are not in the catalog. enum EnumDictType : uint8_t { INVALID = 0, VECTOR_DICT = 1 }; @@ -294,4 +274,20 @@ struct GeoTypeInfo : public ExtraTypeInfo { bool EqualsInternal(ExtraTypeInfo *other_p) const override; }; +struct UnboundTypeInfo : public ExtraTypeInfo { + explicit UnboundTypeInfo(unique_ptr expr_p); + + unique_ptr expr; + + void Serialize(Serializer &serializer) const override; + static shared_ptr Deserialize(Deserializer &source); + shared_ptr Copy() const override; + +protected: + bool EqualsInternal(ExtraTypeInfo *other_p) const override; + +private: + UnboundTypeInfo(); +}; + } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/file_open_flags.hpp b/src/duckdb/src/include/duckdb/common/file_open_flags.hpp index 89cd24b78..9f71e2c54 100644 --- a/src/duckdb/src/include/duckdb/common/file_open_flags.hpp +++ b/src/duckdb/src/include/duckdb/common/file_open_flags.hpp @@ -31,6 +31,7 @@ class FileOpenFlags { static constexpr idx_t FILE_FLAGS_NULL_IF_EXISTS = idx_t(1 << 10); static constexpr idx_t FILE_FLAGS_MULTI_CLIENT_ACCESS = idx_t(1 << 11); static constexpr idx_t FILE_FLAGS_DISABLE_LOGGING = idx_t(1 << 12); + static constexpr idx_t FILE_FLAGS_ENABLE_EXTENSION_INSTALL = idx_t(1 << 13); public: FileOpenFlags() = default; @@ -128,6 +129,9 @@ class FileOpenFlags { inline bool DisableLogging() const { return flags & FILE_FLAGS_DISABLE_LOGGING; } + inline bool EnableExtensionInstall() const { + return flags & FILE_FLAGS_ENABLE_EXTENSION_INSTALL; + } inline idx_t GetFlagsInternal() const { return flags; } @@ -173,6 +177,9 @@ class FileFlags { //! Disables logging to avoid infinite loops when using FileHandle-backed log storage static constexpr FileOpenFlags FILE_FLAGS_DISABLE_LOGGING = FileOpenFlags(FileOpenFlags::FILE_FLAGS_DISABLE_LOGGING); + //! Opened file is allowed to be a duckdb_extension + static constexpr FileOpenFlags FILE_FLAGS_ENABLE_EXTENSION_INSTALL = + FileOpenFlags(FileOpenFlags::FILE_FLAGS_ENABLE_EXTENSION_INSTALL); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/file_system.hpp b/src/duckdb/src/include/duckdb/common/file_system.hpp index 825f22d17..ac5c8d87f 100644 --- a/src/duckdb/src/include/duckdb/common/file_system.hpp +++ b/src/duckdb/src/include/duckdb/common/file_system.hpp @@ -38,6 +38,7 @@ class FileSystem; class Logger; class ClientContext; class QueryContext; +class MultiFileList; enum class FileType { //! Regular file @@ -251,7 +252,11 @@ class FileSystem { DUCKDB_API static bool HasGlob(const string &str); //! Runs a glob on the file system, returning a list of matching files DUCKDB_API virtual vector Glob(const string &path, FileOpener *opener = nullptr); - DUCKDB_API vector GlobFiles(const string &path, ClientContext &context, + DUCKDB_API unique_ptr Glob(const string &path, const FileGlobInput &input, + optional_ptr opener); + DUCKDB_API unique_ptr GlobFileList(const string &path, + const FileGlobInput &input = FileGlobOptions::DISALLOW_EMPTY); + DUCKDB_API vector GlobFiles(const string &pattern, const FileGlobInput &input = FileGlobOptions::DISALLOW_EMPTY); //! registers a sub-file system to handle certain file name prefixes, e.g. http:// etc. @@ -315,6 +320,10 @@ class FileSystem { optional_ptr opener); DUCKDB_API virtual bool SupportsListFilesExtended() const; + DUCKDB_API virtual unique_ptr GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener = nullptr); + DUCKDB_API virtual bool SupportsGlobExtended() const; + public: template TARGET &Cast() { diff --git a/src/duckdb/src/include/duckdb/common/http_util.hpp b/src/duckdb/src/include/duckdb/common/http_util.hpp index a493647b3..e0666dc26 100644 --- a/src/duckdb/src/include/duckdb/common/http_util.hpp +++ b/src/duckdb/src/include/duckdb/common/http_util.hpp @@ -219,6 +219,8 @@ struct PostRequestInfo : public BaseRequest { const_data_ptr_t buffer_in; idx_t buffer_in_len; string buffer_out; + //! Used to send a GET request with a body (non-standard but supported by some servers) + bool send_post_as_get_request = false; }; class HTTPClient { diff --git a/src/duckdb/src/include/duckdb/common/local_file_system.hpp b/src/duckdb/src/include/duckdb/common/local_file_system.hpp index 8d941475e..fce47be65 100644 --- a/src/duckdb/src/include/duckdb/common/local_file_system.hpp +++ b/src/duckdb/src/include/duckdb/common/local_file_system.hpp @@ -67,9 +67,6 @@ class LocalFileSystem : public FileSystem { //! Sync a file handle to disk void FileSync(FileHandle &handle) override; - //! Runs a glob on the file system, returning a list of matching files - vector Glob(const string &path, FileOpener *opener = nullptr) override; - bool CanHandleFile(const string &fpath) override { //! Whether or not a sub-system can handle a specific file path return false; @@ -100,6 +97,8 @@ class LocalFileSystem : public FileSystem { // returns a C-string of the path that trims any file:/ prefix static const char *NormalizeLocalPath(const string &path); + vector FetchFileWithoutGlob(const string &path, optional_ptr opener, bool absolute_path); + protected: bool ListFilesExtended(const string &directory, const std::function &callback, optional_ptr opener) override; @@ -108,12 +107,16 @@ class LocalFileSystem : public FileSystem { return true; } + unique_ptr GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener) override; + bool SupportsGlobExtended() const override { + return true; + } + private: //! Set the file pointer of a file handle to a specified location. Reads and writes will happen from this location void SetFilePointer(FileHandle &handle, idx_t location); idx_t GetFilePointer(FileHandle &handle); - - vector FetchFileWithoutGlob(const string &path, FileOpener *opener, bool absolute_path); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/lru_cache.hpp b/src/duckdb/src/include/duckdb/common/lru_cache.hpp index 322f5d550..d0a6bbfc3 100644 --- a/src/duckdb/src/include/duckdb/common/lru_cache.hpp +++ b/src/duckdb/src/include/duckdb/common/lru_cache.hpp @@ -11,11 +11,13 @@ #include #include "duckdb/common/common.hpp" +#include "duckdb/common/exception.hpp" #include "duckdb/common/list.hpp" #include "duckdb/common/mutex.hpp" #include "duckdb/common/shared_ptr.hpp" #include "duckdb/common/string.hpp" #include "duckdb/common/unordered_map.hpp" +#include "duckdb/storage/buffer/buffer_pool_reservation.hpp" namespace duckdb { @@ -40,8 +42,13 @@ class SharedLruCache { ~SharedLruCache() = default; // Insert `value` with key `key` and explicit memory size. This will replace any previous entry with the same key. - void Put(Key key, shared_ptr value, idx_t memory_size) { + void Put(Key key, shared_ptr value, unique_ptr reservation) { + if (reservation == nullptr) { + throw InvalidInputException("Reservation cannot be null when emplace into LRU!"); + } + // Remove existing entry if present + const idx_t memory_size = reservation->size; auto existing_it = entry_map.find(key); if (existing_it != entry_map.end()) { DeleteImpl(existing_it); @@ -56,8 +63,8 @@ class SharedLruCache { lru_list.emplace_front(key); Entry new_entry; new_entry.value = std::move(value); - new_entry.memory = memory_size; new_entry.lru_iterator = lru_list.begin(); + new_entry.reservation = std::move(reservation); entry_map[std::move(key)] = std::move(new_entry); current_memory += memory_size; @@ -88,11 +95,29 @@ class SharedLruCache { // Clear the whole cache. void Clear() { + for (auto &entry : entry_map) { + D_ASSERT(entry.second.reservation != nullptr); + entry.second.reservation->Resize(0); + } entry_map.clear(); lru_list.clear(); current_memory = 0; } + // Evict entries based on their access, until we've freed at least the target number of bytes or there's no entries + // in the cache. Return number of bytes freed. + idx_t EvictToReduceMemory(idx_t target_bytes) { + idx_t freed = 0; + while (!lru_list.empty() && freed < target_bytes) { + const auto &stale_key = lru_list.back(); + auto stale_it = entry_map.find(stale_key); + D_ASSERT(stale_it != entry_map.end()); + freed += stale_it->second.reservation->size; + DeleteImpl(stale_it); + } + return freed; + } + idx_t MaxMemory() const { return max_memory; } @@ -102,18 +127,25 @@ class SharedLruCache { size_t Size() const { return entry_map.size(); } + bool IsEmpty() const { + return entry_map.empty(); + } private: struct Entry { shared_ptr value; idx_t memory; typename list::iterator lru_iterator; + // Record memory reservation in the buffer pool, which is used for global memory control. + unique_ptr reservation; }; using EntryMap = unordered_map; void DeleteImpl(typename EntryMap::iterator iter) { - current_memory -= iter->second.memory; + current_memory -= iter->second.reservation->size; + D_ASSERT(current_memory >= 0); + iter->second.reservation->Resize(0); lru_list.erase(iter->second.lru_iterator); entry_map.erase(iter); } diff --git a/src/duckdb/src/include/duckdb/common/multi_file/multi_file_function.hpp b/src/duckdb/src/include/duckdb/common/multi_file/multi_file_function.hpp index d7777a052..13dbf15bf 100644 --- a/src/duckdb/src/include/duckdb/common/multi_file/multi_file_function.hpp +++ b/src/duckdb/src/include/duckdb/common/multi_file/multi_file_function.hpp @@ -122,7 +122,7 @@ class MultiFileFunction : public TableFunction { if (!result->file_options.union_by_name && bound_on_first_file) { file_string = result->file_list->GetFirstFile().path; } else { - for (auto &file : result->file_list->GetPaths()) { + for (auto &file : result->file_list->GetAllFiles()) { if (!file_string.empty()) { file_string += ","; } @@ -708,7 +708,22 @@ class MultiFileFunction : public TableFunction { const GlobalTableFunctionState *global_state) { auto &gstate = global_state->Cast(); - auto total_count = gstate.file_list.GetTotalFileCount(); + // get the file count - for >100 files we allow a lower bound to be given instead + auto count_info = gstate.file_list.GetFileCount(100); + while (count_info.type != FileExpansionType::ALL_FILES_EXPANDED) { + // the entire glob has not yet been expanded - we don't know how many files there are exactly + // we try to postpone expanding the glob by only expanding it once we have scanned 1% of the files + // check if we have reached AT LEAST 1% of progress + idx_t one_percent_min = count_info.count / 100; + if (gstate.completed_file_index < one_percent_min) { + // we have not - just report 0% + return 0.0; + } + // we have reached 1% given the currently known (incomplete) list of files + // retrieve more files to scan + count_info = gstate.file_list.GetFileCount(count_info.count + 1); + } + auto total_count = count_info.count; if (total_count == 0) { return 100.0; } @@ -754,7 +769,14 @@ class MultiFileFunction : public TableFunction { if (file_list_cardinality_estimate) { return file_list_cardinality_estimate; } - return data.interface->GetCardinality(data, data.file_list->GetTotalFileCount()); + // get the file count - for >500 files we allow an estimate + auto count_info = data.file_list->GetFileCount(500); + idx_t estimated_file_count = count_info.count; + if (count_info.type != FileExpansionType::ALL_FILES_EXPANDED) { + // not all files have been expanded - it's probably twice as many files + estimated_file_count *= 2; + } + return data.interface->GetCardinality(data, estimated_file_count); } static void MultiFileComplexFilterPushdown(ClientContext &context, LogicalGet &get, FunctionData *bind_data_p, @@ -776,7 +798,7 @@ class MultiFileFunction : public TableFunction { auto &bind_data = bind_data_p->Cast(); vector file_path; - for (const auto &file : bind_data.file_list->Files()) { + for (const auto &file : bind_data.file_list->GetDisplayFileList()) { file_path.emplace_back(file.path); } @@ -812,7 +834,7 @@ class MultiFileFunction : public TableFunction { result.insert(make_pair("Total Files Read", std::to_string(files_loaded))); constexpr size_t FILE_NAME_LIST_LIMIT = 5; - auto file_paths = gstate.file_list.GetPaths(); + auto file_paths = gstate.file_list.GetDisplayFileList(FILE_NAME_LIST_LIMIT + 1); if (!file_paths.empty()) { vector file_path_names; for (idx_t i = 0; i < MinValue(file_paths.size(), FILE_NAME_LIST_LIMIT); i++) { diff --git a/src/duckdb/src/include/duckdb/common/multi_file/multi_file_list.hpp b/src/duckdb/src/include/duckdb/common/multi_file/multi_file_list.hpp index ded5bad05..077076b14 100644 --- a/src/duckdb/src/include/duckdb/common/multi_file/multi_file_list.hpp +++ b/src/duckdb/src/include/duckdb/common/multi_file/multi_file_list.hpp @@ -17,26 +17,39 @@ namespace duckdb { class MultiFileList; enum class FileExpandResult : uint8_t { NO_FILES, SINGLE_FILE, MULTIPLE_FILES }; +enum class MultiFileListScanType { ALWAYS_FETCH, FETCH_IF_AVAILABLE }; + +enum class FileExpansionType { ALL_FILES_EXPANDED, NOT_ALL_FILES_KNOWN }; struct MultiFileListScanData { idx_t current_file_idx = DConstants::INVALID_INDEX; + MultiFileListScanType scan_type = MultiFileListScanType::ALWAYS_FETCH; +}; + +struct MultiFileCount { + explicit MultiFileCount(idx_t count, FileExpansionType type = FileExpansionType::ALL_FILES_EXPANDED) + : count(count), type(type) { + } + + idx_t count; + FileExpansionType type; }; class MultiFileListIterationHelper { public: - DUCKDB_API explicit MultiFileListIterationHelper(MultiFileList &collection); + DUCKDB_API explicit MultiFileListIterationHelper(const MultiFileList &collection); private: - MultiFileList &file_list; + const MultiFileList &file_list; private: class MultiFileListIterator; class MultiFileListIterator { public: - DUCKDB_API explicit MultiFileListIterator(MultiFileList *file_list); + DUCKDB_API explicit MultiFileListIterator(optional_ptr file_list); - optional_ptr file_list; + optional_ptr file_list; MultiFileListScanData file_scan_data; OpenFileInfo current_file; @@ -69,53 +82,50 @@ struct MultiFilePushdownInfo { //! NOTE: subclasses are responsible for ensuring thread-safety class MultiFileList { public: - MultiFileList(vector paths, FileGlobOptions options); - MultiFileList(vector paths, FileGlobInput input); + MultiFileList(); virtual ~MultiFileList(); - //! Returns the raw, unexpanded paths, pre-filter - const vector GetPaths() const; - //! Get Iterator over the files for pretty for loops - MultiFileListIterationHelper Files(); + MultiFileListIterationHelper Files() const; //! Initialize a sequential scan over a file list - void InitializeScan(MultiFileListScanData &iterator); + void InitializeScan(MultiFileListScanData &iterator) const; //! Scan the next file into result_file, returns false when out of files - bool Scan(MultiFileListScanData &iterator, OpenFileInfo &result_file); + bool Scan(MultiFileListScanData &iterator, OpenFileInfo &result_file) const; //! Returns the first file or an empty string if GetTotalFileCount() == 0 - OpenFileInfo GetFirstFile(); + OpenFileInfo GetFirstFile() const; //! Syntactic sugar for GetExpandResult() == FileExpandResult::NO_FILES - bool IsEmpty(); + bool IsEmpty() const; //! Virtual functions for subclasses public: virtual unique_ptr ComplexFilterPushdown(ClientContext &context, const MultiFileOptions &options, MultiFilePushdownInfo &info, - vector> &filters); + vector> &filters) const; virtual unique_ptr DynamicFilterPushdown(ClientContext &context, const MultiFileOptions &options, const vector &names, const vector &types, const vector &column_ids, TableFilterSet &filters) const; - virtual vector GetAllFiles() = 0; - virtual FileExpandResult GetExpandResult() = 0; - virtual idx_t GetTotalFileCount() = 0; + virtual vector GetAllFiles() const = 0; + virtual FileExpandResult GetExpandResult() const = 0; + //! Get the total file count - forces all files to be expanded / known so the exact count can be computed + virtual idx_t GetTotalFileCount() const = 0; + //! Get the file count - anything under "min_exact_count" is allowed to be incomplete (i.e. `NOT_ALL_FILES_KNOWN`) + //! This allows us to get a rough idea of the file count + virtual MultiFileCount GetFileCount(idx_t min_exact_count = 0) const; + virtual vector GetDisplayFileList(optional_idx max_files = optional_idx()) const; - virtual unique_ptr GetCardinality(ClientContext &context); - virtual unique_ptr Copy(); + virtual unique_ptr GetCardinality(ClientContext &context) const; + virtual unique_ptr Copy() const; protected: + //! Whether or not the file at the index is available instantly - or if this requires additional I/O + virtual bool FileIsAvailable(idx_t i) const; //! Get the i-th expanded file - virtual OpenFileInfo GetFile(idx_t i) = 0; - -protected: - //! The unexpanded input paths - const vector paths; - //! Whether paths can expand to 0 files - const FileGlobInput glob_input; + virtual OpenFileInfo GetFile(idx_t i) const = 0; public: template @@ -136,64 +146,73 @@ class SimpleMultiFileList : public MultiFileList { public: //! Construct a SimpleMultiFileList from a list of already expanded files explicit SimpleMultiFileList(vector paths); - //! Copy `paths` to `filtered_files` and apply the filters - unique_ptr ComplexFilterPushdown(ClientContext &context, const MultiFileOptions &options, - MultiFilePushdownInfo &info, - vector> &filters) override; - unique_ptr DynamicFilterPushdown(ClientContext &context, const MultiFileOptions &options, - const vector &names, const vector &types, - const vector &column_ids, - TableFilterSet &filters) const override; //! Main MultiFileList API - vector GetAllFiles() override; - FileExpandResult GetExpandResult() override; - idx_t GetTotalFileCount() override; + vector GetAllFiles() const override; + FileExpandResult GetExpandResult() const override; + idx_t GetTotalFileCount() const override; protected: //! Main MultiFileList API - OpenFileInfo GetFile(idx_t i) override; + OpenFileInfo GetFile(idx_t i) const override; + +protected: + //! The list of input paths + const vector paths; }; -//! MultiFileList that takes a list of paths and produces a list of files with all globs expanded -class GlobMultiFileList : public MultiFileList { +//! Lazily expanded MultiFileList +class LazyMultiFileList : public MultiFileList { public: - GlobMultiFileList(ClientContext &context, vector paths, FileGlobInput glob_input); - //! Calls ExpandAll, then prunes the expanded_files using the hive/filename filters - unique_ptr ComplexFilterPushdown(ClientContext &context, const MultiFileOptions &options, - MultiFilePushdownInfo &info, - vector> &filters) override; - unique_ptr DynamicFilterPushdown(ClientContext &context, const MultiFileOptions &options, - const vector &names, const vector &types, - const vector &column_ids, - TableFilterSet &filters) const override; + explicit LazyMultiFileList(optional_ptr context); - //! Main MultiFileList API - vector GetAllFiles() override; - FileExpandResult GetExpandResult() override; - idx_t GetTotalFileCount() override; + vector GetAllFiles() const override; + FileExpandResult GetExpandResult() const override; + idx_t GetTotalFileCount() const override; + MultiFileCount GetFileCount(idx_t min_exact_count = 0) const override; protected: - //! Main MultiFileList API - OpenFileInfo GetFile(idx_t i) override; + bool FileIsAvailable(idx_t i) const override; + OpenFileInfo GetFile(idx_t i) const override; - //! Get the i-th expanded file - OpenFileInfo GetFileInternal(idx_t i); - //! Grabs the next path and expands it into Expanded paths: returns false if no more files to expand - bool ExpandNextPath(); //! Grabs the next path and expands it into Expanded paths: returns false if no more files to expand - bool ExpandPathInternal(idx_t ¤t_path, vector &result) const; - //! Whether all files have been expanded - bool IsFullyExpanded() const; + virtual bool ExpandNextPath() const = 0; - //! The ClientContext for globbing - ClientContext &context; - //! The current path to expand - idx_t current_path; - //! The expanded files - vector expanded_files; +private: + bool ExpandNextPathInternal() const; +protected: mutable mutex lock; + //! The expanded files + mutable vector expanded_files; + //! Whether or not all files have been expanded + mutable bool all_files_expanded = false; + optional_ptr context; +}; + +//! MultiFileList that takes a list of globs and resolves all of the globs lazily into files +class GlobMultiFileList : public LazyMultiFileList { +public: + GlobMultiFileList(ClientContext &context, vector globs, FileGlobInput input); + + vector GetDisplayFileList(optional_idx max_files = optional_idx()) const override; + +protected: + bool ExpandNextPath() const override; + +protected: + //! The ClientContext for globbing + ClientContext &context; + //! The list of globs to expand + const vector globs; + //! Glob input + const FileGlobInput glob_input; + //! The current glob to expand + mutable idx_t current_glob; + //! File lists for the underlying globs + mutable vector> file_lists; + //! Current scan state + mutable MultiFileListScanData scan_state; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/opener_file_system.hpp b/src/duckdb/src/include/duckdb/common/opener_file_system.hpp index 265de2aff..e3eeab8bd 100644 --- a/src/duckdb/src/include/duckdb/common/opener_file_system.hpp +++ b/src/duckdb/src/include/duckdb/common/opener_file_system.hpp @@ -9,6 +9,7 @@ #pragma once #include "duckdb/common/file_system.hpp" +#include "duckdb/common/multi_file/multi_file_list.hpp" namespace duckdb { @@ -21,6 +22,18 @@ class OpenerFileSystem : public FileSystem { void VerifyNoOpener(optional_ptr opener); void VerifyCanAccessDirectory(const string &path); void VerifyCanAccessFile(const string &path); + void VerifyCanAccessExtension(const string &path, const FileOpenFlags &flags) { + if (flags.OpenForWriting() && !flags.EnableExtensionInstall()) { + throw PermissionException( + "File '%s' cannot be opened for writing since files ending with '.duckdb_extension' are reserved for " + "DuckDB extensions, and these can only be installed through the INSTALL command", + path); + } + } + + bool IsDuckDBExtensionName(const string &path) { + return StringUtil::EndsWith(path, ".duckdb_extension"); + } void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override { GetFileSystem().Read(handle, buffer, nr_bytes, location); @@ -83,6 +96,13 @@ class OpenerFileSystem : public FileSystem { VerifyNoOpener(opener); VerifyCanAccessFile(source); VerifyCanAccessFile(target); + if (IsDuckDBExtensionName(target) && !IsDuckDBExtensionName(source)) { + throw PermissionException( + "File '%s' cannot be moved to '%s', files ending with '.duckdb_extension' are reserved for DuckDB " + "extensions, and these can only be installed through the INSTALL command, or moved if both are " + "extensions'", + source, target); + } GetFileSystem().MoveFile(source, target, GetOpener()); } @@ -150,6 +170,10 @@ class OpenerFileSystem : public FileSystem { GetFileSystem().UnregisterSubSystem(name); } + unique_ptr ExtractSubSystem(const string &name) override { + return GetFileSystem().ExtractSubSystem(name); + } + void SetDisabledFileSystems(const vector &names) override { GetFileSystem().SetDisabledFileSystems(names); } @@ -171,6 +195,9 @@ class OpenerFileSystem : public FileSystem { optional_ptr opener = nullptr) override { VerifyNoOpener(opener); VerifyCanAccessFile(file.path); + if (IsDuckDBExtensionName(file.path)) { + VerifyCanAccessExtension(file.path, flags); + } return GetFileSystem().OpenFile(file, flags, GetOpener()); } @@ -189,6 +216,17 @@ class OpenerFileSystem : public FileSystem { return true; } + unique_ptr GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener) override { + VerifyNoOpener(opener); + VerifyCanAccessFile(path); + return GetFileSystem().Glob(path, input, GetOpener()); + } + + bool SupportsGlobExtended() const override { + return true; + } + private: void VerifyCanAccessFileInternal(const string &path, FileType type); }; diff --git a/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp b/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp index e495e9760..26dbad58c 100644 --- a/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp +++ b/src/duckdb/src/include/duckdb/common/operator/cast_operators.hpp @@ -1095,4 +1095,16 @@ struct CastFromPointer { template <> duckdb::string_t CastFromPointer::Operation(uintptr_t input, Vector &vector); +//===--------------------------------------------------------------------===// +// Types +//===--------------------------------------------------------------------===// +struct CastFromType { + template + static inline string_t Operation(SRC input, Vector &result) { + throw duckdb::NotImplementedException("Cast from pointer could not be performed!"); + } +}; +template <> +duckdb::string_t CastFromType::Operation(string_t input, Vector &vector); + } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/operator/negate.hpp b/src/duckdb/src/include/duckdb/common/operator/negate.hpp new file mode 100644 index 000000000..f5b1f3f7b --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/operator/negate.hpp @@ -0,0 +1,34 @@ +#pragma once + +#include "duckdb/common/limits.hpp" +#include "duckdb/common/exception.hpp" + +namespace duckdb { + +struct NegateOperator { + template + static bool CanNegate(T input) { + using Limits = NumericLimits; + return !(Limits::IsSigned() && Limits::Minimum() == input); + } + + template + static inline TR Operation(TA input) { + if (!CanNegate(input)) { + throw OutOfRangeException("Overflow in negation of numeric value!"); + } + return -(TR)input; + } +}; + +// Specialization for floating point (always negatable) +template <> +inline bool NegateOperator::CanNegate(float input) { + return true; +} +template <> +inline bool NegateOperator::CanNegate(double input) { + return true; +} + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp b/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp index ee1d11afb..382b60dd2 100644 --- a/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp +++ b/src/duckdb/src/include/duckdb/common/row_operations/row_operations.hpp @@ -18,9 +18,7 @@ class ArenaAllocator; struct AggregateObject; struct AggregateFilterData; class DataChunk; -class RowLayout; class TupleDataLayout; -class RowDataCollection; struct SelectionVector; class StringHeap; struct UnifiedVectorFormat; diff --git a/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp b/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp index 8668bbb4c..6b6d8dcc9 100644 --- a/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp +++ b/src/duckdb/src/include/duckdb/common/shared_ptr_ipp.hpp @@ -250,6 +250,18 @@ class shared_ptr { // NOLINT: invalid case style return internal >= other.internal; } + shared_ptr atomic_load() const { + return shared_ptr(std::atomic_load(&internal)); + } + + shared_ptr atomic_load(std::memory_order order) const { + return shared_ptr(std::atomic_load_explicit(&internal, order)); + } + + void atomic_store(const shared_ptr &new_ptr) { + std::atomic_store(&internal, new_ptr.internal); + } + private: // This overload is used when the class inherits from 'enable_shared_from_this' template static string ToString(const vector &input, const string &separator) { diff --git a/src/duckdb/src/include/duckdb/common/types.hpp b/src/duckdb/src/include/duckdb/common/types.hpp index 343a4e4f0..b6e24805c 100644 --- a/src/duckdb/src/include/duckdb/common/types.hpp +++ b/src/duckdb/src/include/duckdb/common/types.hpp @@ -22,6 +22,7 @@ class Value; class TypeCatalogEntry; class Vector; class ClientContext; +class ParsedExpression; class CoordinateReferenceSystem; struct string_t; // NOLINT: mimic std casing @@ -186,8 +187,7 @@ enum class LogicalTypeId : uint8_t { SQLNULL = 1, /* NULL type, used for constant NULL */ UNKNOWN = 2, /* unknown type, used for parameter expressions */ ANY = 3, /* ANY type, used for functions that accept any type as parameter */ - USER = 4, /* A User Defined Type (e.g., ENUMs before the binder) */ - + UNBOUND = 4, /* A parsed but unbound type, used during query planning */ // A "template" type functions as a "placeholder" type for function arguments and return types. // Templates only exist during the binding phase, in the scope of a function, and are replaced with concrete types @@ -196,6 +196,8 @@ enum class LogicalTypeId : uint8_t { // name are always resolved to the same concrete type. TEMPLATE = 5, + TYPE = 6, /* Type type, used for type parameters */ + BOOLEAN = 10, TINYINT = 11, SMALLINT = 12, @@ -284,6 +286,9 @@ struct LogicalType { inline bool IsUnknown() const { return id_ == LogicalTypeId::UNKNOWN; } + inline bool IsUnbound() const { + return id_ == LogicalTypeId::UNBOUND; + } inline shared_ptr GetAuxInfoShrPtr() const { return type_info_; @@ -352,6 +357,7 @@ struct LogicalType { //! Returns the maximum logical type when combining the two types - or throws an exception if combining is not possible DUCKDB_API static LogicalType MaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right); DUCKDB_API static bool TryGetMaxLogicalType(ClientContext &context, const LogicalType &left, const LogicalType &right, LogicalType &result); + DUCKDB_API static bool TryGetMaxLogicalTypeUnchecked(const LogicalType &left, const LogicalType &right, LogicalType &result); //! Forcibly returns a maximum logical type - similar to MaxLogicalType but never throws. As a fallback either left or right are returned. DUCKDB_API static LogicalType ForceMaxLogicalType(const LogicalType &left, const LogicalType &right); //! Normalize a type - removing literals @@ -444,9 +450,8 @@ struct LogicalType { DUCKDB_API static LogicalType INTEGER_LITERAL(const Value &constant); // NOLINT // DEPRECATED - provided for backwards compatibility DUCKDB_API static LogicalType ENUM(const string &enum_name, Vector &ordered_data, idx_t size); // NOLINT - DUCKDB_API static LogicalType USER(const string &user_type_name); // NOLINT - DUCKDB_API static LogicalType USER(const string &user_type_name, const vector &user_type_mods); // NOLINT - DUCKDB_API static LogicalType USER(string catalog, string schema, string name, vector user_type_mods); // NOLINT + DUCKDB_API static LogicalType UNBOUND(unique_ptr expr); // NOLINT + DUCKDB_API static LogicalType TYPE(); // NOLINT //! A list of all NUMERIC types (integral and floating point types) DUCKDB_API static const vector Numeric(); //! A list of all INTEGRAL types @@ -477,12 +482,12 @@ struct ListType { DUCKDB_API static const LogicalType &GetChildType(const LogicalType &type); }; -struct UserType { - DUCKDB_API static const string &GetCatalog(const LogicalType &type); - DUCKDB_API static const string &GetSchema(const LogicalType &type); - DUCKDB_API static const string &GetTypeName(const LogicalType &type); - DUCKDB_API static const vector &GetTypeModifiers(const LogicalType &type); - DUCKDB_API static vector &GetTypeModifiers(LogicalType &type); + +struct UnboundType { + // Try to bind the unbound type into a concrete type, using just the built in types + DUCKDB_API static LogicalType TryParseAndDefaultBind(const string &type_str); + DUCKDB_API static LogicalType TryDefaultBind(const LogicalType &unbound_type); + DUCKDB_API static const unique_ptr &GetTypeExpression(const LogicalType &type); }; struct EnumType { @@ -557,8 +562,6 @@ DUCKDB_API string LogicalTypeIdToString(LogicalTypeId type); DUCKDB_API LogicalTypeId TransformStringToLogicalTypeId(const string &str); -DUCKDB_API LogicalType TransformStringToLogicalType(const string &str); - DUCKDB_API LogicalType TransformStringToLogicalType(const string &str, ClientContext &context); //! The PhysicalType used by the row identifiers column diff --git a/src/duckdb/src/include/duckdb/common/types/geometry.hpp b/src/duckdb/src/include/duckdb/common/types/geometry.hpp index 1fcc9d7a1..65fff18d6 100644 --- a/src/duckdb/src/include/duckdb/common/types/geometry.hpp +++ b/src/duckdb/src/include/duckdb/common/types/geometry.hpp @@ -35,6 +35,7 @@ struct VertexXY { static constexpr auto TYPE = VertexType::XY; static constexpr auto HAS_Z = false; static constexpr auto HAS_M = false; + static constexpr auto WIDTH = 2; double x; double y; @@ -48,6 +49,7 @@ struct VertexXYZ { static constexpr auto TYPE = VertexType::XYZ; static constexpr auto HAS_Z = true; static constexpr auto HAS_M = false; + static constexpr auto WIDTH = 3; double x; double y; @@ -61,6 +63,7 @@ struct VertexXYM { static constexpr auto TYPE = VertexType::XYM; static constexpr auto HAS_M = true; static constexpr auto HAS_Z = false; + static constexpr auto WIDTH = 3; double x; double y; @@ -75,6 +78,7 @@ struct VertexXYZM { static constexpr auto TYPE = VertexType::XYZM; static constexpr auto HAS_Z = true; static constexpr auto HAS_M = true; + static constexpr auto WIDTH = 4; double x; double y; @@ -219,6 +223,17 @@ class Geometry { //! Update the bounding box, return number of vertices processed DUCKDB_API static uint32_t GetExtent(const string_t &wkb, GeometryExtent &extent); + DUCKDB_API static uint32_t GetExtent(const string_t &wkb, GeometryExtent &extent, bool &has_any_empty); + + //! Convert to vectorized format + DUCKDB_API static void ToVectorizedFormat(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + VertexType vert_type); + //! Convert from vectorized format + DUCKDB_API static void FromVectorizedFormat(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + VertexType vert_type, idx_t result_offset); + + //! Get the vectorized logical type for a given geometry and vertex type + DUCKDB_API static LogicalType GetVectorizedType(GeometryType geom_type, VertexType vert_type); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/types/null_value.hpp b/src/duckdb/src/include/duckdb/common/types/null_value.hpp index ed96b721a..9cf57f944 100644 --- a/src/duckdb/src/include/duckdb/common/types/null_value.hpp +++ b/src/duckdb/src/include/duckdb/common/types/null_value.hpp @@ -27,11 +27,12 @@ inline T NullValue() { return std::numeric_limits::min(); } -constexpr const char str_nil[2] = {'\200', '\0'}; +//! This could be two bytes but then GCC gives a warning when it's copied +constexpr const char str_nil[4] = {'\200', '\0', '\0', '\0'}; template <> inline const char *NullValue() { - D_ASSERT(str_nil[0] == '\200' && str_nil[1] == '\0'); + D_ASSERT(str_nil[0] == '\200' && str_nil[1] == '\0' && str_nil[2] == '\0' && str_nil[3] == '\0'); return str_nil; } diff --git a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp b/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp deleted file mode 100644 index 74196f00c..000000000 --- a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection.hpp +++ /dev/null @@ -1,132 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/common/types/row/row_data_collection.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb/common/common.hpp" -#include "duckdb/common/types/vector.hpp" -#include "duckdb/storage/buffer_manager.hpp" -#include "duckdb/storage/buffer/block_handle.hpp" - -namespace duckdb { - -struct RowDataBlock { -public: - RowDataBlock(MemoryTag tag, BufferManager &buffer_manager, idx_t capacity, idx_t entry_size) - : capacity(capacity), entry_size(entry_size), count(0), byte_offset(0) { - auto size = MaxValue(buffer_manager.GetBlockSize(), capacity * entry_size); - auto buffer_handle = buffer_manager.Allocate(tag, size, false); - block = buffer_handle.GetBlockHandle(); - D_ASSERT(BufferManager::GetAllocSize(size + block->block_manager.GetBlockHeaderSize()) == - block->GetMemoryUsage()); - } - - explicit RowDataBlock(idx_t entry_size) : entry_size(entry_size) { - } - //! The buffer block handle - shared_ptr block; - //! Capacity (number of entries) and entry size that fit in this block - idx_t capacity; - const idx_t entry_size; - //! Number of entries currently in this block - idx_t count; - //! Write offset (if variable size entries) - idx_t byte_offset; - -private: - //! Implicit copying is not allowed - RowDataBlock(const RowDataBlock &) = delete; - -public: - unique_ptr Copy() { - auto result = make_uniq(entry_size); - result->block = block; - result->capacity = capacity; - result->count = count; - result->byte_offset = byte_offset; - return result; - } -}; - -struct BlockAppendEntry { - BlockAppendEntry(data_ptr_t baseptr, idx_t count) : baseptr(baseptr), count(count) { - } - data_ptr_t baseptr; - idx_t count; -}; - -class RowDataCollection { -public: - RowDataCollection(BufferManager &buffer_manager, idx_t block_capacity, idx_t entry_size, bool keep_pinned = false); - - unique_ptr CloneEmpty(bool keep_pinned = false) const { - return make_uniq(buffer_manager, block_capacity, entry_size, keep_pinned); - } - - //! BufferManager - BufferManager &buffer_manager; - //! The total number of stored entries - idx_t count; - //! The number of entries per block - idx_t block_capacity; - //! Size of entries in the blocks - idx_t entry_size; - //! The blocks holding the main data - vector> blocks; - //! The blocks that this collection currently has pinned - vector pinned_blocks; - //! Whether the blocks should stay pinned (necessary for e.g. a heap) - const bool keep_pinned; - -public: - idx_t AppendToBlock(RowDataBlock &block, BufferHandle &handle, vector &append_entries, - idx_t remaining, idx_t entry_sizes[]); - RowDataBlock &CreateBlock(); - vector Build(idx_t added_count, data_ptr_t key_locations[], idx_t entry_sizes[], - const SelectionVector *sel = FlatVector::IncrementalSelectionVector()); - - void Merge(RowDataCollection &other); - - void Clear() { - blocks.clear(); - pinned_blocks.clear(); - count = 0; - } - - //! The size (in bytes) of this RowDataCollection - idx_t SizeInBytes() const { - VerifyBlockSizes(); - idx_t size = 0; - for (auto &block : blocks) { - size += block->block->GetMemoryUsage(); - } - return size; - } - - //! Verifies that the block sizes are correct (Debug only) - void VerifyBlockSizes() const { -#ifdef DEBUG - for (auto &block : blocks) { - D_ASSERT(block->block->GetMemoryUsage() == - BufferManager::GetAllocSize(block->capacity * entry_size + Storage::DEFAULT_BLOCK_HEADER_SIZE)); - } -#endif - } - - static inline idx_t EntriesPerBlock(const idx_t width, const idx_t block_size) { - return block_size / width; - } - -private: - mutex rdc_lock; - - //! Copying is not allowed - RowDataCollection(const RowDataCollection &) = delete; -}; - -} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp b/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp deleted file mode 100644 index b805c0955..000000000 --- a/src/duckdb/src/include/duckdb/common/types/row/row_data_collection_scanner.hpp +++ /dev/null @@ -1,123 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/common/types/row/row_data_collection_scanner.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb/common/types.hpp" -#include "duckdb/common/types/row/row_layout.hpp" - -namespace duckdb { - -class BufferHandle; -class RowDataCollection; -struct RowDataBlock; -class DataChunk; - -//! Used to scan the data into DataChunks after sorting -struct RowDataCollectionScanner { -public: - using Types = vector; - - struct ScanState { - explicit ScanState(const RowDataCollectionScanner &scanner_p) : scanner(scanner_p), block_idx(0), entry_idx(0) { - } - - void PinData(); - - //! The data layout - const RowDataCollectionScanner &scanner; - - idx_t block_idx; - idx_t entry_idx; - - BufferHandle data_handle; - BufferHandle heap_handle; - - // We must pin ALL blocks we are going to gather from - vector pinned_blocks; - }; - - //! Ensure that heap blocks correspond to row blocks - static void AlignHeapBlocks(RowDataCollection &dst_block_collection, RowDataCollection &dst_string_heap, - RowDataCollection &src_block_collection, RowDataCollection &src_string_heap, - const RowLayout &layout); - - RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external, - bool flush = true); - - // Single block scan - RowDataCollectionScanner(RowDataCollection &rows, RowDataCollection &heap, const RowLayout &layout, bool external, - idx_t block_idx, bool flush); - - //! The type layout of the payload - inline const vector &GetTypes() const { - return layout.GetTypes(); - } - - //! The number of rows in the collection - inline idx_t Count() const { - return total_count; - } - - //! The number of rows scanned so far - inline idx_t Scanned() const { - return total_scanned; - } - - //! The number of remaining rows - inline idx_t Remaining() const { - return total_count - total_scanned; - } - - //! The number of remaining rows - inline idx_t BlockIndex() const { - return read_state.block_idx; - } - - //! Swizzle the blocks for external scanning - //! Swizzling is all or nothing, so if we have scanned previously, - //! we need to re-swizzle. - void ReSwizzle(); - - void SwizzleBlock(idx_t block_idx); - - //! Scans the next data chunk from the sorted data - void Scan(DataChunk &chunk); - - //! Resets to the start and updates the flush flag - void Reset(bool flush = true); - -private: - //! The row data being scanned - RowDataCollection &rows; - //! The row heap being scanned - RowDataCollection &heap; - //! The data layout - const RowLayout layout; - //! Read state - ScanState read_state; - //! The total count of sorted_data - idx_t total_count; - //! The number of rows scanned so far - idx_t total_scanned; - //! Addresses used to gather from the sorted data - Vector addresses = Vector(LogicalType::POINTER); - //! Whether the blocks can be flushed to disk - const bool external; - //! Whether to flush the blocks after scanning - bool flush; - //! Whether we are unswizzling the blocks - const bool unswizzling; - - //! Swizzle a single block - void SwizzleBlockInternal(RowDataBlock &data_block, RowDataBlock &heap_block); - //! Checks that the newest block is valid - void ValidateUnscannedBlock() const; -}; - -} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/types/row/row_layout.hpp b/src/duckdb/src/include/duckdb/common/types/row/row_layout.hpp deleted file mode 100644 index 702cba4d2..000000000 --- a/src/duckdb/src/include/duckdb/common/types/row/row_layout.hpp +++ /dev/null @@ -1,82 +0,0 @@ -//===----------------------------------------------------------------------===// -// DuckDB -// -// duckdb/common/types/row/row_layout.hpp -// -// -//===----------------------------------------------------------------------===// - -#pragma once - -#include "duckdb/common/common.hpp" -#include "duckdb/common/types/validity_mask.hpp" -#include "duckdb/execution/operator/aggregate/aggregate_object.hpp" -#include "duckdb/planner/expression.hpp" - -namespace duckdb { - -class RowLayout { -public: - friend class TupleDataLayout; - using ValidityBytes = TemplatedValidityMask; - - //! Creates an empty RowLayout - RowLayout(); - -public: - //! Initializes the RowLayout with the specified types to an empty RowLayout - void Initialize(vector types, bool align = true); - //! Returns the number of data columns - inline idx_t ColumnCount() const { - return types.size(); - } - //! Returns a list of the column types for this data chunk - inline const vector &GetTypes() const { - return types; - } - //! Returns the total width required for each row, including padding - inline idx_t GetRowWidth() const { - return row_width; - } - //! Returns the offset to the start of the data - inline idx_t GetDataOffset() const { - return flag_width; - } - //! Returns the total width required for the data, including padding - inline idx_t GetDataWidth() const { - return data_width; - } - //! Returns the offset to the start of the aggregates - inline idx_t GetAggrOffset() const { - return flag_width + data_width; - } - //! Returns the column offsets into each row - inline const vector &GetOffsets() const { - return offsets; - } - //! Returns whether all columns in this layout are constant size - inline bool AllConstant() const { - return all_constant; - } - inline idx_t GetHeapOffset() const { - return heap_pointer_offset; - } - -private: - //! The types of the data columns - vector types; - //! The width of the validity header - idx_t flag_width; - //! The width of the data portion - idx_t data_width; - //! The width of the entire row - idx_t row_width; - //! The offsets to the columns and aggregate data in each row - vector offsets; - //! Whether all columns in this layout are constant size - bool all_constant; - //! Offset to the pointer to the heap for each row - idx_t heap_pointer_offset; -}; - -} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/types/type_manager.hpp b/src/duckdb/src/include/duckdb/common/types/type_manager.hpp new file mode 100644 index 000000000..2347bba75 --- /dev/null +++ b/src/duckdb/src/include/duckdb/common/types/type_manager.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include "duckdb/common/types.hpp" +#include "duckdb/common/types/string.hpp" + +namespace duckdb { + +class ClientContext; +class DatabaseInstance; +class CastFunctionSet; +struct DBConfig; + +class TypeManager { +public: + explicit TypeManager(DBConfig &config); + + ~TypeManager(); + + //! Get the CastFunctionSet from the TypeManager + CastFunctionSet &GetCastFunctions(); + + //! Try to parse and bind a logical type from a string. Throws an exception if the type could not be parsed. + LogicalType ParseLogicalType(const string &type_str, ClientContext &context) const; + + //! Get the TypeManager from the DatabaseInstance + static TypeManager &Get(DatabaseInstance &db); + static TypeManager &Get(ClientContext &context); + +private: + //! This has to be a function pointer to avoid the compiler inlining the implementation and + //! blowing up the binary size of extensions that include type_manager.hpp + LogicalType (*parse_function)(const string &, ClientContext &); + + //! The set of cast functions + unique_ptr cast_functions; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/common/types/value.hpp b/src/duckdb/src/include/duckdb/common/types/value.hpp index 4b54a64d5..b93f5e5b7 100644 --- a/src/duckdb/src/include/duckdb/common/types/value.hpp +++ b/src/duckdb/src/include/duckdb/common/types/value.hpp @@ -36,6 +36,7 @@ class Value { friend struct UnionValue; friend struct ArrayValue; friend struct MapValue; + friend struct TypeValue; public: //! Create an empty NULL value of the specified type @@ -204,6 +205,9 @@ class Value { DUCKDB_API static Value GEOMETRY(const_data_ptr_t data, idx_t len); DUCKDB_API static Value GEOMETRY(const_data_ptr_t data, idx_t len, const CoordinateReferenceSystem &crs); + DUCKDB_API static Value TYPE(const LogicalType &type); + DUCKDB_API static Value TYPE(const string_t &serialized_type); + //! Creates an aggregate state DUCKDB_API static Value AGGREGATE_STATE(const LogicalType &type, const_data_ptr_t data, idx_t len); // NOLINT @@ -468,6 +472,10 @@ struct UnionValue { DUCKDB_API static const LogicalType &GetType(const Value &value); }; +struct TypeValue { + DUCKDB_API static LogicalType GetType(const Value &value); +}; + //! Return the internal integral value for any type that is stored as an integral value internally //! This can be used on values of type integer, uinteger, but also date, timestamp, decimal, etc struct IntegralValue { diff --git a/src/duckdb/src/include/duckdb/common/types/variant.hpp b/src/duckdb/src/include/duckdb/common/types/variant.hpp index 280c9e695..4db6007b0 100644 --- a/src/duckdb/src/include/duckdb/common/types/variant.hpp +++ b/src/duckdb/src/include/duckdb/common/types/variant.hpp @@ -17,9 +17,18 @@ struct UnifiedVariantVector; struct RecursiveUnifiedVectorFormat; struct UnifiedVectorFormat; -enum class VariantChildLookupMode : uint8_t { BY_KEY, BY_INDEX }; +enum class VariantChildLookupMode : uint8_t { INVALID, BY_KEY, BY_INDEX }; struct VariantPathComponent { +public: + explicit VariantPathComponent() : lookup_mode(VariantChildLookupMode::INVALID) { + } + explicit VariantPathComponent(const string &key) : lookup_mode(VariantChildLookupMode::BY_KEY), key(key) { + } + explicit VariantPathComponent(uint32_t index) : lookup_mode(VariantChildLookupMode::BY_INDEX), index(index) { + } + +public: VariantChildLookupMode lookup_mode; string key; uint32_t index; @@ -30,8 +39,6 @@ struct VariantNestedData { uint32_t child_count; //! Index of the first child uint32_t children_idx; - //! Whether the row is null - bool is_null; }; struct VariantDecimalData { diff --git a/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp b/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp index e1b978ba7..2e0bb170f 100644 --- a/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp +++ b/src/duckdb/src/include/duckdb/common/virtual_file_system.hpp @@ -14,12 +14,14 @@ #include "duckdb/main/extension_helper.hpp" namespace duckdb { +struct FileSystemRegistry; // bunch of wrappers to allow registering protocol handlers class VirtualFileSystem : public FileSystem { public: VirtualFileSystem(); explicit VirtualFileSystem(unique_ptr &&inner_file_system); + ~VirtualFileSystem() override; void Read(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override; void Write(FileHandle &handle, void *buffer, int64_t nr_bytes, idx_t location) override; @@ -51,14 +53,9 @@ class VirtualFileSystem : public FileSystem { bool TryRemoveFile(const string &filename, optional_ptr opener) override; void RemoveFiles(const vector &filenames, optional_ptr opener) override; - vector Glob(const string &path, FileOpener *opener = nullptr) override; - void RegisterSubSystem(unique_ptr fs) override; - - void UnregisterSubSystem(const string &name) override; - void RegisterSubSystem(FileCompressionType compression_type, unique_ptr fs) override; - + void UnregisterSubSystem(const string &name) override; unique_ptr ExtractSubSystem(const string &name) override; vector ListSubSystems() override; @@ -85,17 +82,22 @@ class VirtualFileSystem : public FileSystem { return true; } + unique_ptr GlobFilesExtended(const string &path, const FileGlobInput &input, + optional_ptr opener) override; + bool SupportsGlobExtended() const override { + return true; + } + private: FileSystem &FindFileSystem(const string &path, optional_ptr file_opener); - FileSystem &FindFileSystem(const string &path, optional_ptr database_instance); - FileSystem &FindFileSystem(const string &path); - optional_ptr FindFileSystemInternal(const string &path); + FileSystem &FindFileSystem(shared_ptr ®istry, const string &path, + optional_ptr file_opener); + optional_ptr FindFileSystemInternal(FileSystemRegistry ®istry, const string &path); private: - vector> sub_systems; - map> compressed_fs; - const unique_ptr default_fs; - unordered_set disabled_file_systems; + mutex registry_lock; + shared_ptr file_system_registry; + vector> unregistered_file_systems; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp b/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp index 112e76109..fdccac78c 100644 --- a/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp +++ b/src/duckdb/src/include/duckdb/execution/expression_executor_state.hpp @@ -41,6 +41,9 @@ struct ExpressionState { void Verify(ExpressionExecutorState &root); + //! Reset any cached dictionary expression states in this expression state and its children + virtual void ResetDictionaryStates(); + public: template TARGET &Cast() { @@ -67,6 +70,8 @@ struct ExecuteFunctionState : public ExpressionState { bool TryExecuteDictionaryExpression(const BoundFunctionExpression &expr, DataChunk &args, ExpressionState &state, Vector &result); + void ResetDictionaryStates() override; + public: unique_ptr local_state; diff --git a/src/duckdb/src/include/duckdb/execution/index/art/art.hpp b/src/duckdb/src/include/duckdb/execution/index/art/art.hpp index 09e10aa80..35858ce7f 100644 --- a/src/duckdb/src/include/duckdb/execution/index/art/art.hpp +++ b/src/duckdb/src/include/duckdb/execution/index/art/art.hpp @@ -45,8 +45,6 @@ class ART : public BoundIndex { static constexpr uint8_t ALLOCATOR_COUNT = 9; //! FixedSizeAllocator count of deprecated ARTs. static constexpr uint8_t DEPRECATED_ALLOCATOR_COUNT = ALLOCATOR_COUNT - 3; - //! Keys must not exceed MAX_KEY_LEN * prefix_count. - static constexpr idx_t MAX_KEY_LEN = 8192; public: ART(const string &name, const IndexConstraintType index_constraint_type, const vector &column_ids, @@ -70,8 +68,6 @@ class ART : public BoundIndex { shared_ptr, ALLOCATOR_COUNT>> allocators; //! True, if the ART owns its data. bool owns_data; - //! True, if keys need a key length verification pass. - bool verify_max_key_len; public: //! Try to initialize a scan on the ART with the given expression and filter. diff --git a/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp b/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp index 49793f364..ddcffc8ba 100644 --- a/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp +++ b/src/duckdb/src/include/duckdb/execution/index/art/art_key.hpp @@ -73,7 +73,6 @@ class ARTKey { void Concat(ArenaAllocator &allocator, const ARTKey &other); row_t GetRowId() const; idx_t GetMismatchPos(const ARTKey &other, const idx_t start) const; - void VerifyKeyLength(const idx_t max_len) const; private: template diff --git a/src/duckdb/src/include/duckdb/execution/index/art/node.hpp b/src/duckdb/src/include/duckdb/execution/index/art/node.hpp index 3a02c3eec..465eddfab 100644 --- a/src/duckdb/src/include/duckdb/execution/index/art/node.hpp +++ b/src/duckdb/src/include/duckdb/execution/index/art/node.hpp @@ -225,15 +225,6 @@ class Node : public IndexPointer { inline void operator=(const IndexPointer &ptr) { Set(ptr.Get()); } - -private: - template - static void TransformToDeprecatedInternal(ART &art, unsafe_optional_ptr ptr, - TransformToDeprecatedState &state) { - if (ptr) { - NODE::Iterator(*ptr, [&](Node &child) { Node::TransformToDeprecated(art, child, state); }); - } - } }; //! NodeChildren holds the extracted bytes of a node, and their respective children. diff --git a/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp b/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp index b8c77733f..9c3b09455 100644 --- a/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp +++ b/src/duckdb/src/include/duckdb/execution/index/art/prefix.hpp @@ -25,6 +25,7 @@ class Prefix { static constexpr uint8_t ROW_ID_SIZE = sizeof(row_t); static constexpr uint8_t ROW_ID_COUNT = ROW_ID_SIZE - 1; static constexpr uint8_t DEPRECATED_COUNT = 15; + // The child pointer and the in_memory boolean. static constexpr uint8_t METADATA_SIZE = sizeof(Node) + 1; public: diff --git a/src/duckdb/src/include/duckdb/execution/index/art/prefix_handle.hpp b/src/duckdb/src/include/duckdb/execution/index/art/prefix_handle.hpp index d85a51747..3b5c905c4 100644 --- a/src/duckdb/src/include/duckdb/execution/index/art/prefix_handle.hpp +++ b/src/duckdb/src/include/duckdb/execution/index/art/prefix_handle.hpp @@ -39,7 +39,10 @@ class PrefixHandle { //! Create a new deprecated prefix node and return a handle to it. static PrefixHandle NewDeprecated(FixedSizeAllocator &allocator, Node &node); - static void TransformToDeprecated(ART &art, Node &node, TransformToDeprecatedState &state); + //! Transform prefix chain to deprecated format. + //! nullptr denotes an early out optimization (the prefix has not been loaded from storage, hence we do not need + //! to transform it. Otherwise, we get a pointer to the child node at the end of the prefix chain. + static optional_ptr TransformToDeprecated(ART &art, Node &node, TransformToDeprecatedState &state); private: PrefixHandle TransformToDeprecatedAppend(ART &art, FixedSizeAllocator &allocator, const uint8_t byte); diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp index 88345b3cc..56da7a90e 100644 --- a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp +++ b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_set.hpp @@ -16,6 +16,7 @@ namespace duckdb { struct DBConfig; +struct ConfigurationOption; struct ExtensionOption; //! PhysicalSet represents a SET operation (e.g. SET a = 42) @@ -42,7 +43,8 @@ class PhysicalSet : public PhysicalOperator { static void SetExtensionVariable(ClientContext &context, ExtensionOption &extension_option, const String &name, SetScope scope, const Value &value); - static void SetGenericVariable(ClientContext &context, const String &name, SetScope scope, Value target_value); + static void SetGenericVariable(ClientContext &context, idx_t setting_index, SetScope scope, Value target_value); + static SetScope GetSettingScope(const ConfigurationOption &option, SetScope variable_scope); public: String name; diff --git a/src/duckdb/src/include/duckdb/execution/physical_table_scan_enum.hpp b/src/duckdb/src/include/duckdb/execution/physical_table_scan_enum.hpp index 7fddde85d..0d275e2b3 100644 --- a/src/duckdb/src/include/duckdb/execution/physical_table_scan_enum.hpp +++ b/src/duckdb/src/include/duckdb/execution/physical_table_scan_enum.hpp @@ -1,7 +1,7 @@ //===----------------------------------------------------------------------===// // DuckDB // -// duckdb/common/enums/physical_table_scan_enum.hpp +// duckdb/execution/physical_table_scan_enum.hpp // // //===----------------------------------------------------------------------===// diff --git a/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp b/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp index 107b482b7..cab0e28f7 100644 --- a/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp +++ b/src/duckdb/src/include/duckdb/function/cast/default_casts.hpp @@ -171,6 +171,7 @@ struct DefaultCasts { static BoundCastInfo VariantCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target); static BoundCastInfo UUIDCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target); static BoundCastInfo GeoCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target); + static BoundCastInfo TypeCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target); static BoundCastInfo BignumCastSwitch(BindCastInput &input, const LogicalType &source, const LogicalType &target); static BoundCastInfo ImplicitToUnionCast(BindCastInput &input, const LogicalType &source, const LogicalType &target); diff --git a/src/duckdb/src/include/duckdb/function/cast/variant/primitive_to_variant.hpp b/src/duckdb/src/include/duckdb/function/cast/variant/primitive_to_variant.hpp index 9aa105bd3..250daef4a 100644 --- a/src/duckdb/src/include/duckdb/function/cast/variant/primitive_to_variant.hpp +++ b/src/duckdb/src/include/duckdb/function/cast/variant/primitive_to_variant.hpp @@ -392,6 +392,8 @@ bool ConvertPrimitiveToVariant(ToVariantSourceData &source, ToVariantGlobalResul case LogicalTypeId::BIT: return ConvertPrimitiveTemplated( source, result, count, selvec, values_index_selvec, empty_payload, is_root); + case LogicalTypeId::TYPE: + throw NotImplementedException("Cannot convert TYPE to VARIANT"); default: throw NotImplementedException("Invalid LogicalType (%s) for ConvertToVariant", EnumUtil::ToString(logical_type)); diff --git a/src/duckdb/src/include/duckdb/function/lambda_functions.hpp b/src/duckdb/src/include/duckdb/function/lambda_functions.hpp index 828dd609a..ac4208f1a 100644 --- a/src/duckdb/src/include/duckdb/function/lambda_functions.hpp +++ b/src/duckdb/src/include/duckdb/function/lambda_functions.hpp @@ -17,7 +17,11 @@ namespace duckdb { -struct ListLambdaBindData final : public FunctionData { +struct LambdaFunctionData : public FunctionData { + DUCKDB_API virtual const unique_ptr &GetLambdaExpression() const = 0; +}; + +struct ListLambdaBindData final : public LambdaFunctionData { public: ListLambdaBindData(const LogicalType &return_type, unique_ptr lambda_expr, const bool has_index = false, const bool has_initial = false) @@ -49,6 +53,10 @@ struct ListLambdaBindData final : public FunctionData { const ScalarFunction &function); //! Deserializes a lambda function's bind data static unique_ptr Deserialize(Deserializer &deserializer, ScalarFunction &); + + const unique_ptr &GetLambdaExpression() const override { + return lambda_expr; + } }; class LambdaFunctions { diff --git a/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp b/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp index f502b4e82..f476ff431 100644 --- a/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp +++ b/src/duckdb/src/include/duckdb/function/scalar/generic_functions.hpp @@ -55,4 +55,14 @@ struct CreateSortKeyFun { static ScalarFunction GetFunction(); }; +struct InvokeFun { + static constexpr const char *Name = "invoke"; + static constexpr const char *Parameters = "lambda,arg1,arg2,..."; + static constexpr const char *Description = "Invokes a lambda function with the given arguments"; + static constexpr const char *Example = "invoke(x -> x + 1, 5)"; + static constexpr const char *Categories = ""; + + static ScalarFunction GetFunction(); +}; + } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/scalar/variant_utils.hpp b/src/duckdb/src/include/duckdb/function/scalar/variant_utils.hpp index 1c20b19c0..78eb7bd36 100644 --- a/src/duckdb/src/include/duckdb/function/scalar/variant_utils.hpp +++ b/src/duckdb/src/include/duckdb/function/scalar/variant_utils.hpp @@ -16,6 +16,20 @@ namespace duckdb { +struct VariantExtractBindData : public FunctionData { +public: + explicit VariantExtractBindData(const string &str); + explicit VariantExtractBindData(uint32_t index); + VariantExtractBindData(const VariantExtractBindData &other) = default; + +public: + unique_ptr Copy() const override; + bool Equals(const FunctionData &other) const override; + +public: + VariantPathComponent component; +}; + struct VariantNestedDataCollectionResult { public: VariantNestedDataCollectionResult() : success(true) { @@ -73,10 +87,11 @@ struct VariantUtils { DUCKDB_API static void FindChildValues(const UnifiedVariantVectorData &variant, const VariantPathComponent &component, optional_ptr sel, SelectionVector &res, - ValidityMask &res_validity, VariantNestedData *nested_data, idx_t count); + ValidityMask &res_validity, const VariantNestedData *nested_data, + const ValidityMask &validity, idx_t count); DUCKDB_API static VariantNestedDataCollectionResult CollectNestedData(const UnifiedVariantVectorData &variant, VariantLogicalType expected_type, - const SelectionVector &sel, idx_t count, optional_idx row, idx_t offset, + const SelectionVector &value_index_sel, idx_t count, optional_idx row, idx_t offset, VariantNestedData *child_data, ValidityMask &validity); DUCKDB_API static vector ValueIsNull(const UnifiedVariantVectorData &variant, const SelectionVector &sel, idx_t count, optional_idx row); @@ -85,6 +100,8 @@ struct VariantUtils { DUCKDB_API static bool Verify(Vector &variant, const SelectionVector &sel_p, idx_t count); DUCKDB_API static void FinalizeVariantKeys(Vector &variant, OrderedOwningStringMap &dictionary, SelectionVector &sel, idx_t sel_size); + DUCKDB_API static void VariantExtract(Vector &input, const vector &components, Vector &result, + idx_t count); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/function/variant/variant_value_convert.hpp b/src/duckdb/src/include/duckdb/function/variant/variant_value_convert.hpp index 3b83418fa..5565c472b 100644 --- a/src/duckdb/src/include/duckdb/function/variant/variant_value_convert.hpp +++ b/src/duckdb/src/include/duckdb/function/variant/variant_value_convert.hpp @@ -103,7 +103,16 @@ struct ValueConverter { static Value VisitArray(const UnifiedVariantVectorData &variant, idx_t row, const VariantNestedData &nested_data) { auto array_items = VariantVisitor::VisitArrayItems(variant, row, nested_data); - return Value::LIST(LogicalType::VARIANT(), std::move(array_items)); + if (array_items.empty()) { + return Value::LIST(LogicalType::VARIANT(), std::move(array_items)); + } + auto &child_type = array_items[0].type(); + for (idx_t i = 1; i < array_items.size(); i++) { + if (child_type != array_items[i].type()) { + return Value::LIST(LogicalType::VARIANT(), std::move(array_items)); + } + } + return Value::LIST(child_type, std::move(array_items)); } static Value VisitObject(const UnifiedVariantVectorData &variant, idx_t row, const VariantNestedData &nested_data) { diff --git a/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp b/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp index 4504cfc30..04a0fae39 100644 --- a/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp +++ b/src/duckdb/src/include/duckdb/function/window/window_value_function.hpp @@ -79,7 +79,7 @@ class WindowNthValueExecutor : public WindowValueExecutor { class WindowFillExecutor : public WindowValueExecutor { public: - WindowFillExecutor(BoundWindowExpression &wexpr, WindowSharedExpressions &shared); + WindowFillExecutor(BoundWindowExpression &wexpr, ClientContext &client, WindowSharedExpressions &shared); //! Never ignore nulls (that's the point!) bool IgnoreNulls() const override { diff --git a/src/duckdb/src/include/duckdb/logging/logging.hpp b/src/duckdb/src/include/duckdb/logging/logging.hpp index 11d0760c7..8c74d38fa 100644 --- a/src/duckdb/src/include/duckdb/logging/logging.hpp +++ b/src/duckdb/src/include/duckdb/logging/logging.hpp @@ -41,12 +41,6 @@ struct LogConfig { LogConfig(); - DUCKDB_API static LogConfig Create(bool enabled, LogLevel level); - DUCKDB_API static LogConfig CreateFromEnabled(bool enabled, LogLevel level, - unordered_set &enabled_log_types); - DUCKDB_API static LogConfig CreateFromDisabled(bool enabled, LogLevel level, - unordered_set &disabled_log_types); - DUCKDB_API bool IsConsistent() const; bool enabled; diff --git a/src/duckdb/src/include/duckdb/main/appender.hpp b/src/duckdb/src/include/duckdb/main/appender.hpp index b637717f8..f1b6c091f 100644 --- a/src/duckdb/src/include/duckdb/main/appender.hpp +++ b/src/duckdb/src/include/duckdb/main/appender.hpp @@ -14,11 +14,12 @@ namespace duckdb { -class ColumnDataCollection; class ClientContext; +class ColumnDataCollection; +class Connection; class DuckDB; +class SQLStatement; class TableCatalogEntry; -class Connection; enum class AppenderType : uint8_t { LOGICAL, // Cast input -> LogicalType @@ -31,6 +32,14 @@ class BaseAppender { //! The amount of tuples that are gathered in the column data collection before flushing. static constexpr const idx_t DEFAULT_FLUSH_COUNT = STANDARD_VECTOR_SIZE * 100ULL; +public: + //! Returns a table reference to the appended data. + static unique_ptr GetColumnDataTableRef(ColumnDataCollection &collection, const string &table_name, + const vector &expected_names); + //! Parses the statement to append data. + static unique_ptr ParseStatement(unique_ptr table_ref, const string &query, + const string &table_name); + protected: //! The allocator for the column data collection. Allocator &allocator; @@ -148,6 +157,11 @@ class Appender : public BaseAppender { void AppendDefault(DataChunk &chunk, idx_t col, idx_t row) override; void AddColumn(const string &name) override; void ClearColumns() override; + //! Get the expected names based on the active columns. + vector GetExpectedNames(); + //! Construct a query that appends data from, typically, a column data collection. + static string ConstructQuery(TableDescription &description_p, const string &table_name, + const vector &expected_names); private: //! A shared pointer to the context of this appender. @@ -176,11 +190,11 @@ class QueryAppender : public BaseAppender { private: //! A shared pointer to the context of this appender. weak_ptr context; - //! The query to run + //! The query to run. string query; - //! The column names of the to-be-appended data, or "col1, col2, ..." if empty + //! The column names of the to-be-appended data, or "col1, col2, ...", if empty. vector names; - //! The table name that we can reference in the query, or "appended_data" if empty + //! The table name that we can reference in the query, or "appended_data", if empty. string table_name; protected: diff --git a/src/duckdb/src/include/duckdb/main/attached_database.hpp b/src/duckdb/src/include/duckdb/main/attached_database.hpp index 7a0d95a1b..da561c982 100644 --- a/src/duckdb/src/include/duckdb/main/attached_database.hpp +++ b/src/duckdb/src/include/duckdb/main/attached_database.hpp @@ -154,7 +154,7 @@ class AttachedDatabase : public CatalogEntry, public enable_shared_from_this close_lock; unordered_map attach_options; private: diff --git a/src/duckdb/src/include/duckdb/main/client_config.hpp b/src/duckdb/src/include/duckdb/main/client_config.hpp index e2b5c6926..40980b8a0 100644 --- a/src/duckdb/src/include/duckdb/main/client_config.hpp +++ b/src/duckdb/src/include/duckdb/main/client_config.hpp @@ -17,6 +17,7 @@ #include "duckdb/main/profiling_info.hpp" #include "duckdb/parser/expression/lambda_expression.hpp" #include "duckdb/main/query_profiler.hpp" +#include "duckdb/main/user_settings.hpp" namespace duckdb { @@ -27,8 +28,6 @@ class PreparedStatementData; typedef std::function get_result_collector_t; struct ClientConfig { - //! The home directory used by the system (if any) - string home_directory; //! If the query profiler is enabled or not. bool enable_profiler = false; //! If detailed query profiling is enabled @@ -57,9 +56,6 @@ struct ClientConfig { //! The wait time before showing the progress bar int wait_time = 2000; - //! The maximum expression depth limit in the parser - idx_t max_expression_depth = 1000; - //! Whether or not aggressive query verification is enabled bool query_verification_enabled = false; //! Whether or not verification of external operators is enabled, used for testing @@ -88,21 +84,12 @@ struct ClientConfig { //! Callback to create a progress bar display progress_bar_display_create_func_t display_create_func = nullptr; - //! The explain output type used when none is specified (default: PHYSICAL_ONLY) - ExplainOutputType explain_output_type = ExplainOutputType::PHYSICAL_ONLY; - - //! If DEFAULT or ENABLE_SINGLE_ARROW, it is possible to use the deprecated single arrow operator (->) for lambda - //! functions. Otherwise, DISABLE_SINGLE_ARROW. - LambdaSyntax lambda_syntax = LambdaSyntax::DEFAULT; //! The profiling coverage. SELECT is the default behavior, and ALL emits profiling information for all operator //! types. ProfilingCoverage profiling_coverage = ProfilingCoverage::SELECT; - //! Output error messages as structured JSON instead of as a raw string - bool errors_as_json = false; - //! Generic options - case_insensitive_map_t set_variables; + LocalUserSettings user_settings; //! Variables set by the user case_insensitive_map_t user_variables; @@ -127,16 +114,6 @@ struct ClientConfig { bool GetUserVariable(const string &name, Value &result); void ResetUserVariable(const String &name); - template - static typename OP::RETURN_TYPE GetSetting(const ClientContext &context) { - return OP::GetSetting(context).template GetValue(); - } - - template - static Value GetSettingValue(const ClientContext &context) { - return OP::GetSetting(context); - } - public: void SetDefaultStreamingBufferSize(); }; diff --git a/src/duckdb/src/include/duckdb/main/client_context.hpp b/src/duckdb/src/include/duckdb/main/client_context.hpp index 02edee9ca..e73e60bca 100644 --- a/src/duckdb/src/include/duckdb/main/client_context.hpp +++ b/src/duckdb/src/include/duckdb/main/client_context.hpp @@ -136,12 +136,10 @@ class ClientContext : public enable_shared_from_this { const string &table_name); //! Get the table info of a specific table, or nullptr if it cannot be found. Uses INVALID_CATALOG. DUCKDB_API unique_ptr TableInfo(const string &schema_name, const string &table_name); - //! Execute a query with the given collection "attached" to the query using a CTE - DUCKDB_API void Append(ColumnDataCollection &collection, const string &query, const vector &column_names, - const string &collection_name); - //! Appends a DataChunk and its default columns to the specified table. - DUCKDB_API void Append(TableDescription &description, ColumnDataCollection &collection, - optional_ptr> column_ids = nullptr); + //! Executes a query with the given collection "attached" to the query using a CTE. + DUCKDB_API void Append(unique_ptr stmt); + //! Appends a ColumnDataCollection to the described table. + DUCKDB_API void Append(TableDescription &description, ColumnDataCollection &collection); //! Try to bind a relation in the current client context; either throws an exception or fills the result_columns //! list with the set of returned columns @@ -200,6 +198,8 @@ class ClientContext : public enable_shared_from_this { //! Equivalent to CURRENT_SETTING(key) SQL function. DUCKDB_API SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) const; + //! Returns the value of the current setting set by the user - if the user has set it. + DUCKDB_API SettingLookupResult TryGetCurrentUserSetting(idx_t setting_index, Value &result) const; //! Returns the parser options for this client context DUCKDB_API ParserOptions GetParserOptions() const; @@ -231,6 +231,8 @@ class ClientContext : public enable_shared_from_this { //! Process an error for display to the user DUCKDB_API void ProcessError(ErrorData &error, const string &query) const; + DUCKDB_API LogicalType ParseLogicalType(const string &type); + private: //! Parse statements and resolve pragmas from a query vector> ParseStatements(ClientContextLock &lock, const string &query); @@ -309,8 +311,6 @@ class ClientContext : public enable_shared_from_this { unique_ptr statement, PendingQueryParameters parameters); - SettingLookupResult TryGetCurrentSettingInternal(const string &key, Value &result) const; - private: //! Lock on using the ClientContext in parallel mutex context_lock; diff --git a/src/duckdb/src/include/duckdb/main/client_data.hpp b/src/duckdb/src/include/duckdb/main/client_data.hpp index 7e901c498..a2068b68e 100644 --- a/src/duckdb/src/include/duckdb/main/client_data.hpp +++ b/src/duckdb/src/include/duckdb/main/client_data.hpp @@ -44,8 +44,6 @@ struct ClientData { //! The catalog search path. unique_ptr catalog_search_path; - //! The file search path. - string file_search_path; //! The file opener of the client context. unique_ptr file_opener; diff --git a/src/duckdb/src/include/duckdb/main/config.hpp b/src/duckdb/src/include/duckdb/main/config.hpp index 757d67c89..e36e43af3 100644 --- a/src/duckdb/src/include/duckdb/main/config.hpp +++ b/src/duckdb/src/include/duckdb/main/config.hpp @@ -30,14 +30,13 @@ #include "duckdb/execution/index/index_type_set.hpp" #include "duckdb/function/cast/default_casts.hpp" #include "duckdb/function/replacement_scan.hpp" -#include "duckdb/optimizer/optimizer_extension.hpp" -#include "duckdb/parser/parsed_data/create_info.hpp" -#include "duckdb/parser/parser_extension.hpp" -#include "duckdb/planner/operator_extension.hpp" #include "duckdb/storage/compression/bitpacking.hpp" #include "duckdb/function/encoding_function.hpp" #include "duckdb/main/setting_info.hpp" #include "duckdb/logging/log_manager.hpp" +#include "duckdb/main/user_settings.hpp" +#include "duckdb/parser/parsed_data/create_info.hpp" +#include "duckdb/common/types/type_manager.hpp" namespace duckdb { @@ -58,6 +57,8 @@ class CompressionInfo; class EncryptionUtil; class HTTPUtil; class DatabaseFilePathManager; +class ExtensionCallbackManager; +class TypeManager; struct CompressionFunctionSet; struct DatabaseCacheEntry; @@ -87,6 +88,9 @@ class SerializationCompatibility { SerializationCompatibility() = default; }; +//! NOTE: DBConfigOptions is mostly deprecated. +//! If you want to add a setting that can be set by the user, add it as a generic setting to `settings.json`. +//! See e.g. "http_proxy" (HTTPProxySetting) as an example struct DBConfigOptions { //! Database file path. May be empty for in-memory mode string database_path; @@ -100,33 +104,12 @@ struct DBConfigOptions { bool use_direct_io = false; //! Whether extensions should be loaded on start-up bool load_extensions = true; -#ifdef DUCKDB_EXTENSION_AUTOLOAD_DEFAULT - //! Whether known extensions are allowed to be automatically loaded when a query depends on them - bool autoload_known_extensions = DUCKDB_EXTENSION_AUTOLOAD_DEFAULT; -#else - bool autoload_known_extensions = false; -#endif -#ifdef DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT - //! Whether known extensions are allowed to be automatically installed when a query depends on them - bool autoinstall_known_extensions = DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT; -#else - bool autoinstall_known_extensions = false; -#endif - //! Setting for the parser override registered by extensions. Allowed options: "default, "fallback", "strict" - string allow_parser_override_extension = "default"; - //! Override for the default extension repository - string custom_extension_repo = ""; - //! Override for the default autoload extension repository - string autoinstall_extension_repo = ""; //! The maximum memory used by the database system (in bytes). Default: 80% of System available memory idx_t maximum_memory = DConstants::INVALID_INDEX; //! The maximum size of the 'temp_directory' folder when set (in bytes). Default: 90% of available disk space. idx_t maximum_swap_space = DConstants::INVALID_INDEX; //! The maximum amount of CPU threads used by the database system. Default: all available. idx_t maximum_threads = DConstants::INVALID_INDEX; - //! The number of external threads that work on DuckDB tasks. Default: 1. - //! Must be smaller or equal to maximum_threads. - idx_t external_threads = 1; //! Whether or not to create and use a temporary directory to store intermediates that do not fit in memory bool use_temporary_directory = true; //! Directory to store temporary structures that do not fit in memory @@ -136,20 +119,6 @@ struct DBConfigOptions { bool trim_free_blocks = false; //! Record timestamps of buffer manager unpin() events. Usable by custom eviction policies. bool buffer_manager_track_eviction_timestamps = false; - //! Whether or not to allow printing unredacted secrets - bool allow_unredacted_secrets = false; - //! Disables invalidating the database instance when encountering a fatal error. - bool disable_database_invalidation = false; - //! enable COPY and related commands - bool enable_external_access = true; - //! Whether or not the global http metadata cache is used - bool http_metadata_cache_enable = false; - //! HTTP Proxy config as 'hostname:port' - string http_proxy; - //! HTTP Proxy username for basic auth - string http_proxy_username; - //! HTTP Proxy password for basic auth - string http_proxy_password; //! Force checkpoint when CHECKPOINT is called or on shutdown, even if no changes have been made bool force_checkpoint = false; //! Run a checkpoint on successful shutdown and delete the WAL, to leave only a single database file behind @@ -161,52 +130,26 @@ struct DBConfigOptions { bool initialize_default_database = true; //! The set of disabled optimizers (default empty) set disabled_optimizers; - //! The average string length required to use ZSTD compression. - uint64_t zstd_min_string_length = 4096; - //! Force a specific compression method to be used when checkpointing (if available) - CompressionType force_compression = CompressionType::COMPRESSION_AUTO; - //! Force a specific bitpacking mode to be used when using the bitpacking compression method - BitpackingMode force_bitpacking_mode = BitpackingMode::AUTO; //! Force a specific schema for VARIANT shredding LogicalType force_variant_shredding = LogicalType::INVALID; - //! Minimum size of a rowgroup to enable VARIANT shredding, -1 to disable - int64_t variant_minimum_shredding_size = 30000; - //! Database configuration variables as controlled by SET - case_insensitive_map_t set_variables; //! Database configuration variable default values; case_insensitive_map_t set_variable_defaults; - //! Directory to store extension binaries in - string extension_directory; //! Additional directories to store extension binaries in vector extension_directories; - //! Whether unsigned extensions should be loaded - bool allow_unsigned_extensions = false; - //! Whether community extensions should be loaded - bool allow_community_extensions = true; //! Debug setting - how to initialize blocks in the storage layer when allocating DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE; //! The set of user-provided options case_insensitive_map_t user_options; //! The set of unrecognized (other) options case_insensitive_map_t unrecognized_options; - //! Whether or not the configuration settings can be altered - bool lock_configuration = false; //! Whether to print bindings when printing the plan (debug mode only) static bool debug_print_bindings; // NOLINT: debug setting //! The peak allocation threshold at which to flush the allocator after completing a task (1 << 27, ~128MB) idx_t allocator_flush_threshold = 134217728ULL; //! If bulk deallocation larger than this occurs, flush outstanding allocations (1 << 30, ~1GB) idx_t allocator_bulk_deallocation_flush_threshold = 536870912ULL; - //! Whether the allocator background thread is enabled - bool allocator_background_threads = false; - //! DuckDB API surface - string duckdb_api; //! Metadata from DuckDB callers string custom_user_agent; - //! Encrypt the temp files - bool temp_file_encryption = false; - //! The default block allocation size for new duckdb database files (new as-in, they do not yet exist). - idx_t default_block_alloc_size = DEFAULT_BLOCK_ALLOC_SIZE; //! The default block header size for new duckdb database files. idx_t default_block_header_size = DUCKDB_BLOCK_HEADER_STORAGE_SIZE; //! Whether or not to abort if a serialization exception is thrown during WAL playback (when reading truncated WAL) @@ -217,18 +160,6 @@ struct DBConfigOptions { set allowed_directories; //! The log configuration LogConfig log_config = LogConfig(); - //! Whether to enable external file caching using CachingFileSystem - bool enable_external_file_cache = true; - //! Cache validation mode, by default all cache entries are validated. - CacheValidationMode validate_external_file_cache = CacheValidationMode::VALIDATE_ALL; - //! Partially process tasks before rescheduling - allows for more scheduler fairness between separate queries -#ifdef DUCKDB_ALTERNATIVE_VERIFY - bool scheduler_process_partial = true; -#else - bool scheduler_process_partial = false; -#endif - //! Whether to pin threads to cores (linux only, default AUTOMATIC: on when there are more than 64 cores) - ThreadPinMode pin_threads = ThreadPinMode::AUTO; //! Physical memory that the block allocator is allowed to use (this memory is never freed and cannot be reduced) idx_t block_allocator_size = 0; @@ -245,12 +176,9 @@ struct DBConfig { DUCKDB_API DBConfig(const case_insensitive_map_t &config_dict, bool read_only); DUCKDB_API ~DBConfig(); - mutable mutex config_lock; //! Replacement table scans are automatically attempted when a table name cannot be found in the schema vector replacement_scans; - //! Extra parameters that can be SET for loaded extensions - case_insensitive_map_t extension_parameters; //! The FileSystem to use, can be overwritten to allow for injecting custom file systems for testing purposes (e.g. //! RamFS or something similar) unique_ptr file_system; @@ -262,24 +190,14 @@ struct DBConfig { unique_ptr block_allocator; //! Database configuration options DBConfigOptions options; - //! Extensions made to the parser - vector parser_extensions; - //! Extensions made to the optimizer - vector optimizer_extensions; //! Error manager unique_ptr error_manager; //! A reference to the (shared) default allocator (Allocator::DefaultAllocator) shared_ptr default_allocator; - //! Extensions made to binder - vector> operator_extensions; - //! Extensions made to storage - case_insensitive_map_t> storage_extensions; //! A buffer pool can be shared across multiple databases (if desired). shared_ptr buffer_pool; //! Provide a custom buffer manager implementation (if desired). shared_ptr buffer_manager; - //! Set of callbacks that can be installed by extensions - vector> extension_callbacks; //! Encryption Util for OpenSSL shared_ptr encryption_util; //! HTTP Request utility functions @@ -288,6 +206,8 @@ struct DBConfig { shared_ptr db_cache_entry; //! Reference to the database file path manager shared_ptr path_manager; + //! Database configuration variables as controlled by SET + GlobalUserSettings user_settings; public: DUCKDB_API static DBConfig &GetConfig(ClientContext &context); @@ -305,7 +225,9 @@ struct DBConfig { DUCKDB_API void AddExtensionOption(const string &name, string description, LogicalType parameter, const Value &default_value = Value(), set_option_callback_t function = nullptr, SetScope default_scope = SetScope::SESSION); - DUCKDB_API bool HasExtensionOption(const string &name); + DUCKDB_API bool HasExtensionOption(const string &name) const; + DUCKDB_API case_insensitive_map_t GetExtensionSettings() const; + DUCKDB_API bool TryGetExtensionOption(const String &name, ExtensionOption &result) const; //! Fetch an option by index. Returns a pointer to the option, or nullptr if out of range DUCKDB_API static optional_ptr GetOptionByIndex(idx_t index); //! Fetcha n alias by index, or nullptr if out of range @@ -314,12 +236,15 @@ struct DBConfig { DUCKDB_API static optional_ptr GetOptionByName(const String &name); DUCKDB_API void SetOption(const ConfigurationOption &option, const Value &value); DUCKDB_API void SetOption(optional_ptr db, const ConfigurationOption &option, const Value &value); + DUCKDB_API void SetOption(const string &name, Value value); + DUCKDB_API void SetOption(idx_t setting_index, Value value); DUCKDB_API void SetOptionByName(const string &name, const Value &value); DUCKDB_API void SetOptionsByName(const case_insensitive_map_t &values); DUCKDB_API void ResetOption(optional_ptr db, const ConfigurationOption &option); - DUCKDB_API void SetOption(const String &name, Value value); - DUCKDB_API void ResetOption(const String &name); - DUCKDB_API void ResetGenericOption(const String &name); + DUCKDB_API void ResetOption(const ExtensionOption &extension_option); + DUCKDB_API void ResetGenericOption(idx_t setting_index); + DUCKDB_API optional_idx TryGetSettingIndex(const String &name, + optional_ptr &option) const; static LogicalType ParseLogicalType(const string &type); DUCKDB_API void CheckLock(const String &name); @@ -352,6 +277,7 @@ struct DBConfig { bool operator!=(const DBConfig &other); DUCKDB_API CastFunctionSet &GetCastFunctions(); + DUCKDB_API TypeManager &GetTypeManager(); DUCKDB_API CollationBinding &GetCollationBinding(); DUCKDB_API IndexTypeSet &GetIndexTypes(); static idx_t GetSystemMaxThreads(FileSystem &fs); @@ -364,44 +290,29 @@ struct DBConfig { OrderByNullType ResolveNullOrder(ClientContext &context, OrderType order_type, OrderByNullType null_type) const; const string UserAgent() const; + //! Returns the value of a setting currently. If the setting is not set by the user, returns the default value. SettingLookupResult TryGetCurrentSetting(const string &key, Value &result) const; - - template - static typename std::enable_if::value, typename OP::RETURN_TYPE>::type - GetSetting(const SOURCE &source) { - return EnumUtil::FromString( - GetSettingInternal(source, OP::Name, OP::DefaultValue).ToString()); - } - - template - static typename std::enable_if::value, typename OP::RETURN_TYPE>::type - GetSetting(const SOURCE &source) { - return GetSettingInternal(source, OP::Name, OP::DefaultValue).template GetValue(); - } - - template - Value GetSettingValue(const ClientContext &context) const { - lock_guard lock(config_lock); - return OP::GetSetting(context); - } + //! Returns the value of a setting set by the user currently + SettingLookupResult TryGetCurrentUserSetting(idx_t setting_index, Value &result) const; + //! Returns the default value of an option + static SettingLookupResult TryGetDefaultValue(optional_ptr option, Value &result); bool CanAccessFile(const string &path, FileType type); void AddAllowedDirectory(const string &path); void AddAllowedPath(const string &path); string SanitizeAllowedPath(const string &path) const; + ExtensionCallbackManager &GetCallbackManager(); + const ExtensionCallbackManager &GetCallbackManager() const; private: - static Value GetSettingInternal(const DatabaseInstance &db, const char *setting, const char *default_value); - static Value GetSettingInternal(const DBConfig &config, const char *setting, const char *default_value); - static Value GetSettingInternal(const ClientContext &context, const char *setting, const char *default_value); - -private: + mutable mutex config_lock; unique_ptr compression_functions; unique_ptr encoding_functions; unique_ptr arrow_extensions; - unique_ptr cast_functions; + unique_ptr type_manager; unique_ptr collation_bindings; unique_ptr index_types; + unique_ptr callback_manager; bool is_user_config = true; }; diff --git a/src/duckdb/src/include/duckdb/main/connection.hpp b/src/duckdb/src/include/duckdb/main/connection.hpp index 1c88757fc..164dec6b8 100644 --- a/src/duckdb/src/include/duckdb/main/connection.hpp +++ b/src/duckdb/src/include/duckdb/main/connection.hpp @@ -139,9 +139,7 @@ class Connection { //! Extract the logical plan that corresponds to a query DUCKDB_API unique_ptr ExtractPlan(const string &query); - //! Appends a DataChunk to the specified table - DUCKDB_API void Append(TableDescription &description, DataChunk &chunk); - //! Appends a ColumnDataCollection to the specified table + //! Appends a ColumnDataCollection to the described table. DUCKDB_API void Append(TableDescription &description, ColumnDataCollection &collection); //! Returns a relation that produces a table from this connection diff --git a/src/duckdb/src/include/duckdb/main/extension_callback_manager.hpp b/src/duckdb/src/include/duckdb/main/extension_callback_manager.hpp new file mode 100644 index 000000000..03bc1d3eb --- /dev/null +++ b/src/duckdb/src/include/duckdb/main/extension_callback_manager.hpp @@ -0,0 +1,76 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/main/extension_callback_manager.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/mutex.hpp" +#include "duckdb/common/optional_ptr.hpp" +#include "duckdb/common/shared_ptr.hpp" +#include "duckdb/common/vector.hpp" + +namespace duckdb { + +class ClientContext; +class DatabaseInstance; +class ExtensionCallback; +class OperatorExtension; +class OptimizerExtension; +class ParserExtension; +class StorageExtension; +struct ExtensionCallbackRegistry; + +template +class ExtensionCallbackIteratorHelper; + +class ExtensionCallbackManager { +public: + ExtensionCallbackManager(); + ~ExtensionCallbackManager(); + + static ExtensionCallbackManager &Get(ClientContext &context); + static ExtensionCallbackManager &Get(DatabaseInstance &db); + static const ExtensionCallbackManager &Get(const ClientContext &context); + + void Register(ParserExtension extension); + void Register(OptimizerExtension extension); + void Register(shared_ptr extension); + void Register(const string &name, shared_ptr extension); + void Register(shared_ptr extension); + + ExtensionCallbackIteratorHelper> OperatorExtensions() const; + ExtensionCallbackIteratorHelper OptimizerExtensions() const; + ExtensionCallbackIteratorHelper ParserExtensions() const; + ExtensionCallbackIteratorHelper> ExtensionCallbacks() const; + optional_ptr FindStorageExtension(const string &name) const; + bool HasParserExtensions() const; + +private: + mutex registry_lock; + shared_ptr callback_registry; +}; + +template +class ExtensionCallbackIteratorHelper { +public: + ExtensionCallbackIteratorHelper(const vector &vec, shared_ptr callback_registry); + ~ExtensionCallbackIteratorHelper(); + +private: + const vector &vec; + shared_ptr callback_registry; + +public: + typename vector::const_iterator begin() { // NOLINT: match stl API + return vec.cbegin(); + } + typename vector::const_iterator end() { // NOLINT: match stl API + return vec.cend(); + } +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/main/extension_entries.hpp b/src/duckdb/src/include/duckdb/main/extension_entries.hpp index df7a0a7c3..d33750568 100644 --- a/src/duckdb/src/include/duckdb/main/extension_entries.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_entries.hpp @@ -211,6 +211,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"get_bit", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"get_current_time", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, {"get_current_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"get_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"grade_up", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"greatest", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"greatest_common_divisor", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, @@ -453,6 +454,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"make_timestamp_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"make_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"map_concat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, {"map_entries", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY}, @@ -628,6 +630,7 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = { {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, + {"st_interiorringn", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_interpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY}, {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY}, @@ -1044,6 +1047,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { {"ducklake_retry_wait_ms", "ducklake"}, {"enable_curl_server_cert_verification", "httpfs"}, {"enable_geoparquet_conversion", "parquet"}, + {"enable_global_s3_configuration", "httpfs"}, {"enable_server_cert_verification", "httpfs"}, {"force_download", "httpfs"}, {"hf_max_per_page", "httpfs"}, @@ -1056,9 +1060,12 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = { {"http_timeout", "httpfs"}, {"httpfs_client_implementation", "httpfs"}, {"iceberg_via_aws_sdk_for_catalog_interactions", "iceberg"}, + {"merge_http_secret_into_s3_request", "httpfs"}, {"mysql_bit1_as_boolean", "mysql_scanner"}, {"mysql_debug_show_queries", "mysql_scanner"}, + {"mysql_enable_transactions", "mysql_scanner"}, {"mysql_experimental_filter_pushdown", "mysql_scanner"}, + {"mysql_incomplete_dates_as_nulls", "mysql_scanner"}, {"mysql_session_time_zone", "mysql_scanner"}, {"mysql_time_as_time", "mysql_scanner"}, {"mysql_tinyint1_as_boolean", "mysql_scanner"}, diff --git a/src/duckdb/src/include/duckdb/main/extension_helper.hpp b/src/duckdb/src/include/duckdb/main/extension_helper.hpp index 480bc398f..6dd63f7db 100644 --- a/src/duckdb/src/include/duckdb/main/extension_helper.hpp +++ b/src/duckdb/src/include/duckdb/main/extension_helper.hpp @@ -11,6 +11,7 @@ #include "duckdb.hpp" #include "duckdb/main/extension_entries.hpp" #include "duckdb/main/extension_install_info.hpp" +#include "duckdb/main/settings.hpp" #include @@ -126,8 +127,15 @@ class ExtensionHelper { static vector GetExtensionDirectoryPath(ClientContext &context); static vector GetExtensionDirectoryPath(DatabaseInstance &db, FileSystem &fs); + // Check signature of an Extension stored as FileHandle static bool CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata, const bool allow_community_extensions); + // Check signature of an Extension, represented by a buffer and total_buffer_length, and a signature to be added + static bool CheckExtensionBufferSignature(const char *buffer, idx_t buffer_length, const string &signature, + const bool allow_community_extensions); + // Check signature of an Extension, represented by a buffer and total_buffer_length + static bool CheckExtensionBufferSignature(const char *buffer, idx_t total_buffer_length, + const bool allow_community_extensions); static ParsedExtensionMetaData ParseExtensionMetaData(const char *metadata) noexcept; static ParsedExtensionMetaData ParseExtensionMetaData(FileHandle &handle); @@ -207,9 +215,8 @@ class ExtensionHelper { //! Lookup a name in an extension entry and try to autoload it template static void TryAutoloadFromEntry(DatabaseInstance &db, const string &entry, const ExtensionEntry (&entries)[N]) { - auto &dbconfig = DBConfig::GetConfig(db); #ifndef DUCKDB_DISABLE_EXTENSION_LOAD - if (dbconfig.options.autoload_known_extensions) { + if (Settings::Get(db)) { auto extension_name = ExtensionHelper::FindExtensionInEntries(entry, entries); if (ExtensionHelper::CanAutoloadExtension(extension_name)) { ExtensionHelper::AutoLoadExtension(db, extension_name); diff --git a/src/duckdb/src/include/duckdb/main/secret/secret.hpp b/src/duckdb/src/include/duckdb/main/secret/secret.hpp index fd8a1b241..cc6ad1c94 100644 --- a/src/duckdb/src/include/duckdb/main/secret/secret.hpp +++ b/src/duckdb/src/include/duckdb/main/secret/secret.hpp @@ -252,7 +252,7 @@ class KeyValueSecret : public BaseSecret { class KeyValueSecretReader { public: //! Manually pass in a secret reference - KeyValueSecretReader(const KeyValueSecret &secret_p, FileOpener &opener_p) : secret(secret_p) {}; + KeyValueSecretReader(const KeyValueSecret &secret_p, FileOpener &opener_p); //! Initializes the KeyValueSecretReader by fetching the secret automatically KeyValueSecretReader(FileOpener &opener_p, optional_ptr info, const char **secret_types, diff --git a/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp b/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp index 80fb46044..8ba703dcd 100644 --- a/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp +++ b/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp @@ -16,8 +16,10 @@ #include "duckdb/parser/parsed_data/create_secret_info.hpp" namespace duckdb { -class SecretManager; + +struct BoundStatement; struct DBConfig; +class SecretManager; class SchemaCatalogEntry; //! A Secret Entry in the secret manager @@ -217,6 +219,9 @@ class DefaultSecretGenerator : public DefaultGenerator { unique_ptr CreateDefaultEntry(CatalogTransaction transaction, const string &entry_name) override; unique_ptr CreateDefaultEntry(ClientContext &context, const string &entry_name) override; vector GetDefaultEntries() override; + bool LockDuringCreate() const override { + return true; + } protected: unique_ptr CreateDefaultEntryInternal(const string &entry_name); diff --git a/src/duckdb/src/include/duckdb/main/setting_info.hpp b/src/duckdb/src/include/duckdb/main/setting_info.hpp index 7968c4d8f..8aaa19223 100644 --- a/src/duckdb/src/include/duckdb/main/setting_info.hpp +++ b/src/duckdb/src/include/duckdb/main/setting_info.hpp @@ -17,8 +17,6 @@ class ClientContext; class DatabaseInstance; struct DBConfig; -const string GetDefaultUserAgent(); - enum class SettingScope : uint8_t { //! Setting is from the global Setting scope GLOBAL, @@ -30,6 +28,18 @@ enum class SettingScope : uint8_t { INVALID }; +enum class SettingScopeTarget { + INVALID, + //! Setting can be set in global scope only + GLOBAL_ONLY, + //! Setting can be set in local scope only + LOCAL_ONLY, + //! Setting can be set in both scopes - but defaults to global + GLOBAL_DEFAULT, + //! Setting can be set in both scopes - but defaults to local + LOCAL_DEFAULT +}; + struct SettingLookupResult { public: SettingLookupResult() : scope(SettingScope::INVALID) { @@ -79,9 +89,10 @@ struct ConfigurationOption { reset_global_function_t reset_global; reset_local_function_t reset_local; get_setting_function_t get_setting; - SetScope default_scope; + SettingScopeTarget scope; const char *default_value; set_callback_t set_callback; + optional_idx setting_idx; }; struct ConfigurationAlias { @@ -92,6 +103,8 @@ struct ConfigurationAlias { typedef void (*set_option_callback_t)(ClientContext &context, SetScope scope, Value ¶meter); struct ExtensionOption { + ExtensionOption() : set_function(nullptr), default_scope(SetScope::AUTOMATIC) { + } // NOLINTNEXTLINE: work around bug in clang-tidy ExtensionOption(string description_p, LogicalType type_p, set_option_callback_t set_function_p, Value default_value_p, SetScope default_scope_p) @@ -104,6 +117,7 @@ struct ExtensionOption { set_option_callback_t set_function; Value default_value; SetScope default_scope; + optional_idx setting_index; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/main/settings.hpp b/src/duckdb/src/include/duckdb/main/settings.hpp index d87f8aa1a..4506c1231 100644 --- a/src/duckdb/src/include/duckdb/main/settings.hpp +++ b/src/duckdb/src/include/duckdb/main/settings.hpp @@ -8,21 +8,78 @@ #pragma once -#include "duckdb/main/config.hpp" #include "duckdb/main/setting_info.hpp" -#include "duckdb/common/enums/access_mode.hpp" -#include "duckdb/common/enums/cache_validation_mode.hpp" -#include "duckdb/common/enums/checkpoint_abort.hpp" -#include "duckdb/common/enums/debug_vector_verification.hpp" -#include "duckdb/common/enums/window_aggregation_mode.hpp" -#include "duckdb/common/enums/order_type.hpp" -#include "duckdb/common/enums/output_type.hpp" -#include "duckdb/common/enums/thread_pin_mode.hpp" -#include "duckdb/common/enums/arrow_format_version.hpp" -#include "duckdb/common/enums/storage_block_prefetch.hpp" +#include "duckdb/common/enum_util.hpp" namespace duckdb { +struct Settings { + template + static typename std::enable_if::value, typename OP::RETURN_TYPE>::type + Get(const SOURCE &source) { + Value result; + if (TryGetSettingInternal(source, OP::SettingIndex, result)) { + return EnumUtil::FromString(StringValue::Get(result)); + } + return EnumUtil::FromString(OP::DefaultValue); + } + + template + static typename std::enable_if::value, string>::type + Get(const SOURCE &source) { + Value result; + if (TryGetSettingInternal(source, OP::SettingIndex, result)) { + return StringValue::Get(result); + } + return OP::DefaultValue; + } + + template + static typename std::enable_if::value, bool>::type + Get(const SOURCE &source) { + Value result; + if (TryGetSettingInternal(source, OP::SettingIndex, result)) { + return BooleanValue::Get(result); + } + return StringUtil::Equals(OP::DefaultValue, "true"); + } + + template + static typename std::enable_if::value, idx_t>::type + Get(const SOURCE &source) { + Value result; + if (TryGetSettingInternal(source, OP::SettingIndex, result)) { + return UBigIntValue::Get(result); + } + return StringUtil::ToUnsigned(OP::DefaultValue); + } + + template + static typename std::enable_if::value, int64_t>::type + Get(const SOURCE &source) { + Value result; + if (TryGetSettingInternal(source, OP::SettingIndex, result)) { + return BigIntValue::Get(result); + } + return StringUtil::ToSigned(OP::DefaultValue); + } + + template + static typename std::enable_if::value, double>::type + Get(const SOURCE &source) { + Value result; + if (TryGetSettingInternal(source, OP::SettingIndex, result)) { + return DoubleValue::Get(result); + } + return StringUtil::ToDouble(OP::DefaultValue); + } + +private: + static bool TryGetSettingInternal(const DatabaseInstance &db, idx_t setting_index, Value &result); + static bool TryGetSettingInternal(const DBConfig &config, idx_t setting_index, Value &result); + static bool TryGetSettingInternal(const ClientContext &context, idx_t setting_index, Value &result); +}; + //===----------------------------------------------------------------------===// // This code is autogenerated from 'update_settings_header_file.py'. // Please do not make any changes directly here, as they will be overwritten. @@ -46,11 +103,10 @@ struct AllocatorBackgroundThreadsSetting { static constexpr const char *Name = "allocator_background_threads"; static constexpr const char *Description = "Whether to enable the allocator background thread."; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 0; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct AllocatorBulkDeallocationFlushThresholdSetting { @@ -80,11 +136,10 @@ struct AllowCommunityExtensionsSetting { static constexpr const char *Name = "allow_community_extensions"; static constexpr const char *Description = "Allow to load community built extensions"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "true"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 1; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct AllowExtensionsMetadataMismatchSetting { @@ -93,19 +148,19 @@ struct AllowExtensionsMetadataMismatchSetting { static constexpr const char *Description = "Allow to load extensions with not compatible metadata"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 2; }; struct AllowParserOverrideExtensionSetting { - using RETURN_TYPE = string; + using RETURN_TYPE = AllowParserOverride; static constexpr const char *Name = "allow_parser_override_extension"; static constexpr const char *Description = "Allow extensions to override the current parser"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "DEFAULT"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 3; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct AllowPersistentSecretsSetting { @@ -124,11 +179,10 @@ struct AllowUnredactedSecretsSetting { static constexpr const char *Name = "allow_unredacted_secrets"; static constexpr const char *Description = "Allow printing unredacted secrets"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 4; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct AllowUnsignedExtensionsSetting { @@ -136,11 +190,10 @@ struct AllowUnsignedExtensionsSetting { static constexpr const char *Name = "allow_unsigned_extensions"; static constexpr const char *Description = "Allow to load extensions with invalid or missing signatures"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 5; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct AllowedDirectoriesSetting { @@ -172,7 +225,8 @@ struct ArrowLargeBufferSizeSetting { "Whether Arrow buffers for strings, blobs, uuids and bits should be exported using large buffers"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 6; }; struct ArrowLosslessConversionSetting { @@ -183,7 +237,8 @@ struct ArrowLosslessConversionSetting { "with a duckdb.type_name extension name."; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 7; }; struct ArrowOutputListViewSetting { @@ -193,7 +248,8 @@ struct ArrowOutputListViewSetting { "Whether export to Arrow format should use ListView as the physical layout for LIST columns"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 8; }; struct ArrowOutputVersionSetting { @@ -203,7 +259,8 @@ struct ArrowOutputVersionSetting { "Whether strings should be produced by DuckDB in Utf8View format instead of Utf8"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "1.0"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 9; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -214,7 +271,8 @@ struct AsofLoopJoinThresholdSetting { "The maximum number of rows we need on the left side of an ASOF join to use a nested loop join"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "64"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 10; }; struct AutoinstallExtensionRepositorySetting { @@ -223,9 +281,9 @@ struct AutoinstallExtensionRepositorySetting { static constexpr const char *Description = "Overrides the custom endpoint for extension installation on autoloading"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 11; }; struct AutoinstallKnownExtensionsSetting { @@ -234,9 +292,13 @@ struct AutoinstallKnownExtensionsSetting { static constexpr const char *Description = "Whether known extensions are allowed to be automatically installed when a query depends on them"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); +#if defined(DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT) && DUCKDB_EXTENSION_AUTOINSTALL_DEFAULT + static constexpr const char *DefaultValue = "true"; +#else + static constexpr const char *DefaultValue = "false"; +#endif + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 12; }; struct AutoloadKnownExtensionsSetting { @@ -245,9 +307,13 @@ struct AutoloadKnownExtensionsSetting { static constexpr const char *Description = "Whether known extensions are allowed to be automatically loaded when a query depends on them"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); +#if defined(DUCKDB_EXTENSION_AUTOLOAD_DEFAULT) && DUCKDB_EXTENSION_AUTOLOAD_DEFAULT + static constexpr const char *DefaultValue = "true"; +#else + static constexpr const char *DefaultValue = "false"; +#endif + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 13; }; struct BlockAllocatorMemorySetting { @@ -268,7 +334,8 @@ struct CatalogErrorMaxSchemasSetting { "The maximum number of schemas the system will scan for \"did you mean...\" style errors in the catalog"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "100"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 14; }; struct CheckpointThresholdSetting { @@ -287,9 +354,9 @@ struct CustomExtensionRepositorySetting { static constexpr const char *Name = "custom_extension_repository"; static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 15; }; struct CustomProfilingSettingsSetting { @@ -318,7 +385,8 @@ struct DebugAsofIejoinSetting { static constexpr const char *Description = "DEBUG SETTING: force use of IEJoin to implement AsOf joins"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 16; }; struct DebugCheckpointAbortSetting { @@ -328,7 +396,8 @@ struct DebugCheckpointAbortSetting { "DEBUG SETTING: trigger an abort while checkpointing for testing purposes"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "NONE"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 17; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -338,7 +407,8 @@ struct DebugCheckpointSleepMsSetting { static constexpr const char *Description = "DEBUG SETTING: time to sleep before a checkpoint"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "0"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 18; }; struct DebugForceExternalSetting { @@ -359,7 +429,8 @@ struct DebugForceNoCrossProductSetting { "DEBUG SETTING: Force disable cross product generation when hyper graph isn't connected, used for testing"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 19; }; struct DebugPhysicalTableScanExecutionStrategySetting { @@ -369,7 +440,8 @@ struct DebugPhysicalTableScanExecutionStrategySetting { "DEBUG SETTING: force use of given strategy for executing physical table scans"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "DEFAULT"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 20; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -379,7 +451,8 @@ struct DebugSkipCheckpointOnCommitSetting { static constexpr const char *Description = "DEBUG SETTING: skip checkpointing on commit"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 21; }; struct DebugVerifyBlocksSetting { @@ -388,7 +461,8 @@ struct DebugVerifyBlocksSetting { static constexpr const char *Description = "DEBUG SETTING: verify block metadata during checkpointing"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 22; }; struct DebugVerifyVectorSetting { @@ -397,7 +471,8 @@ struct DebugVerifyVectorSetting { static constexpr const char *Description = "DEBUG SETTING: enable vector verification"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "NONE"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 23; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -407,7 +482,8 @@ struct DebugWindowModeSetting { static constexpr const char *Description = "DEBUG SETTING: switch window mode to use"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "WINDOW"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 24; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -417,9 +493,10 @@ struct DefaultBlockSizeSetting { static constexpr const char *Description = "The default block size for new duckdb database files (new as-in, they do not yet exist)."; static constexpr const char *InputType = "UBIGINT"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "262144"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 25; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct DefaultCollationSetting { @@ -428,7 +505,8 @@ struct DefaultCollationSetting { static constexpr const char *Description = "The collation setting used when none is specified"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = ""; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 26; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -438,7 +516,8 @@ struct DefaultNullOrderSetting { static constexpr const char *Description = "NULL ordering used when none is specified (NULLS_FIRST or NULLS_LAST)"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "NULLS_LAST"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 27; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -448,7 +527,8 @@ struct DefaultOrderSetting { static constexpr const char *Description = "The order type used when none is specified (ASC or DESC)"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "ASCENDING"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 28; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -469,11 +549,10 @@ struct DisableDatabaseInvalidationSetting { "Disables invalidating the database instance when encountering a fatal error. Should be used with great care, " "as DuckDB cannot guarantee correct behavior after a fatal error."; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 29; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct DisableTimestamptzCastsSetting { @@ -482,7 +561,8 @@ struct DisableTimestamptzCastsSetting { static constexpr const char *Description = "Disable casting from timestamp to timestamptz "; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 30; }; struct DisabledCompressionMethodsSetting { @@ -530,9 +610,10 @@ struct DuckDBAPISetting { static constexpr const char *Name = "duckdb_api"; static constexpr const char *Description = "DuckDB API surface"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 31; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct DynamicOrFilterThresholdSetting { @@ -542,7 +623,8 @@ struct DynamicOrFilterThresholdSetting { "The maximum amount of OR filters we generate dynamically from a hash join"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "50"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 32; }; struct EnableExternalAccessSetting { @@ -552,11 +634,10 @@ struct EnableExternalAccessSetting { "Allow the database to access external state (through e.g. loading/installing modules, COPY TO/FROM, CSV " "readers, pandas replacement scans, etc)"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "true"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 33; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct EnableExternalFileCacheSetting { @@ -564,9 +645,10 @@ struct EnableExternalFileCacheSetting { static constexpr const char *Name = "enable_external_file_cache"; static constexpr const char *Description = "Allow the database to cache external files (e.g., Parquet) in memory."; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "true"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 34; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct EnableFSSTVectorsSetting { @@ -576,7 +658,8 @@ struct EnableFSSTVectorsSetting { "Allow scans on FSST compressed segments to emit compressed vectors to utilize late decompression"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 35; }; struct EnableHTTPLoggingSetting { @@ -594,9 +677,9 @@ struct EnableHTTPMetadataCacheSetting { static constexpr const char *Name = "enable_http_metadata_cache"; static constexpr const char *Description = "Whether or not the global http metadata is used to cache HTTP metadata"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 36; }; struct EnableLogging { @@ -616,7 +699,8 @@ struct EnableMacroDependenciesSetting { "Enable created MACROs to create dependencies on the referenced objects (such as tables)"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 37; }; struct EnableObjectCacheSetting { @@ -625,7 +709,8 @@ struct EnableObjectCacheSetting { static constexpr const char *Description = "[PLACEHOLDER] Legacy setting - does nothing"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 38; }; struct EnableProfilingSetting { @@ -670,7 +755,8 @@ struct EnableViewDependenciesSetting { "Enable created VIEWs to create dependencies on the referenced objects (such as tables)"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 39; }; struct EnabledLogTypes { @@ -688,9 +774,9 @@ struct ErrorsAsJSONSetting { static constexpr const char *Name = "errors_as_json"; static constexpr const char *Description = "Output error messages as structured JSON instead of as a raw string"; static constexpr const char *InputType = "BOOLEAN"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 40; }; struct ExperimentalMetadataReuseSetting { @@ -699,7 +785,8 @@ struct ExperimentalMetadataReuseSetting { static constexpr const char *Description = "EXPERIMENTAL: Re-use row group and table metadata when checkpointing."; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "true"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 41; }; struct ExplainOutputSetting { @@ -707,9 +794,10 @@ struct ExplainOutputSetting { static constexpr const char *Name = "explain_output"; static constexpr const char *Description = "Output of EXPLAIN statements (ALL, OPTIMIZED_ONLY, PHYSICAL_ONLY)"; static constexpr const char *InputType = "VARCHAR"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "PHYSICAL_ONLY"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 42; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct ExtensionDirectoriesSetting { @@ -727,9 +815,9 @@ struct ExtensionDirectorySetting { static constexpr const char *Name = "extension_directory"; static constexpr const char *Description = "Set the directory to store extensions in"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 43; }; struct ExternalThreadsSetting { @@ -737,11 +825,10 @@ struct ExternalThreadsSetting { static constexpr const char *Name = "external_threads"; static constexpr const char *Description = "The number of external threads that work on DuckDB tasks."; static constexpr const char *InputType = "UBIGINT"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static bool OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input); - static bool OnGlobalReset(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "1"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 44; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct FileSearchPathSetting { @@ -749,29 +836,31 @@ struct FileSearchPathSetting { static constexpr const char *Name = "file_search_path"; static constexpr const char *Description = "A comma separated list of directories to search for input files"; static constexpr const char *InputType = "VARCHAR"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 45; }; struct ForceBitpackingModeSetting { - using RETURN_TYPE = string; + using RETURN_TYPE = BitpackingMode; static constexpr const char *Name = "force_bitpacking_mode"; static constexpr const char *Description = "DEBUG SETTING: forces a specific bitpacking mode"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "AUTO"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 46; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct ForceCompressionSetting { - using RETURN_TYPE = string; + using RETURN_TYPE = CompressionType; static constexpr const char *Name = "force_compression"; static constexpr const char *Description = "DEBUG SETTING: forces a specific compression method to be used"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "auto"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 47; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct ForceVariantShredding { @@ -785,14 +874,26 @@ struct ForceVariantShredding { static Value GetSetting(const ClientContext &context); }; +struct GeometryMinimumShreddingSize { + using RETURN_TYPE = int64_t; + static constexpr const char *Name = "geometry_minimum_shredding_size"; + static constexpr const char *Description = "Minimum size of a rowgroup to enable GEOMETRY shredding, or set to -1 " + "to disable entirely. Defaults to 1/4th of a rowgroup"; + static constexpr const char *InputType = "BIGINT"; + static constexpr const char *DefaultValue = "30000"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 48; +}; + struct HomeDirectorySetting { using RETURN_TYPE = string; static constexpr const char *Name = "home_directory"; static constexpr const char *Description = "Sets the home directory used by the system"; static constexpr const char *InputType = "VARCHAR"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 49; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct HTTPLoggingOutputSetting { @@ -811,9 +912,9 @@ struct HTTPProxySetting { static constexpr const char *Name = "http_proxy"; static constexpr const char *Description = "HTTP proxy host"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 50; }; struct HTTPProxyPasswordSetting { @@ -821,9 +922,9 @@ struct HTTPProxyPasswordSetting { static constexpr const char *Name = "http_proxy_password"; static constexpr const char *Description = "Password for HTTP proxy"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 51; }; struct HTTPProxyUsernameSetting { @@ -831,9 +932,9 @@ struct HTTPProxyUsernameSetting { static constexpr const char *Name = "http_proxy_username"; static constexpr const char *Description = "Username for HTTP proxy"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 52; }; struct IeeeFloatingPointOpsSetting { @@ -843,7 +944,8 @@ struct IeeeFloatingPointOpsSetting { "Use IEE754-compliant floating point operations (returning NAN instead of errors/NULL)."; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "true"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 53; }; struct ImmediateTransactionModeSetting { @@ -853,7 +955,8 @@ struct ImmediateTransactionModeSetting { "Whether transactions should be started lazily when needed, or immediately when BEGIN TRANSACTION is called"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 54; }; struct IndexScanMaxCountSetting { @@ -864,7 +967,8 @@ struct IndexScanMaxCountSetting { "index_scan_percentage * total_row_count) rows match, we perform an index scan instead of a table scan."; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "2048"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 55; }; struct IndexScanPercentageSetting { @@ -875,7 +979,8 @@ struct IndexScanPercentageSetting { "index_scan_percentage * total_row_count) rows match, we perform an index scan instead of a table scan."; static constexpr const char *InputType = "DOUBLE"; static constexpr const char *DefaultValue = "0.001"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 56; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -886,18 +991,20 @@ struct IntegerDivisionSetting { "Whether or not the / operator defaults to integer division, or to floating point division"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 57; }; struct LambdaSyntaxSetting { - using RETURN_TYPE = string; + using RETURN_TYPE = LambdaSyntax; static constexpr const char *Name = "lambda_syntax"; static constexpr const char *Description = "Configures the use of the deprecated single arrow operator (->) for lambda functions."; static constexpr const char *InputType = "VARCHAR"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "DEFAULT"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 58; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct LateMaterializationMaxRowsSetting { @@ -907,7 +1014,8 @@ struct LateMaterializationMaxRowsSetting { "The maximum amount of rows in the LIMIT/SAMPLE for which we trigger late materialization"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "50"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 59; }; struct LockConfigurationSetting { @@ -915,9 +1023,9 @@ struct LockConfigurationSetting { static constexpr const char *Name = "lock_configuration"; static constexpr const char *Description = "Whether or not the configuration can be altered"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 60; }; struct LogQueryPathSetting { @@ -926,9 +1034,10 @@ struct LogQueryPathSetting { static constexpr const char *Description = "Specifies the path to which queries should be logged (default: NULL, queries are not logged)"; static constexpr const char *InputType = "VARCHAR"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 61; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct LoggingLevel { @@ -968,9 +1077,9 @@ struct MaxExpressionDepthSetting { "The maximum expression depth limit in the parser. WARNING: increasing this setting and using very deep " "expressions might lead to stack overflow errors."; static constexpr const char *InputType = "UBIGINT"; - static void SetLocal(ClientContext &context, const Value ¶meter); - static void ResetLocal(ClientContext &context); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "1000"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 62; }; struct MaxMemorySetting { @@ -1000,7 +1109,8 @@ struct MaxVacuumTasksSetting { static constexpr const char *Description = "The maximum vacuum tasks to schedule during a checkpoint."; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "100"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 63; }; struct MergeJoinThresholdSetting { @@ -1009,7 +1119,8 @@ struct MergeJoinThresholdSetting { static constexpr const char *Description = "The maximum number of rows on either table to choose a merge join"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "1000"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 64; }; struct NestedLoopJoinThresholdSetting { @@ -1019,7 +1130,8 @@ struct NestedLoopJoinThresholdSetting { "The maximum number of rows on either table to choose a nested loop join"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "5"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 65; }; struct OldImplicitCastingSetting { @@ -1028,7 +1140,8 @@ struct OldImplicitCastingSetting { static constexpr const char *Description = "Allow implicit casting to/from VARCHAR"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 66; }; struct OrderByNonIntegerLiteralSetting { @@ -1038,7 +1151,8 @@ struct OrderByNonIntegerLiteralSetting { "Allow ordering by non-integer literals - ordering by such literals has no effect."; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 67; }; struct OrderedAggregateThresholdSetting { @@ -1047,7 +1161,8 @@ struct OrderedAggregateThresholdSetting { static constexpr const char *Description = "The number of rows to accumulate before sorting, used for tuning"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "262144"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 68; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -1058,7 +1173,8 @@ struct PartitionedWriteFlushThresholdSetting { "The threshold in number of rows after which we flush a thread state when writing using PARTITION_BY"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "524288"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 69; }; struct PartitionedWriteMaxOpenFilesSetting { @@ -1068,7 +1184,8 @@ struct PartitionedWriteMaxOpenFilesSetting { "The maximum amount of files the system can keep open before flushing to disk when writing using PARTITION_BY"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "100"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 70; }; struct PasswordSetting { @@ -1076,9 +1193,9 @@ struct PasswordSetting { static constexpr const char *Name = "password"; static constexpr const char *Description = "The password to use. Ignored for legacy compatibility."; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 71; }; struct PerfectHtThresholdSetting { @@ -1087,7 +1204,8 @@ struct PerfectHtThresholdSetting { static constexpr const char *Description = "Threshold in bytes for when to use a perfect hash table"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "12"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 72; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -1097,9 +1215,10 @@ struct PinThreadsSetting { static constexpr const char *Description = "Whether to pin threads to cores (Linux only, default AUTO: on when there are more than 64 cores)"; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "auto"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 73; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct PivotFilterThresholdSetting { @@ -1109,7 +1228,8 @@ struct PivotFilterThresholdSetting { "The threshold to switch from using filtered aggregates to LIST with a dedicated pivot operator"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "20"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 74; }; struct PivotLimitSetting { @@ -1118,7 +1238,8 @@ struct PivotLimitSetting { static constexpr const char *Description = "The maximum number of pivot columns in a pivot statement"; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "100000"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 75; }; struct PreferRangeJoinsSetting { @@ -1127,7 +1248,8 @@ struct PreferRangeJoinsSetting { static constexpr const char *Description = "Force use of range joins with mixed predicates"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 76; }; struct PreserveIdentifierCaseSetting { @@ -1137,7 +1259,8 @@ struct PreserveIdentifierCaseSetting { "Whether or not to preserve the identifier case, instead of always lowercasing all non-quoted identifiers"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "true"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 77; }; struct PreserveInsertionOrderSetting { @@ -1148,7 +1271,8 @@ struct PreserveInsertionOrderSetting { "that do not contain ORDER BY clauses."; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "true"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 78; }; struct ProduceArrowStringViewSetting { @@ -1158,7 +1282,8 @@ struct ProduceArrowStringViewSetting { "Whether Arrow strings should be produced by DuckDB in Utf8View format instead of Utf8"; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "false"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 79; }; struct ProfileOutputSetting { @@ -1210,7 +1335,8 @@ struct ScalarSubqueryErrorOnMultipleRowsSetting { "When a scalar subquery returns multiple rows - return a random row instead of returning an error."; static constexpr const char *InputType = "BOOLEAN"; static constexpr const char *DefaultValue = "true"; - static constexpr SetScope DefaultScope = SetScope::SESSION; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::LOCAL_DEFAULT; + static constexpr idx_t SettingIndex = 80; }; struct SchedulerProcessPartialSetting { @@ -1219,9 +1345,13 @@ struct SchedulerProcessPartialSetting { static constexpr const char *Description = "Partially process tasks before rescheduling - allows for more scheduler fairness between separate queries"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); +#ifdef DUCKDB_ALTERNATIVE_VERIFY + static constexpr const char *DefaultValue = "true"; +#else + static constexpr const char *DefaultValue = "false"; +#endif + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 81; }; struct SchemaSetting { @@ -1262,7 +1392,8 @@ struct StorageBlockPrefetchSetting { static constexpr const char *Description = "In which scenarios to use storage block prefetching"; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "REMOTE_ONLY"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 82; static void OnSet(SettingCallbackInfo &info, Value &input); }; @@ -1302,9 +1433,10 @@ struct TempFileEncryptionSetting { static constexpr const char *Name = "temp_file_encryption"; static constexpr const char *Description = "Encrypt all temporary files if database is encrypted"; static constexpr const char *InputType = "BOOLEAN"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "false"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 83; + static void OnSet(SettingCallbackInfo &info, Value &input); }; struct ThreadsSetting { @@ -1322,9 +1454,9 @@ struct UsernameSetting { static constexpr const char *Name = "username"; static constexpr const char *Description = "The username to use. Ignored for legacy compatibility."; static constexpr const char *InputType = "VARCHAR"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = ""; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 84; }; struct ValidateExternalFileCacheSetting { @@ -1335,19 +1467,20 @@ struct ValidateExternalFileCacheSetting { "remote cache entries), or NO_VALIDATION (disable cache validation)."; static constexpr const char *InputType = "VARCHAR"; static constexpr const char *DefaultValue = "VALIDATE_ALL"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 85; static void OnSet(SettingCallbackInfo &info, Value &input); }; -struct VariantMinimumShreddingSize { +struct VariantMinimumShreddingSizeSetting { using RETURN_TYPE = int64_t; static constexpr const char *Name = "variant_minimum_shredding_size"; static constexpr const char *Description = "Minimum size of a rowgroup to enable VARIANT shredding, or set to -1 " "to disable entirely. Defaults to 1/4th of a rowgroup"; static constexpr const char *InputType = "BIGINT"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "30000"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 86; }; struct WriteBufferRowGroupCountSetting { @@ -1357,7 +1490,8 @@ struct WriteBufferRowGroupCountSetting { "them together. Reducing this setting can reduce memory consumption."; static constexpr const char *InputType = "UBIGINT"; static constexpr const char *DefaultValue = "5"; - static constexpr SetScope DefaultScope = SetScope::GLOBAL; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_DEFAULT; + static constexpr idx_t SettingIndex = 87; }; struct ZstdMinStringLengthSetting { @@ -1366,9 +1500,13 @@ struct ZstdMinStringLengthSetting { static constexpr const char *Description = "The (average) length at which to enable ZSTD compression, defaults to 4096"; static constexpr const char *InputType = "UBIGINT"; - static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value ¶meter); - static void ResetGlobal(DatabaseInstance *db, DBConfig &config); - static Value GetSetting(const ClientContext &context); + static constexpr const char *DefaultValue = "4096"; + static constexpr SettingScopeTarget Scope = SettingScopeTarget::GLOBAL_ONLY; + static constexpr idx_t SettingIndex = 88; +}; + +struct GeneratedSettingInfo { + static constexpr idx_t MaxSettingIndex = 89; }; //===----------------------------------------------------------------------===// diff --git a/src/duckdb/src/include/duckdb/main/user_settings.hpp b/src/duckdb/src/include/duckdb/main/user_settings.hpp new file mode 100644 index 000000000..7354805df --- /dev/null +++ b/src/duckdb/src/include/duckdb/main/user_settings.hpp @@ -0,0 +1,88 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/main/user_settings.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/common.hpp" +#include "duckdb/common/mutex.hpp" +#include "duckdb/common/types/value.hpp" +#include "duckdb/main/setting_info.hpp" +#include "duckdb/common/atomic.hpp" + +namespace duckdb { + +struct GenericSetting { + GenericSetting() : is_set(false) { + } + + bool is_set; + Value value; +}; + +struct UserSettingsMap { +public: + void SetUserSetting(idx_t setting_index, Value target_value); + void ClearSetting(idx_t setting_index); + bool IsSet(idx_t setting_index) const; + bool TryGetSetting(idx_t setting_index, Value &result_value) const; + +private: + vector settings; +}; + +struct CachedGlobalSettings { + CachedGlobalSettings(idx_t version, UserSettingsMap settings); + + idx_t version; + UserSettingsMap settings; +}; + +struct GlobalUserSettings { +public: + GlobalUserSettings(); + // enable copy constructors + GlobalUserSettings(const GlobalUserSettings &other); + GlobalUserSettings &operator=(const GlobalUserSettings &); + + void SetUserSetting(idx_t setting_index, Value target_value); + void ClearSetting(idx_t setting_index); + bool IsSet(idx_t setting_index) const; + SettingLookupResult TryGetSetting(idx_t setting_index, Value &result_value) const; + bool HasExtensionOption(const string &name) const; + idx_t AddExtensionOption(const string &name, ExtensionOption extension_option); + case_insensitive_map_t GetExtensionSettings() const; + bool TryGetExtensionOption(const String &name, ExtensionOption &result) const; + shared_ptr GetSettings(shared_ptr &cache) const; + +private: + mutable mutex lock; + //! Database-global settings + UserSettingsMap settings_map; + //! Extra parameters that can be SET for loaded extensions + case_insensitive_map_t extension_parameters; + //! Current version of the settings - incremented when settings are modified + atomic settings_version; +}; + +struct LocalUserSettings { +public: + ~LocalUserSettings(); + + void SetUserSetting(idx_t setting_index, Value target_value); + void ClearSetting(idx_t setting_index); + bool IsSet(idx_t setting_index) const; + SettingLookupResult TryGetSetting(const GlobalUserSettings &global_settings, idx_t setting_index, + Value &result_value) const; + +private: + //! Client-local settings + UserSettingsMap settings_map; + //! Cache of global settings - used to allow lock-free access to global settings in a thread-safe manner + mutable shared_ptr global_settings_cache; +}; +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp b/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp index 49bb11e5b..0ae354854 100644 --- a/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/expression_heuristics.hpp @@ -46,6 +46,6 @@ class ExpressionHeuristics : public LogicalOperatorVisitor { static idx_t ExpressionCost(BoundFunctionExpression &expr); static idx_t ExpressionCost(BoundOperatorExpression &expr, ExpressionType expr_type); static idx_t ExpressionCost(PhysicalType return_type, idx_t multiplier); - static idx_t Cost(TableFilter &filter); + static idx_t Cost(const TableFilter &filter); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp b/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp index 060274b36..b6a34facc 100644 --- a/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/join_order/relation_statistics_helper.hpp @@ -57,7 +57,7 @@ class RelationStatisticsHelper { static constexpr double DEFAULT_SELECTIVITY = 0.2; public: - static idx_t InspectTableFilter(idx_t cardinality, idx_t column_index, TableFilter &filter, + static idx_t InspectTableFilter(idx_t cardinality, idx_t column_index, const TableFilter &filter, BaseStatistics &base_stats); // static idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter &filter, // BaseStatistics &base_stats); diff --git a/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp b/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp index d2202fcb1..4ea4b323d 100644 --- a/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/optimizer_extension.hpp @@ -10,9 +10,10 @@ #include "duckdb/common/common.hpp" #include "duckdb/planner/logical_operator.hpp" +#include "duckdb/main/extension_callback_manager.hpp" namespace duckdb { - +struct DBConfig; class Optimizer; class ClientContext; @@ -44,6 +45,11 @@ class OptimizerExtension { //! Additional optimizer info passed to the optimize functions shared_ptr optimizer_info; + + static void Register(DBConfig &config, OptimizerExtension extension); + static ExtensionCallbackIteratorHelper Iterate(ClientContext &context) { + return ExtensionCallbackManager::Get(context).OptimizerExtensions(); + } }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp b/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp index 4d02f224c..a4fad42ac 100644 --- a/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/remove_unused_columns.hpp @@ -89,13 +89,16 @@ class BaseColumnPruner : public LogicalOperatorVisitor { //! ret: The amount of bindings created idx_t ReplaceBinding(ColumnBinding current_binding, ColumnBinding new_binding); - bool HandleStructExtract(unique_ptr *expression, - optional_ptr> cast_expression = nullptr); - - bool HandleStructExtractRecursive(unique_ptr &expr, optional_ptr &colref, - vector &indexes, vector &expressions); + bool HandleExtractExpression(unique_ptr *expression, + optional_ptr> cast_expression = nullptr); + + bool HandleStructExtract(unique_ptr &expr, optional_ptr &colref, + reference &path_ref, vector &expressions); + bool HandleVariantExtract(unique_ptr &expr, optional_ptr &colref, + reference &path_ref, vector &expressions); + bool HandleExtractRecursive(unique_ptr &expr, optional_ptr &colref, + reference &path_ref, vector &expressions); void SetMode(BaseColumnPrunerMode mode); - bool HandleStructPack(Expression &expr); BaseColumnPrunerMode GetMode() const; private: @@ -134,6 +137,6 @@ class RemoveUnusedColumns : public BaseColumnPruner { void RewriteExpressions(LogicalProjection &proj, idx_t expression_count); void WritePushdownExtractColumns( const ColumnBinding &binding, ReferencedColumn &col, idx_t original_idx, const LogicalType &column_type, - const std::function cast_type)> &callback); + const std::function cast_type)> &callback); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp b/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp index 1ec4acaa9..08340b0a5 100644 --- a/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/statistics_propagator.hpp @@ -81,7 +81,7 @@ class StatisticsPropagator { //! Run a comparison between the statistics and the table filter; returns the prune result FilterPropagateResult PropagateTableFilter(ColumnBinding stats_binding, BaseStatistics &stats, TableFilter &filter); //! Update filter statistics from a TableFilter - void UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter); + void UpdateFilterStatistics(BaseStatistics &input, const TableFilter &filter); //! Add cardinalities together (i.e. new max is stats.max + new_stats.max): used for union void AddCardinalities(unique_ptr &stats, NodeStatistics &new_stats); diff --git a/src/duckdb/src/include/duckdb/optimizer/topn_window_elimination.hpp b/src/duckdb/src/include/duckdb/optimizer/topn_window_elimination.hpp index 0fb5ba00c..2a52f432b 100644 --- a/src/duckdb/src/include/duckdb/optimizer/topn_window_elimination.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/topn_window_elimination.hpp @@ -11,6 +11,7 @@ #include "duckdb/main/client_context.hpp" #include "duckdb/optimizer/column_binding_replacer.hpp" #include "duckdb/optimizer/remove_unused_columns.hpp" +#include "duckdb/optimizer/optimizer.hpp" namespace duckdb { diff --git a/src/duckdb/src/include/duckdb/optimizer/window_self_join.hpp b/src/duckdb/src/include/duckdb/optimizer/window_self_join.hpp index dc9c0a300..bac7e9976 100644 --- a/src/duckdb/src/include/duckdb/optimizer/window_self_join.hpp +++ b/src/duckdb/src/include/duckdb/optimizer/window_self_join.hpp @@ -21,6 +21,7 @@ class WindowSelfJoinOptimizer { unique_ptr Optimize(unique_ptr op); private: + bool CanOptimize(const BoundWindowExpression &w_expr, const BoundWindowExpression &w_expr0) const; unique_ptr OptimizeInternal(unique_ptr op, ColumnBindingReplacer &replacer); Optimizer &optimizer; diff --git a/src/duckdb/src/include/duckdb/parallel/pipeline.hpp b/src/duckdb/src/include/duckdb/parallel/pipeline.hpp index 45e603467..0d8a665a5 100644 --- a/src/duckdb/src/include/duckdb/parallel/pipeline.hpp +++ b/src/duckdb/src/include/duckdb/parallel/pipeline.hpp @@ -86,6 +86,7 @@ class Pipeline : public enable_shared_from_this { ClientContext &GetClientContext(); void AddDependency(shared_ptr &pipeline); + vector> GetDependencies() const; void Ready(); void Reset(); diff --git a/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp index 276edf418..08c02f835 100644 --- a/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp +++ b/src/duckdb/src/include/duckdb/parser/expression/lambda_expression.hpp @@ -11,10 +11,10 @@ #include "duckdb/common/unordered_set.hpp" #include "duckdb/common/vector.hpp" #include "duckdb/parser/parsed_expression.hpp" +#include "duckdb/common/enums/lambda_syntax.hpp" namespace duckdb { -enum class LambdaSyntax : uint8_t { DEFAULT = 0, ENABLE_SINGLE_ARROW = 1, DISABLE_SINGLE_ARROW = 2 }; enum class LambdaSyntaxType : uint8_t { SINGLE_ARROW_STORAGE = 0, SINGLE_ARROW = 1, LAMBDA_KEYWORD = 2 }; //! DuckDB 1.3. introduced a new lambda syntax: lambda x, y: x + y. diff --git a/src/duckdb/src/include/duckdb/parser/expression/list.hpp b/src/duckdb/src/include/duckdb/parser/expression/list.hpp index 0114a55a2..c6d84ec4b 100644 --- a/src/duckdb/src/include/duckdb/parser/expression/list.hpp +++ b/src/duckdb/src/include/duckdb/parser/expression/list.hpp @@ -17,3 +17,4 @@ #include "duckdb/parser/expression/star_expression.hpp" #include "duckdb/parser/expression/subquery_expression.hpp" #include "duckdb/parser/expression/window_expression.hpp" +#include "duckdb/parser/expression/type_expression.hpp" diff --git a/src/duckdb/src/include/duckdb/parser/expression/type_expression.hpp b/src/duckdb/src/include/duckdb/parser/expression/type_expression.hpp new file mode 100644 index 000000000..e26e2fc4e --- /dev/null +++ b/src/duckdb/src/include/duckdb/parser/expression/type_expression.hpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/parser/expression/type_expression.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/vector.hpp" +#include "duckdb/parser/parsed_expression.hpp" +#include "duckdb/parser/keyword_helper.hpp" + +namespace duckdb { + +class TypeExpression : public ParsedExpression { +public: + static constexpr const ExpressionClass TYPE = ExpressionClass::TYPE; + + TypeExpression(string catalog, string schema, string type_name, vector> children); + TypeExpression(string type_name, vector> children); + +public: + const string &GetTypeName() const { + return type_name; + } + const string &GetSchema() const { + return schema; + } + const string &GetCatalog() const { + return catalog; + } + const vector> &GetChildren() const { + return children; + } + vector> &GetChildren() { + return children; + } + +public: + string ToString() const override; + + unique_ptr Copy() const override; + + static bool Equal(const TypeExpression &a, const TypeExpression &b); + hash_t Hash() const override; + + void Serialize(Serializer &serializer) const override; + static unique_ptr Deserialize(Deserializer &deserializer); + + void Verify() const override; + +private: + TypeExpression(); + + //! Qualified name parts + string catalog; + string schema; + string type_name; + + //! Children of the type expression (e.g. type parameters) + vector> children; +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp b/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp index d53951105..5a621321b 100644 --- a/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp +++ b/src/duckdb/src/include/duckdb/parser/keyword_helper.hpp @@ -16,20 +16,22 @@ namespace duckdb { class KeywordHelper { public: //! Returns true if the given text matches a keyword of the parser - static bool IsKeyword(const string &text); + static bool IsKeyword(const string &text, KeywordCategory category = KeywordCategory::KEYWORD_NONE); static KeywordCategory KeywordCategoryType(const string &text); static string EscapeQuotes(const string &text, char quote = '"'); //! Returns true if the given string needs to be quoted when written as an identifier - static bool RequiresQuotes(const string &text, bool allow_caps = true); + static bool RequiresQuotes(const string &text, bool allow_caps = true, + KeywordCategory category = KeywordCategory::KEYWORD_NONE); //! Writes a string that is quoted static string WriteQuoted(const string &text, char quote = '\''); //! Writes a string that is optionally quoted + escaped so it can be used as an identifier - static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true); + static string WriteOptionallyQuoted(const string &text, char quote = '"', bool allow_caps = true, + KeywordCategory category = KeywordCategory::KEYWORD_NONE); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp index 1408d6e28..0730f7642 100644 --- a/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp +++ b/src/duckdb/src/include/duckdb/parser/parsed_data/alter_table_info.hpp @@ -84,7 +84,9 @@ enum class AlterTableType : uint8_t { SET_SORTED_BY = 13, ADD_FIELD = 14, REMOVE_FIELD = 15, - RENAME_FIELD = 16 + RENAME_FIELD = 16, + SET_TABLE_OPTIONS = 17, + RESET_TABLE_OPTIONS = 18, }; struct AlterTableInfo : public AlterInfo { @@ -493,4 +495,44 @@ struct SetSortedByInfo : public AlterTableInfo { SetSortedByInfo(); }; +//===--------------------------------------------------------------------===// +// SetOptionsInfo +//===--------------------------------------------------------------------===// +struct SetTableOptionsInfo : public AlterTableInfo { + SetTableOptionsInfo(AlterEntryData data, case_insensitive_map_t> table_options); + ~SetTableOptionsInfo() override; + + case_insensitive_map_t> table_options; + +public: + unique_ptr Copy() const override; + string ToString() const override; + + void Serialize(Serializer &serializer) const override; + static unique_ptr Deserialize(Deserializer &deserializer); + +private: + SetTableOptionsInfo(); +}; + +//===--------------------------------------------------------------------===// +// ResetOptionsInfo +//===--------------------------------------------------------------------===// +struct ResetTableOptionsInfo : public AlterTableInfo { + ResetTableOptionsInfo(AlterEntryData data, case_insensitive_set_t table_options); + ~ResetTableOptionsInfo() override; + + case_insensitive_set_t table_options; + +public: + unique_ptr Copy() const override; + string ToString() const override; + + void Serialize(Serializer &serializer) const override; + static unique_ptr Deserialize(Deserializer &deserializer); + +private: + ResetTableOptionsInfo(); +}; + } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp index 84423dc59..6004d428f 100644 --- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp +++ b/src/duckdb/src/include/duckdb/parser/parsed_data/create_table_info.hpp @@ -29,6 +29,12 @@ struct CreateTableInfo : public CreateInfo { vector> constraints; //! CREATE TABLE as QUERY unique_ptr query; + //! Table Partition definitions + vector> partition_keys; + //! Table Sort definitions + vector> sort_keys; + //! Extra Table options if any + case_insensitive_map_t> options; public: DUCKDB_API unique_ptr Copy() const override; diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp index 2c4eb983f..8d25b626a 100644 --- a/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp +++ b/src/duckdb/src/include/duckdb/parser/parsed_data/create_type_info.hpp @@ -13,14 +13,42 @@ namespace duckdb { +class TypeArgument { +public: + TypeArgument(string name_p, Value value_p) : name(std::move(name_p)), value(std::move(value_p)) { + } + const string &GetName() const { + return name; + } + const Value &GetValue() const { + return value; + } + bool HasName() const { + return !name.empty(); + } + bool IsNamed(const char *name_to_check) const { + return StringUtil::CIEquals(name, name_to_check); + } + bool IsNotNull() const { + return !value.IsNull(); + } + const LogicalType &GetType() const { + return value.type(); + } + +private: + string name; + Value value; +}; + struct BindLogicalTypeInput { - ClientContext &context; + optional_ptr context; const LogicalType &base_type; - const vector &modifiers; + const vector &modifiers; }; //! The type to bind type modifiers to a type -typedef LogicalType (*bind_logical_type_function_t)(const BindLogicalTypeInput &input); +typedef LogicalType (*bind_logical_type_function_t)(BindLogicalTypeInput &input); struct CreateTypeInfo : public CreateInfo { CreateTypeInfo(); diff --git a/src/duckdb/src/include/duckdb/parser/parser_extension.hpp b/src/duckdb/src/include/duckdb/parser/parser_extension.hpp index cf264adc7..b97349a74 100644 --- a/src/duckdb/src/include/duckdb/parser/parser_extension.hpp +++ b/src/duckdb/src/include/duckdb/parser/parser_extension.hpp @@ -14,6 +14,7 @@ #include "duckdb/parser/sql_statement.hpp" namespace duckdb { +struct DBConfig; //! The ParserExtensionInfo holds static information relevant to the parser extension //! It is made available in the parse_function, and will be kept alive as long as the database system is kept alive @@ -114,6 +115,8 @@ class ParserExtension { //! Additional parser info passed to the parse function shared_ptr parser_info; + + static void Register(DBConfig &config, ParserExtension extension); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/parser/parser_options.hpp b/src/duckdb/src/include/duckdb/parser/parser_options.hpp index d9a42632a..2d8227aca 100644 --- a/src/duckdb/src/include/duckdb/parser/parser_options.hpp +++ b/src/duckdb/src/include/duckdb/parser/parser_options.hpp @@ -9,16 +9,19 @@ #pragma once #include "duckdb/common/common.hpp" +#include "duckdb/common/enums/allow_parser_override.hpp" +#include "duckdb/common/optional_ptr.hpp" namespace duckdb { +class ExtensionCallbackManager; class ParserExtension; struct ParserOptions { bool preserve_identifier_case = true; bool integer_division = false; idx_t max_expression_depth = 1000; - const vector *extensions = nullptr; - string parser_override_setting = "default"; + optional_ptr extensions; + AllowParserOverride parser_override_setting = AllowParserOverride::DEFAULT_OVERRIDE; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/parser/query_node.hpp b/src/duckdb/src/include/duckdb/parser/query_node.hpp index 4981e8afc..98f085523 100644 --- a/src/duckdb/src/include/duckdb/parser/query_node.hpp +++ b/src/duckdb/src/include/duckdb/parser/query_node.hpp @@ -41,7 +41,6 @@ class CommonTableExpressionMap { CommonTableExpressionMap Copy() const; void Serialize(Serializer &serializer) const; - // static void Deserialize(Deserializer &deserializer, CommonTableExpressionMap &ret); static CommonTableExpressionMap Deserialize(Deserializer &deserializer); }; diff --git a/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp index 7d0bd86e1..a38bd422b 100644 --- a/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp +++ b/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp @@ -14,7 +14,9 @@ #include "duckdb/common/vector.hpp" namespace duckdb { -//! Represents an expression list as generated by a VALUES statement + +//! A table reference that consists of a list of expressions. +//! The expression list is generated by, e.g., a VALUES statement. class ExpressionListRef : public TableRef { public: static constexpr const TableReferenceType TYPE = TableReferenceType::EXPRESSION_LIST; @@ -23,11 +25,11 @@ class ExpressionListRef : public TableRef { ExpressionListRef() : TableRef(TableReferenceType::EXPRESSION_LIST) { } - //! Value list, only used for VALUES statement + //! Value list like in a VALUES statement. vector>> values; - //! Expected SQL types + //! Expected table types. vector expected_types; - //! The set of expected names + //! Expected table names. vector expected_names; public: diff --git a/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp b/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp index 163bf66ad..78a1e1266 100644 --- a/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp +++ b/src/duckdb/src/include/duckdb/parser/tableref/showref.hpp @@ -14,7 +14,7 @@ namespace duckdb { -enum class ShowType : uint8_t { SUMMARY, DESCRIBE, SHOW_FROM }; +enum class ShowType : uint8_t { SUMMARY, DESCRIBE, SHOW_FROM, SHOW_UNQUALIFIED }; //! Represents a SHOW/DESCRIBE/SUMMARIZE statement class ShowRef : public TableRef { diff --git a/src/duckdb/src/include/duckdb/parser/transformer.hpp b/src/duckdb/src/include/duckdb/parser/transformer.hpp index 8a8ba2ecb..460755566 100644 --- a/src/duckdb/src/include/duckdb/parser/transformer.hpp +++ b/src/duckdb/src/include/duckdb/parser/transformer.hpp @@ -156,6 +156,8 @@ class Transformer { unique_ptr TransformCopy(duckdb_libpgquery::PGCopyStmt &stmt); void TransformCopyOptions(CopyInfo &info, optional_ptr options); void TransformCreateSecretOptions(CreateSecretInfo &info, optional_ptr options); + void TransformTableOptions(case_insensitive_map_t> &info, + optional_ptr options, bool throw_if_value = false); //! Transform a Postgres duckdb_libpgquery::T_PGTransactionStmt node into a TransactionStatement unique_ptr TransformTransaction(duckdb_libpgquery::PGTransactionStmt &stmt); //! Transform a Postgres T_DeleteStatement node into a DeleteStatement @@ -191,8 +193,6 @@ class Transformer { unique_ptr CreatePivotStatement(unique_ptr statement); PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot); vector TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot); - static bool TransformPivotInList(unique_ptr &expr, PivotColumnEntry &entry, - bool root_entry = true); unique_ptr TransformMergeInto(duckdb_libpgquery::PGMergeIntoStmt &stmt); unique_ptr TransformMergeIntoAction(duckdb_libpgquery::PGMatchAction &action); @@ -308,7 +308,6 @@ class Transformer { unique_ptr TransformUnaryOperator(const string &op, unique_ptr child); unique_ptr TransformBinaryOperator(string op, unique_ptr left, unique_ptr right); - static bool ConstructConstantFromExpression(const ParsedExpression &expr, Value &value); //===--------------------------------------------------------------------===// // TableRef transform //===--------------------------------------------------------------------===// @@ -336,13 +335,11 @@ class Transformer { QualifiedName TransformQualifiedName(duckdb_libpgquery::PGRangeVar &root); //! Transform a Postgres TypeName string into a LogicalType (non-LIST types) - LogicalType TransformTypeNameInternal(duckdb_libpgquery::PGTypeName &name); + unique_ptr TransformTypeExpressionInternal(duckdb_libpgquery::PGTypeName &name); + unique_ptr TransformTypeExpression(duckdb_libpgquery::PGTypeName &name); //! Transform a Postgres TypeName string into a LogicalType LogicalType TransformTypeName(duckdb_libpgquery::PGTypeName &name); - //! Transform a list of type modifiers into a list of values - vector TransformTypeModifiers(duckdb_libpgquery::PGTypeName &name); - //! Transform a Postgres GROUP BY expression into a list of Expression bool TransformGroupBy(optional_ptr group, SelectNode &result); void TransformGroupByNode(duckdb_libpgquery::PGNode &n, GroupingExpressionMap &map, SelectNode &result, diff --git a/src/duckdb/src/include/duckdb/planner/binder.hpp b/src/duckdb/src/include/duckdb/planner/binder.hpp index 523ba484a..3f9ac2e77 100644 --- a/src/duckdb/src/include/duckdb/planner/binder.hpp +++ b/src/duckdb/src/include/duckdb/planner/binder.hpp @@ -288,8 +288,8 @@ class Binder : public enable_shared_from_this { void BindVacuumTable(LogicalVacuum &vacuum, unique_ptr &root); static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema); - void BindLogicalType(LogicalType &type, optional_ptr catalog = nullptr, - const string &schema = INVALID_SCHEMA); + + void BindLogicalType(LogicalType &type); optional_ptr GetMatchingBinding(const string &table_name, const string &column_name, ErrorData &error); optional_ptr GetMatchingBinding(const string &schema_name, const string &table_name, @@ -321,6 +321,8 @@ class Binder : public enable_shared_from_this { unique_ptr UnionOperators(vector> nodes); + void SetSearchPath(Catalog &catalog, const string &schema); + private: //! The parent binder (if any) shared_ptr parent; @@ -505,7 +507,7 @@ class Binder : public enable_shared_from_this { vector GetSearchPath(Catalog &catalog, const string &schema_name); - LogicalType BindLogicalTypeInternal(const LogicalType &type, optional_ptr catalog, const string &schema); + LogicalType BindLogicalTypeInternal(const unique_ptr &type_expr); BoundStatement BindSelectNode(SelectNode &statement, BoundStatement from_table); diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder.hpp index 3232c4d99..40cabe202 100644 --- a/src/duckdb/src/include/duckdb/planner/expression_binder.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression_binder.hpp @@ -14,6 +14,7 @@ #include "duckdb/common/exception/binder_exception.hpp" #include "duckdb/parser/expression/bound_expression.hpp" #include "duckdb/parser/expression/lambdaref_expression.hpp" +#include "duckdb/parser/expression/type_expression.hpp" #include "duckdb/parser/parsed_expression.hpp" #include "duckdb/parser/tokens.hpp" #include "duckdb/planner/expression.hpp" @@ -180,6 +181,7 @@ class ExpressionBinder { BindResult BindExpression(ConjunctionExpression &expr, idx_t depth); BindResult BindExpression(ConstantExpression &expr, idx_t depth); BindResult BindExpression(FunctionExpression &expr, idx_t depth, unique_ptr &expr_ptr); + BindResult BindExpression(TypeExpression &expr, idx_t depth); BindResult BindExpression(LambdaExpression &expr, idx_t depth, const vector &function_child_types, optional_ptr bind_lambda_function); diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp index b111cc368..02c70229a 100644 --- a/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp @@ -27,6 +27,8 @@ class HavingBinder : public BaseSelectBinder { unique_ptr QualifyColumnName(ColumnRefExpression &col_ref, ErrorData &error) override; + bool DoesColumnAliasExist(const ColumnRefExpression &colref) override; + private: ColumnAliasBinder column_alias_binder; AggregateHandling aggregate_handling; diff --git a/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp b/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp index cc20dd5ed..a86c2ed45 100644 --- a/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp +++ b/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp @@ -18,6 +18,14 @@ class TableFunctionBinder : public ExpressionBinder { TableFunctionBinder(Binder &binder, ClientContext &context, string table_function_name = string(), string clause = "Table function"); +public: + void DisableSQLValueFunctions() { + accept_sql_value_functions = false; + } + void EnableSQLValueFunctions() { + accept_sql_value_functions = true; + } + protected: BindResult BindLambdaReference(LambdaRefExpression &expr, idx_t depth); BindResult BindColumnReference(unique_ptr &expr, idx_t depth, bool root_expression); @@ -28,6 +36,8 @@ class TableFunctionBinder : public ExpressionBinder { private: string table_function_name; string clause; + //! Whether sql_value_functions (GetSQLValueFunctionName) are considered when binding column refs + bool accept_sql_value_functions = true; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/planner/extension_callback.hpp b/src/duckdb/src/include/duckdb/planner/extension_callback.hpp index 389f8f257..d457019bf 100644 --- a/src/duckdb/src/include/duckdb/planner/extension_callback.hpp +++ b/src/duckdb/src/include/duckdb/planner/extension_callback.hpp @@ -9,8 +9,10 @@ #pragma once #include "duckdb/common/common.hpp" +#include "duckdb/main/extension_callback_manager.hpp" namespace duckdb { +struct DBConfig; class ClientContext; class DatabaseInstance; class ErrorData; @@ -35,6 +37,14 @@ class ExtensionCallback { //! Called after an extension fails to load loading virtual void OnExtensionLoadFail(DatabaseInstance &db, const string &name, const ErrorData &error) { } + + static void Register(DBConfig &config, shared_ptr extension); + static ExtensionCallbackIteratorHelper> Iterate(ClientContext &context) { + return ExtensionCallbackManager::Get(context).ExtensionCallbacks(); + } + static ExtensionCallbackIteratorHelper> Iterate(DatabaseInstance &db) { + return ExtensionCallbackManager::Get(db).ExtensionCallbacks(); + } }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/planner/operator_extension.hpp b/src/duckdb/src/include/duckdb/planner/operator_extension.hpp index b14b640d1..35668580b 100644 --- a/src/duckdb/src/include/duckdb/planner/operator_extension.hpp +++ b/src/duckdb/src/include/duckdb/planner/operator_extension.hpp @@ -11,9 +11,12 @@ #include "duckdb/common/common.hpp" #include "duckdb/execution/physical_plan_generator.hpp" #include "duckdb/planner/binder.hpp" +#include "duckdb/main/extension_callback_manager.hpp" namespace duckdb { +struct DBConfig; + //! The OperatorExtensionInfo holds static information relevant to the operator extension struct OperatorExtensionInfo { virtual ~OperatorExtensionInfo() { @@ -38,6 +41,11 @@ class OperatorExtension { virtual ~OperatorExtension() { } + + static void Register(DBConfig &config, shared_ptr extension); + static ExtensionCallbackIteratorHelper> Iterate(ClientContext &context) { + return ExtensionCallbackManager::Get(context).OperatorExtensions(); + } }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/block_manager.hpp b/src/duckdb/src/include/duckdb/storage/block_manager.hpp index 695b6aed9..3f52205e3 100644 --- a/src/duckdb/src/include/duckdb/storage/block_manager.hpp +++ b/src/duckdb/src/include/duckdb/storage/block_manager.hpp @@ -120,8 +120,9 @@ class BlockManager { //! Returns a reference to the metadata manager of this block manager. MetadataManager &GetMetadataManager(); + //! Returns the block allocation size of this block manager. - inline idx_t GetBlockAllocSize() const { + idx_t GetBlockAllocSize() const { return block_alloc_size.GetIndex(); } //! Returns the possibly invalid block allocation size of this block manager. @@ -132,15 +133,15 @@ class BlockManager { inline optional_idx GetOptionalBlockHeaderSize() const { return block_header_size; } - //! Block header size including the 8-byte checksum - inline idx_t GetBlockHeaderSize() const { + //! Returns the block header size including the 8-byte checksum of this block manager. + idx_t GetBlockHeaderSize() const { if (!block_header_size.IsValid()) { return Storage::DEFAULT_BLOCK_HEADER_SIZE; } return block_header_size.GetIndex(); } - //! Size of the block available for the user - inline idx_t GetBlockSize() const { + //! Returns the size of the block that is available for usage. + idx_t GetBlockSize() const { return block_alloc_size.GetIndex() - block_header_size.GetIndex(); } //! Sets the block allocation size. This should only happen when initializing an existing database. @@ -194,9 +195,9 @@ class BlockManager { //! for in-memory block managers. Default to default_block_alloc_size for file-backed block managers. //! This is NOT the actual memory available on a block (block_size). optional_idx block_alloc_size; - //! The size of the block headers (incl. checksum) in this block manager. + //! The size of the block headers (including checksum) in this block manager. //! Defaults to DEFAULT_BLOCK_HEADER_SIZE for in-memory block managers. - //! Default to default_block_header_size for file-backed block managers. + //! Defaults to default_block_header_size for file-backed block managers. optional_idx block_header_size; }; diff --git a/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp b/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp index b4095853b..00a6a1006 100644 --- a/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp +++ b/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp @@ -13,57 +13,36 @@ #include "duckdb/common/enums/memory_tag.hpp" #include "duckdb/common/file_buffer.hpp" #include "duckdb/common/mutex.hpp" +#include "duckdb/common/numeric_utils.hpp" +#include "duckdb/common/optional_idx.hpp" +#include "duckdb/storage/buffer/buffer_pool_reservation.hpp" #include "duckdb/storage/storage_info.hpp" namespace duckdb { +// Forward declaration. class BlockManager; class BufferHandle; -class BufferPool; +class BufferManager; class DatabaseInstance; -enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 }; - -struct BufferPoolReservation { - MemoryTag tag; - idx_t size {0}; - BufferPool &pool; - - BufferPoolReservation(MemoryTag tag, BufferPool &pool); - BufferPoolReservation(const BufferPoolReservation &) = delete; - BufferPoolReservation &operator=(const BufferPoolReservation &) = delete; - - BufferPoolReservation(BufferPoolReservation &&) noexcept; - BufferPoolReservation &operator=(BufferPoolReservation &&) noexcept; - - ~BufferPoolReservation(); - - void Resize(idx_t new_size); - void Merge(BufferPoolReservation src); -}; - -struct TempBufferPoolReservation : BufferPoolReservation { - TempBufferPoolReservation(MemoryTag tag, BufferPool &pool, idx_t size) : BufferPoolReservation(tag, pool) { - Resize(size); - } - TempBufferPoolReservation(TempBufferPoolReservation &&) = default; - ~TempBufferPoolReservation() { - Resize(0); - } -}; - using BlockLock = unique_lock; class BlockHandle : public enable_shared_from_this { public: BlockHandle(BlockManager &block_manager, block_id_t block_id, MemoryTag tag); BlockHandle(BlockManager &block_manager, block_id_t block_id, MemoryTag tag, unique_ptr buffer, - DestroyBufferUpon destroy_buffer_upon, idx_t block_size, BufferPoolReservation &&reservation); + DestroyBufferUpon destroy_buffer_upon, idx_t size, BufferPoolReservation &&reservation); ~BlockHandle(); - BlockManager &block_manager; - public: + BufferManager &GetBufferManager() const { + return buffer_manager; + } + BlockManager &GetBlockManager() const { + return block_manager; + } + block_id_t BlockId() const { return block_id; } @@ -107,10 +86,25 @@ class BlockHandle : public enable_shared_from_this { return destroy_buffer_upon == DestroyBufferUpon::BLOCK; } - inline idx_t GetMemoryUsage() const { + idx_t GetMemoryUsage() const { return memory_usage; } + //! Returns the block allocation size of this block. + idx_t GetBlockAllocSize() const { + return block_alloc_size; + } + //! Returns the block header size including the 8-byte checksum. + idx_t GetBlockHeaderSize() const { + return block_header_size; + } + //! Returns the size of the block that is available for usage, as determined by the block manager that created the + //! block. The block_alloc_size can differ from the memory_usage for blocks managed by the temporary block manager, + //! thus, this should only be called for persistent blocks. + idx_t GetBlockSize() const { + return block_alloc_size - block_header_size; + } + bool IsUnloaded() const { return state == BlockState::BLOCK_UNLOADED; } @@ -178,6 +172,16 @@ class BlockHandle : public enable_shared_from_this { void VerifyMutex(unique_lock &l) const; private: + BufferManager &buffer_manager; + BlockManager &block_manager; + //! The block allocation size, which is determined by the block manager creating the block. + //! For non-temporary block managers the block_alloc_size corresponds to the memory_usage. + //! If we are pinning/loading an unloaded block, then we know how much memory to reserve. + //! This is NOT the actual memory available on a block. + idx_t block_alloc_size; + //! The size of the block header, including the checksum. + idx_t block_header_size; + //! The block-level lock mutex lock; //! Whether or not the block is loaded/unloaded diff --git a/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp b/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp index a77b34ef7..0f668bd90 100644 --- a/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp +++ b/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool.hpp @@ -10,14 +10,17 @@ #include "duckdb/common/array.hpp" #include "duckdb/common/enums/memory_tag.hpp" +#include "duckdb/common/exception.hpp" #include "duckdb/common/file_buffer.hpp" #include "duckdb/common/mutex.hpp" +#include "duckdb/common/optional_ptr.hpp" #include "duckdb/common/typedefs.hpp" #include "duckdb/storage/buffer/block_handle.hpp" namespace duckdb { class TemporaryMemoryManager; +class ObjectCache; struct EvictionQueue; struct BufferEvictionNode { @@ -63,6 +66,15 @@ class BufferPool { TemporaryMemoryManager &GetTemporaryMemoryManager(); + //! Take per-database ObjectCache under buffer pool's memory management. + //! Notice, object cache should be registered for at most once, otherwise InvalidInput exception is thrown. + void SetObjectCache(ObjectCache *object_cache_p) { + if (object_cache != nullptr) { + throw InvalidInputException("Object cache has already been registered in buffer pool, cannot re-register!"); + } + object_cache = object_cache_p; + } + protected: //! Evict blocks until the currently used memory + extra_memory fit, returns false if this was not possible //! (i.e. not enough blocks could be evicted) @@ -79,6 +91,9 @@ class BufferPool { virtual EvictionResult EvictBlocksInternal(EvictionQueue &queue, MemoryTag tag, idx_t extra_memory, idx_t memory_limit, unique_ptr *buffer = nullptr); + //! Evict object cache entries if needed. + EvictionResult EvictObjectCacheEntries(MemoryTag tag, idx_t extra_memory, idx_t memory_limit); + //! Purge all blocks that haven't been pinned within the last N seconds idx_t PurgeAgedBlocks(uint32_t max_age_sec); idx_t PurgeAgedBlocksInternal(EvictionQueue &queue, uint32_t max_age_sec, int64_t now, int64_t limit); @@ -163,6 +178,8 @@ class BufferPool { mutable MemoryUsage memory_usage; //! The block allocator BlockAllocator &block_allocator; + //! Per-database singleton object cache managed by buffer pool. + optional_ptr object_cache = nullptr; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool_reservation.hpp b/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool_reservation.hpp new file mode 100644 index 000000000..4140c9f00 --- /dev/null +++ b/src/duckdb/src/include/duckdb/storage/buffer/buffer_pool_reservation.hpp @@ -0,0 +1,48 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/storage/buffer/buffer_pool_reservation.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/common/enums/memory_tag.hpp" + +namespace duckdb { + +enum class BlockState : uint8_t { BLOCK_UNLOADED = 0, BLOCK_LOADED = 1 }; + +// Forward declaration. +class BufferPool; + +struct BufferPoolReservation { + MemoryTag tag; + idx_t size {0}; + BufferPool &pool; + + BufferPoolReservation(MemoryTag tag, BufferPool &pool); + BufferPoolReservation(const BufferPoolReservation &) = delete; + BufferPoolReservation &operator=(const BufferPoolReservation &) = delete; + + BufferPoolReservation(BufferPoolReservation &&) noexcept; + BufferPoolReservation &operator=(BufferPoolReservation &&) noexcept; + + virtual ~BufferPoolReservation(); + + void Resize(idx_t new_size); + void Merge(BufferPoolReservation src); +}; + +struct TempBufferPoolReservation : BufferPoolReservation { + TempBufferPoolReservation(MemoryTag tag, BufferPool &pool, idx_t size) : BufferPoolReservation(tag, pool) { + Resize(size); + } + TempBufferPoolReservation(TempBufferPoolReservation &&) = default; + ~TempBufferPoolReservation() override { + Resize(0); + } +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp b/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp index a13c72943..a598e74a9 100644 --- a/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp +++ b/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp @@ -55,9 +55,14 @@ struct UncompressedStringSegmentState : public CompressedSegmentState { string GetSegmentInfo() const override; + void InsertOverflowBlock(block_id_t block_id, reference block); + reference FindOverflowBlock(block_id_t block_id); + private: mutex block_lock; unordered_map> handles; + + StorageLock overflow_blocks_lock; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp index 0aa9f00c8..188b5f1bb 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp @@ -124,7 +124,7 @@ struct AlpScanState : public SegmentScanState { // Load the offset (metadata) indicating where the vector data starts metadata_ptr -= AlpConstants::METADATA_POINTER_SIZE; auto data_byte_offset = Load(metadata_ptr); - D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize()); + D_ASSERT(data_byte_offset < segment.GetBlockSize()); idx_t vector_size = MinValue((idx_t)AlpConstants::ALP_VECTOR_SIZE, (count - total_value_count)); diff --git a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp index a05b2026c..47e29434d 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_scan.hpp @@ -143,7 +143,7 @@ struct AlpRDScanState : public SegmentScanState { // Load the offset (metadata) indicating where the vector data starts metadata_ptr -= AlpRDConstants::METADATA_POINTER_SIZE; auto data_byte_offset = Load(metadata_ptr); - D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize()); + D_ASSERT(data_byte_offset < segment.GetBlockSize()); idx_t vector_size = MinValue((idx_t)AlpRDConstants::ALP_VECTOR_SIZE, (count - total_value_count)); diff --git a/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp b/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp index 6b87e5bb1..0e1131f8f 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/bitpacking.hpp @@ -14,7 +14,4 @@ namespace duckdb { enum class BitpackingMode : uint8_t { INVALID, AUTO, CONSTANT, CONSTANT_DELTA, DELTA_FOR, FOR }; -BitpackingMode BitpackingModeFromString(const string &str); -string BitpackingModeToString(const BitpackingMode &mode); - } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp index b29ecc8d1..6cd49a1e6 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_scan.hpp @@ -187,7 +187,7 @@ struct ChimpScanState : public SegmentScanState { // Load the offset indicating where a groups data starts metadata_ptr -= sizeof(uint32_t); auto data_byte_offset = Load(metadata_ptr); - D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize()); + D_ASSERT(data_byte_offset < segment.GetBlockSize()); // Only used for point queries (void)data_byte_offset; diff --git a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp index 74a0cf9a9..ea1f95fb0 100644 --- a/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp +++ b/src/duckdb/src/include/duckdb/storage/compression/patas/patas_scan.hpp @@ -154,7 +154,7 @@ struct PatasScanState : public SegmentScanState { // Load the offset indicating where a groups data starts metadata_ptr -= sizeof(uint32_t); auto data_byte_offset = Load(metadata_ptr); - D_ASSERT(data_byte_offset < segment.GetBlockManager().GetBlockSize()); + D_ASSERT(data_byte_offset < segment.GetBlockSize()); // Initialize the byte_reader with the data values for the group group_state.Init(segment_data + data_byte_offset); diff --git a/src/duckdb/src/include/duckdb/storage/object_cache.hpp b/src/duckdb/src/include/duckdb/storage/object_cache.hpp index e2a0de155..8a21a22d0 100644 --- a/src/duckdb/src/include/duckdb/storage/object_cache.hpp +++ b/src/duckdb/src/include/duckdb/storage/object_cache.hpp @@ -9,14 +9,19 @@ #pragma once #include "duckdb/common/common.hpp" +#include "duckdb/common/enums/memory_tag.hpp" #include "duckdb/common/lru_cache.hpp" #include "duckdb/common/mutex.hpp" #include "duckdb/common/string.hpp" #include "duckdb/common/unordered_map.hpp" #include "duckdb/main/database.hpp" +#include "duckdb/storage/buffer/buffer_pool_reservation.hpp" namespace duckdb { +// Forward declaration. +class BufferPool; + //! ObjectCache is the base class for objects caches in DuckDB class ObjectCacheEntry { public: @@ -33,17 +38,12 @@ class ObjectCacheEntry { class ObjectCache { public: //! Default max memory 8GiB for non-evictable cache entries. - // - // TODO(hjiang): Hard-code a large enough memory consumption upper bound, which is likely a non-regression change. - // I will followup with another PR before v1.5.0 release to provide a user option to tune. - // - // A few consideration here: should we cap object cache memory consumption with duckdb max memory or separate. static constexpr idx_t DEFAULT_MAX_MEMORY = 8ULL * 1024 * 1024 * 1024; - ObjectCache() : ObjectCache(DEFAULT_MAX_MEMORY) { + explicit ObjectCache(BufferPool &buffer_pool_p) : ObjectCache(DEFAULT_MAX_MEMORY, buffer_pool_p) { } - explicit ObjectCache(idx_t max_memory) : lru_cache(max_memory) { + ObjectCache(idx_t max_memory, BufferPool &buffer_pool_p) : lru_cache(max_memory), buffer_pool(buffer_pool_p) { } shared_ptr GetObject(const string &key) { @@ -93,10 +93,12 @@ class ObjectCache { const bool is_evictable = estimated_memory.IsValid(); if (!is_evictable) { non_evictable_entries[key] = value; - } else { - lru_cache.Put(key, value, estimated_memory.GetIndex()); + return value; } + auto reservation = + make_uniq(MemoryTag::OBJECT_CACHE, buffer_pool, estimated_memory.GetIndex()); + lru_cache.Put(key, value, std::move(reservation)); return value; } @@ -112,7 +114,10 @@ class ObjectCache { non_evictable_entries[std::move(key)] = std::move(value); return; } - lru_cache.Put(std::move(key), std::move(value), estimated_memory.GetIndex()); + + auto reservation = + make_uniq(MemoryTag::OBJECT_CACHE, buffer_pool, estimated_memory.GetIndex()); + lru_cache.Put(std::move(key), std::move(value), std::move(reservation)); } void Delete(const string &key) { @@ -139,6 +144,15 @@ class ObjectCache { const lock_guard lock(lock_mutex); return lru_cache.Size() + non_evictable_entries.size(); } + bool IsEmpty() const { + const lock_guard lock(lock_mutex); + return lru_cache.IsEmpty() && non_evictable_entries.empty(); + } + + idx_t EvictToReduceMemory(idx_t target_bytes) { + const lock_guard lock(lock_mutex); + return lru_cache.EvictToReduceMemory(target_bytes); + } private: mutable mutex lock_mutex; @@ -146,6 +160,8 @@ class ObjectCache { SharedLruCache lru_cache; //! Separate storage for non-evictable entries (i.e., encryption keys) unordered_map> non_evictable_entries; + //! Used to create buffer pool reservation on entries creation. + BufferPool &buffer_pool; }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp b/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp index 763a0d067..d28d56a93 100644 --- a/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp +++ b/src/duckdb/src/include/duckdb/storage/segment/uncompressed.hpp @@ -30,6 +30,13 @@ struct ValidityUncompressed { public: static CompressionFunction GetFunction(PhysicalType data_type); static void AlignedScan(data_ptr_t input, idx_t input_start, Vector &result, idx_t scan_count); + + //! ANDs scan_count validity bits from input (starting at input_start) into the result validity mask + //! (starting at result_offset). If a bit in the result is already invalid (0), it remains invalid + //! regardless of the input bit value - i.e., the operation is result[i] &= input[i]. + //! This function should be used, as the name suggests, if the starting points are unaligned relative to + //! ValidityMask::BITS_PER_VALUE, otherwise AlignedScan should be used (however this function will + //! still work). static void UnalignedScan(data_ptr_t input, idx_t input_size, idx_t input_start, Vector &result, idx_t result_offset, idx_t scan_count); diff --git a/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp b/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp index 7a2dce826..7819ccf00 100644 --- a/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp +++ b/src/duckdb/src/include/duckdb/storage/single_file_block_manager.hpp @@ -38,6 +38,8 @@ struct EncryptionOptions { uint32_t key_length = MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH; //! User key pointer (to StorageOptions) shared_ptr user_key; + //! Version of duckdb-encryption + EncryptionTypes::EncryptionVersion encryption_version = EncryptionTypes::NONE; }; struct StorageManagerOptions { @@ -156,6 +158,8 @@ class SingleFileBlockManager : public BlockManager { static void StoreEncryptedCanary(AttachedDatabase &db, MainHeader &main_header, const string &key_id); static void StoreDBIdentifier(MainHeader &main_header, const data_ptr_t db_identifier); void StoreEncryptionMetadata(MainHeader &main_header) const; + template + static void WriteEncryptionData(MemoryStream &stream, const T &val); //! Check and adding Encryption Keys void CheckAndAddEncryptionKey(MainHeader &main_header, string &user_key); diff --git a/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp b/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp index 6b88247d0..e6585e982 100644 --- a/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp +++ b/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp @@ -163,6 +163,8 @@ class StandardBufferManager : public BufferManager { void BatchRead(vector> &handles, const map &load_map, block_id_t first_block, block_id_t last_block); + bool EncryptTemporaryFiles(); + protected: // These are stored here because temp_directory creation is lazy // so we need to store information related to the temporary directory before it's created diff --git a/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp b/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp index 237ddec7e..203fdef6e 100644 --- a/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp +++ b/src/duckdb/src/include/duckdb/storage/statistics/base_statistics.hpp @@ -89,7 +89,7 @@ class BaseStatistics { void Set(StatsInfo info); void CombineValidity(const BaseStatistics &left, const BaseStatistics &right); - void CopyValidity(BaseStatistics &stats); + void CopyValidity(const BaseStatistics &stats); //! Set that the CURRENT level can have null values //! Note that this is not correct for nested types unless this information is propagated in a different manner //! Use Set(StatsInfo::CAN_HAVE_NULL_VALUES) in the general case diff --git a/src/duckdb/src/include/duckdb/storage/statistics/geometry_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/geometry_stats.hpp index 78f7608d3..2adf308d6 100644 --- a/src/duckdb/src/include/duckdb/storage/statistics/geometry_stats.hpp +++ b/src/duckdb/src/include/duckdb/storage/statistics/geometry_stats.hpp @@ -75,6 +75,69 @@ class GeometryTypeSet { } } + //! Check if only the given geometry and vertex type is present + //! (all others are absent) + bool HasOnly(GeometryType geom_type, VertexType vert_type) const { + const auto vert_idx = static_cast(vert_type); + const auto geom_idx = static_cast(geom_type); + D_ASSERT(vert_idx < VERT_TYPES); + D_ASSERT(geom_idx < PART_TYPES); + for (uint8_t v_idx = 0; v_idx < VERT_TYPES; v_idx++) { + for (uint8_t g_idx = 1; g_idx < PART_TYPES; g_idx++) { + if (v_idx == vert_idx && g_idx == geom_idx) { + if (!(sets[v_idx] & (1 << g_idx))) { + return false; + } + } else { + if (sets[v_idx] & (1 << g_idx)) { + return false; + } + } + } + } + return true; + } + + bool HasSingleType() const { + idx_t type_count = 0; + for (uint8_t v_idx = 0; v_idx < VERT_TYPES; v_idx++) { + for (uint8_t g_idx = 1; g_idx < PART_TYPES; g_idx++) { + if (sets[v_idx] & (1 << g_idx)) { + type_count++; + if (type_count > 1) { + return false; + } + } + } + } + return type_count == 1; + } + + bool TryGetSingleType(GeometryType &geom_type, VertexType &vert_type) const { + auto result_geom = GeometryType::INVALID; + auto result_vert = VertexType::XY; + auto result_found = false; + + for (uint8_t v_idx = 0; v_idx < VERT_TYPES; v_idx++) { + for (uint8_t g_idx = 1; g_idx < PART_TYPES; g_idx++) { + if (sets[v_idx] & (1 << g_idx)) { + if (result_found) { + // Multiple types found + return false; + } + result_found = true; + result_geom = static_cast(g_idx); + result_vert = static_cast(v_idx); + } + } + } + if (result_found) { + geom_type = result_geom; + vert_type = result_vert; + } + return result_found; + } + void AddWKBType(int32_t wkb_type) { const auto vert_idx = static_cast((wkb_type / 1000) % 10); const auto geom_idx = static_cast(wkb_type % 1000); @@ -100,23 +163,85 @@ class GeometryTypeSet { uint8_t sets[VERT_TYPES]; }; +class GeometryStatsFlags { +public: + // There are two types of "empty" + // 1. Empty geometry: A geometry that contains no vertices (e.g., POINT EMPTY) + // 2. Empty part: A geometry that contains at least one empty geometry (e.g., MULTIPOINT(POINT EMPTY, POINT(1 2))) + + static GeometryStatsFlags Unknown() { + GeometryStatsFlags flags; + flags.flags = 0xF; // All bits set + return flags; + } + + static GeometryStatsFlags Empty() { + GeometryStatsFlags flags; + flags.flags = 0x0; // No bits set + return flags; + } + void Clear() { + flags = 0x0; + } + bool HasEmptyGeometry() const { + return (flags & HAS_EMPTY_GEOM) != 0; + } + bool HasNonEmptyGeometry() const { + return (flags & HAS_NON_EMPTY_GEOM) != 0; + } + bool HasEmptyPart() const { + return (flags & HAS_EMPTY_PART) != 0; + } + bool HasNonEmptyPart() const { + return (flags & HAS_NON_EMPTY_PART) != 0; + } + void SetHasEmptyGeometry() { + flags |= HAS_EMPTY_GEOM; + } + void SetHasNonEmptyGeometry() { + flags |= HAS_NON_EMPTY_GEOM; + } + void SetHasEmptyPart() { + flags |= HAS_EMPTY_PART; + } + void SetHasNonEmptyPart() { + flags |= HAS_NON_EMPTY_PART; + } + + void Merge(const GeometryStatsFlags &other) { + flags |= other.flags; + } + + uint8_t flags; + +private: + static constexpr auto HAS_EMPTY_GEOM = 0x1; + static constexpr auto HAS_NON_EMPTY_GEOM = 0x2; + static constexpr auto HAS_EMPTY_PART = 0x4; + static constexpr auto HAS_NON_EMPTY_PART = 0x8; +}; + struct GeometryStatsData { GeometryTypeSet types; GeometryExtent extent; + GeometryStatsFlags flags; void SetEmpty() { types = GeometryTypeSet::Empty(); extent = GeometryExtent::Empty(); + flags = GeometryStatsFlags::Empty(); } void SetUnknown() { types = GeometryTypeSet::Unknown(); extent = GeometryExtent::Unknown(); + flags = GeometryStatsFlags::Unknown(); } void Merge(const GeometryStatsData &other) { types.Merge(other.types); extent.Merge(other.extent); + flags.Merge(other.flags); } void Update(const string_t &geom_blob) { @@ -125,7 +250,21 @@ struct GeometryStatsData { types.Add(type_info.first, type_info.second); // Update extent - Geometry::GetExtent(geom_blob, extent); + bool has_any_empty = false; + const auto vert_count = Geometry::GetExtent(geom_blob, extent, has_any_empty); + + // Update flags + if (has_any_empty) { + flags.SetHasEmptyPart(); + } else { + flags.SetHasNonEmptyPart(); + } + + if (vert_count == 0) { + flags.SetHasEmptyGeometry(); + } else { + flags.SetHasNonEmptyGeometry(); + } } }; @@ -152,8 +291,9 @@ struct GeometryStats { DUCKDB_API static const GeometryExtent &GetExtent(const BaseStatistics &stats); DUCKDB_API static GeometryTypeSet &GetTypes(BaseStatistics &stats); DUCKDB_API static const GeometryTypeSet &GetTypes(const BaseStatistics &stats); + DUCKDB_API static GeometryStatsFlags &GetFlags(BaseStatistics &stats); + DUCKDB_API static const GeometryStatsFlags &GetFlags(const BaseStatistics &stats); -private: static GeometryStatsData &GetDataUnsafe(BaseStatistics &stats); static const GeometryStatsData &GetDataUnsafe(const BaseStatistics &stats); }; diff --git a/src/duckdb/src/include/duckdb/storage/statistics/variant_stats.hpp b/src/duckdb/src/include/duckdb/storage/statistics/variant_stats.hpp index e2cbfae94..a91ff7c03 100644 --- a/src/duckdb/src/include/duckdb/storage/statistics/variant_stats.hpp +++ b/src/duckdb/src/include/duckdb/storage/statistics/variant_stats.hpp @@ -2,6 +2,7 @@ #include "duckdb/common/types/variant.hpp" #include "duckdb/common/types/selection_vector.hpp" +#include "duckdb/storage/storage_index.hpp" namespace duckdb { class BaseStatistics; @@ -25,6 +26,8 @@ struct VariantStatsData { struct VariantShreddedStats { public: DUCKDB_API static bool IsFullyShredded(const BaseStatistics &stats); + DUCKDB_API static optional_ptr FindChildStats(const BaseStatistics &stats, + const VariantPathComponent &component); }; //! VARIANT as a type can hold arbitrarily typed values within the same column. @@ -65,6 +68,8 @@ struct VariantStats { DUCKDB_API static bool MergeShredding(BaseStatistics &stats, const BaseStatistics &other, BaseStatistics &new_stats); + DUCKDB_API static unique_ptr WrapExtractedFieldAsVariant(const BaseStatistics &base_variant, + const BaseStatistics &extracted_field); public: DUCKDB_API static void Serialize(const BaseStatistics &stats, Serializer &serializer); @@ -75,6 +80,8 @@ struct VariantStats { DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other); DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count); DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other); + DUCKDB_API static unique_ptr PushdownExtract(const BaseStatistics &stats, + const StorageIndex &index); private: static VariantStatsData &GetDataUnsafe(BaseStatistics &stats); diff --git a/src/duckdb/src/include/duckdb/storage/storage_extension.hpp b/src/duckdb/src/include/duckdb/storage/storage_extension.hpp index 8f55d9b7c..62b887cd1 100644 --- a/src/duckdb/src/include/duckdb/storage/storage_extension.hpp +++ b/src/duckdb/src/include/duckdb/storage/storage_extension.hpp @@ -44,10 +44,13 @@ class StorageExtension { virtual void OnCheckpointEnd(AttachedDatabase &db, CheckpointOptions checkpoint_options) { } + + static optional_ptr Find(const DBConfig &config, const string &extension_name); + static void Register(DBConfig &config, const string &extension_name, shared_ptr extension); }; struct OpenFileStorageExtension { - static unique_ptr Create(); + static shared_ptr Create(); }; } // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/storage_index.hpp b/src/duckdb/src/include/duckdb/storage/storage_index.hpp index 09aec8e1c..75f5fe8d4 100644 --- a/src/duckdb/src/include/duckdb/storage/storage_index.hpp +++ b/src/duckdb/src/include/duckdb/storage/storage_index.hpp @@ -19,12 +19,20 @@ enum class StorageIndexType : uint8_t { FULL_READ, PUSHDOWN_EXTRACT }; struct StorageIndex { public: - StorageIndex() : index(COLUMN_IDENTIFIER_ROW_ID), index_type(StorageIndexType::FULL_READ) { + StorageIndex() : has_index(true), index(COLUMN_IDENTIFIER_ROW_ID), index_type(StorageIndexType::FULL_READ) { } - explicit StorageIndex(idx_t index) : index(index), index_type(StorageIndexType::FULL_READ) { + explicit StorageIndex(idx_t index) : has_index(true), index(index), index_type(StorageIndexType::FULL_READ) { + } + explicit StorageIndex(const string &field) + : has_index(false), field(field), index_type(StorageIndexType::FULL_READ) { } StorageIndex(idx_t index, vector child_indexes_p) - : index(index), index_type(StorageIndexType::FULL_READ), child_indexes(std::move(child_indexes_p)) { + : has_index(true), index(index), index_type(StorageIndexType::FULL_READ), + child_indexes(std::move(child_indexes_p)) { + } + StorageIndex(const string &field, vector child_indexes_p) + : has_index(false), field(field), index_type(StorageIndexType::FULL_READ), + child_indexes(std::move(child_indexes_p)) { } inline bool operator==(const StorageIndex &rhs) const { @@ -43,7 +51,12 @@ struct StorageIndex { for (auto &child_id : column_id.GetChildIndexes()) { result.push_back(StorageIndex::FromColumnIndex(child_id)); } - auto storage_index = StorageIndex(column_id.GetPrimaryIndex(), std::move(result)); + StorageIndex storage_index; + if (column_id.HasPrimaryIndex()) { + storage_index = StorageIndex(column_id.GetPrimaryIndex(), std::move(result)); + } else { + storage_index = StorageIndex(column_id.GetFieldName(), std::move(result)); + } if (column_id.HasType()) { storage_index.SetType(column_id.GetType()); } @@ -54,15 +67,31 @@ struct StorageIndex { } public: + bool HasPrimaryIndex() const { + return has_index; + } idx_t GetPrimaryIndex() const { + D_ASSERT(has_index); return index; } + const string &GetFieldName() const { + D_ASSERT(!has_index); + return field; + } PhysicalIndex ToPhysical() const { + D_ASSERT(has_index); return PhysicalIndex(index); } bool HasType() const { return type.id() != LogicalTypeId::INVALID; } + const LogicalType &GetScanType() const { + D_ASSERT(HasType()); + if (IsPushdownExtract()) { + return child_indexes[0].GetScanType(); + } + return GetType(); + } const LogicalType &GetType() const { return type; } @@ -95,14 +124,21 @@ struct StorageIndex { return index_type == StorageIndexType::PUSHDOWN_EXTRACT; } void SetIndex(idx_t new_index) { + D_ASSERT(has_index); index = new_index; } bool IsRowIdColumn() const { + if (!has_index) { + return false; + } return index == DConstants::INVALID_INDEX; } private: + bool has_index = true; idx_t index; + string field; + LogicalType type = LogicalType::INVALID; StorageIndexType index_type; vector child_indexes; diff --git a/src/duckdb/src/include/duckdb/storage/storage_info.hpp b/src/duckdb/src/include/duckdb/storage/storage_info.hpp index f919bac33..228865b9c 100644 --- a/src/duckdb/src/include/duckdb/storage/storage_info.hpp +++ b/src/duckdb/src/include/duckdb/storage/storage_info.hpp @@ -96,6 +96,8 @@ class MainHeader { uint64_t version_number; //! The set of flags used by the database. uint64_t flags[FLAG_COUNT]; + //! Encryption version + uint8_t encryption_version; //! The length of the unique database identifier. static constexpr idx_t DB_IDENTIFIER_LEN = 16; @@ -123,6 +125,9 @@ class MainHeader { void SetEncrypted() { flags[0] |= MainHeader::ENCRYPTED_DATABASE_FLAG; } + void SetEncryptionVersion(uint8_t version) { + encryption_version = version; + } void SetEncryptionMetadata(data_ptr_t source) { memset(encryption_metadata, 0, ENCRYPTION_METADATA_LEN); @@ -133,6 +138,10 @@ class MainHeader { return static_cast(encryption_metadata[2]); } + EncryptionTypes::EncryptionVersion GetEncryptionVersion() const { + return static_cast(encryption_metadata[3]); + } + void SetDBIdentifier(data_ptr_t source) { memset(db_identifier, 0, DB_IDENTIFIER_LEN); memcpy(db_identifier, source, DB_IDENTIFIER_LEN); @@ -143,10 +152,28 @@ class MainHeader { memcpy(encrypted_canary, source, CANARY_BYTE_SIZE); } + void SetCanaryIV(data_ptr_t source) { + memset(canary_iv, 0, AES_IV_LEN); + memcpy(canary_iv, source, AES_IV_LEN); + } + + void SetCanaryTag(data_ptr_t source) { + memset(canary_tag, 0, AES_TAG_LEN); + memcpy(canary_tag, source, AES_TAG_LEN); + } + data_ptr_t GetDBIdentifier() { return db_identifier; } + data_ptr_t GetIV() { + return canary_iv; + } + + data_ptr_t GetTag() { + return canary_tag; + } + static bool CompareDBIdentifiers(const data_ptr_t db_identifier_1, const data_ptr_t db_identifier_2) { for (idx_t i = 0; i < DB_IDENTIFIER_LEN; i++) { if (db_identifier_1[i] != db_identifier_2[i]) { @@ -170,6 +197,8 @@ class MainHeader { //! The unique database identifier and optional encryption salt. data_t db_identifier[DB_IDENTIFIER_LEN]; data_t encrypted_canary[CANARY_BYTE_SIZE]; + data_t canary_iv[AES_IV_LEN]; + data_t canary_tag[AES_IV_LEN]; }; //! The DatabaseHeader contains information about the current state of the database. Every storage file has two diff --git a/src/duckdb/src/include/duckdb/storage/storage_manager.hpp b/src/duckdb/src/include/duckdb/storage/storage_manager.hpp index b6e0fda94..7861b53f9 100644 --- a/src/duckdb/src/include/duckdb/storage/storage_manager.hpp +++ b/src/duckdb/src/include/duckdb/storage/storage_manager.hpp @@ -131,6 +131,9 @@ class StorageManager { bool IsEncrypted() const { return storage_options.encryption; } + uint8_t GetEncryptionVersion() const { + return storage_options.encryption_version; + } protected: virtual void LoadDatabase(QueryContext context) = 0; diff --git a/src/duckdb/src/include/duckdb/storage/storage_options.hpp b/src/duckdb/src/include/duckdb/storage/storage_options.hpp index 4cf1f539b..63af588a2 100644 --- a/src/duckdb/src/include/duckdb/storage/storage_options.hpp +++ b/src/duckdb/src/include/duckdb/storage/storage_options.hpp @@ -36,7 +36,10 @@ struct StorageOptions { //! encryption key //! FIXME: change to a unique_ptr in the future shared_ptr user_key; + //! encryption version (set default to 1) + EncryptionTypes::EncryptionVersion encryption_version = EncryptionTypes::NONE; + void SetEncryptionVersion(string &storage_version_user_provided); void Initialize(const unordered_map &options); }; diff --git a/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp b/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp index 286c97fdf..52ed376c4 100644 --- a/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp +++ b/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp @@ -127,7 +127,7 @@ struct UncompressedStringStorage { auto end = handle.Ptr() + *dictionary_end; #ifdef DEBUG - GetDictionary(segment, handle).Verify(segment.GetBlockManager().GetBlockSize()); + GetDictionary(segment, handle).Verify(segment.GetBlockSize()); #endif // Unknown string, continue // non-null value, check if we can fit it within the block @@ -136,8 +136,7 @@ struct UncompressedStringStorage { // determine whether or not we have space in the block for this string bool use_overflow_block = false; idx_t required_space = string_length; - if (DUCKDB_UNLIKELY(required_space >= - StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize()))) { + if (DUCKDB_UNLIKELY(required_space >= StringUncompressed::GetStringBlockLimit(segment.GetBlockSize()))) { // string exceeds block limit, store in overflow block and only write a marker here required_space = BIG_STRING_MARKER_SIZE; use_overflow_block = true; @@ -168,7 +167,7 @@ struct UncompressedStringStorage { // note: for overflow strings we write negative value // dictionary_size is an uint32_t value, so we can cast up. - D_ASSERT(NumericCast(*dictionary_size) <= segment.GetBlockManager().GetBlockSize()); + D_ASSERT(NumericCast(*dictionary_size) <= segment.GetBlockSize()); result_data[target_idx] = -NumericCast((*dictionary_size)); } else { // string fits in block, append to dictionary and increment dictionary position @@ -180,13 +179,13 @@ struct UncompressedStringStorage { memcpy(dict_pos, source_data[source_idx].GetData(), string_length); // dictionary_size is an uint32_t value, so we can cast up. - D_ASSERT(NumericCast(*dictionary_size) <= segment.GetBlockManager().GetBlockSize()); + D_ASSERT(NumericCast(*dictionary_size) <= segment.GetBlockSize()); // Place the dictionary offset into the set of vectors. result_data[target_idx] = NumericCast(*dictionary_size); } - D_ASSERT(RemainingSpace(segment, handle) <= segment.GetBlockManager().GetBlockSize()); + D_ASSERT(RemainingSpace(segment, handle) <= segment.GetBlockSize()); #ifdef DEBUG - GetDictionary(segment, handle).Verify(segment.GetBlockManager().GetBlockSize()); + GetDictionary(segment, handle).Verify(segment.GetBlockSize()); #endif } segment.count += count; @@ -220,7 +219,7 @@ struct UncompressedStringStorage { inline static string_t FetchStringFromDict(ColumnSegment &segment, uint32_t dict_end_offset, Vector &result, data_ptr_t base_ptr, int32_t dict_offset, uint32_t string_length) { - D_ASSERT(dict_offset <= NumericCast(segment.GetBlockManager().GetBlockSize())); + D_ASSERT(dict_offset <= NumericCast(segment.GetBlockSize())); if (DUCKDB_LIKELY(dict_offset >= 0)) { // regular string - fetch from dictionary auto dict_end = base_ptr + dict_end_offset; diff --git a/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp index 79b2d007c..f9b15b0f1 100644 --- a/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/array_column_data.hpp @@ -52,7 +52,8 @@ class ArrayColumnData : public ColumnData { unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager) override; - unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) override; bool IsPersistent() override; bool HasAnyChanges() const override; @@ -67,6 +68,8 @@ class ArrayColumnData : public ColumnData { void SetValidityData(shared_ptr validity); void SetChildData(shared_ptr child_column); + const BaseStatistics &GetChildStats(const ColumnData &child) const override; + protected: //! The child-column of the list shared_ptr child_column; diff --git a/src/duckdb/src/include/duckdb/storage/table/column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/column_data.hpp index 53f309ce4..ad291434f 100644 --- a/src/duckdb/src/include/duckdb/storage/table/column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/column_data.hpp @@ -104,6 +104,9 @@ class ColumnData : public enable_shared_from_this { D_ASSERT(HasParent()); return *parent; } + + virtual const BaseStatistics &GetChildStats(const ColumnData &child) const; + const LogicalType &GetType() const { return type; } @@ -175,7 +178,11 @@ class ColumnData : public enable_shared_from_this { virtual unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager); - virtual unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info); + //! If this is a nested column, "stats" are the corresponding statistics from the parent column + //! Otherwise, "stats" == this->statistics->stats + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info); + virtual unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &stats); virtual void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t count, Vector &scan_vector) const; @@ -202,6 +209,7 @@ class ColumnData : public enable_shared_from_this { void MergeStatistics(const BaseStatistics &other); void MergeIntoStatistics(BaseStatistics &other); unique_ptr GetStatistics() const; + const BaseStatistics &GetStatisticsRef() const; protected: //! Append a transient segment @@ -243,10 +251,10 @@ class ColumnData : public enable_shared_from_this { unique_ptr updates; //! The lock for the stats mutable mutex stats_lock; - //! The stats of the root segment - unique_ptr stats; //! Total transient allocation size atomic allocation_size; + //! The stats of the root segment + unique_ptr stats; private: //! Whether or not this column data belongs to a main table or if it is transaction local @@ -270,6 +278,69 @@ class ColumnData : public enable_shared_from_this { } }; +enum class ExtraPersistentColumnDataType : uint8_t { + INVALID = 0, + VARIANT = 1, + GEOMETRY = 2, +}; + +class ExtraPersistentColumnData { +public: + ExtraPersistentColumnDataType GetType() const { + return type; + } + + virtual ~ExtraPersistentColumnData() = default; + + template + TARGET &Cast() { + D_ASSERT(type == TARGET::TYPE); + DynamicCastCheck(this); + return reinterpret_cast(*this); + } + template + const TARGET &Cast() const { + D_ASSERT(type == TARGET::TYPE); + DynamicCastCheck(this); + return reinterpret_cast(*this); + } + + void Serialize(Serializer &serializer) const; + static unique_ptr Deserialize(Deserializer &deserializer); + +protected: + explicit ExtraPersistentColumnData(ExtraPersistentColumnDataType type_p) : type(type_p) { + } + +private: + ExtraPersistentColumnDataType type; +}; + +class VariantPersistentColumnData final : public ExtraPersistentColumnData { +public: + static constexpr auto TYPE = ExtraPersistentColumnDataType::VARIANT; + VariantPersistentColumnData() : ExtraPersistentColumnData(TYPE) { + } + explicit VariantPersistentColumnData(const LogicalType &storage_type) + : ExtraPersistentColumnData(TYPE), logical_type(storage_type) { + } + + LogicalType logical_type; +}; + +class GeometryPersistentColumnData final : public ExtraPersistentColumnData { +public: + static constexpr auto TYPE = ExtraPersistentColumnDataType::GEOMETRY; + GeometryPersistentColumnData() : ExtraPersistentColumnData(TYPE) { + } + GeometryPersistentColumnData(GeometryType type, VertexType vert) + : ExtraPersistentColumnData(TYPE), geom_type(type), vert_type(vert) { + } + + GeometryType geom_type = GeometryType::INVALID; + VertexType vert_type = VertexType::XY; +}; + struct PersistentColumnData { public: explicit PersistentColumnData(const LogicalType &logical_type); @@ -288,15 +359,15 @@ struct PersistentColumnData { void DeserializeField(Deserializer &deserializer, field_id_t field_idx, const char *field_name, const LogicalType &type); bool HasUpdates() const; - void SetVariantShreddedType(const LogicalType &shredded_type); public: - PhysicalType physical_type; - LogicalTypeId logical_type_id; + LogicalType logical_type; vector pointers; vector child_columns; bool has_updates = false; - LogicalType variant_shredded_type; + + //! Extra persistent data for specific column types + unique_ptr extra_data; }; struct PersistentRowGroupData { diff --git a/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp b/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp index ce75200b4..3f5750bad 100644 --- a/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp @@ -110,11 +110,9 @@ class ColumnSegment : public SegmentBase { return block_id; } - //! Returns the block manager handling this segment. For transient segments, this might be the temporary block - //! manager. Later, we possibly convert this (transient) segment to a persistent segment. In that case, there - //! exists another block manager handling the ColumnData, of which this segment is a part. - BlockManager &GetBlockManager() const { - return block->block_manager; + //! Returns the size of the underlying block of the segment. It is size is the size available for usage on a block. + idx_t GetBlockSize() const { + return block->GetBlockSize(); } idx_t GetBlockOffset() { diff --git a/src/duckdb/src/include/duckdb/storage/table/geo_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/geo_column_data.hpp new file mode 100644 index 000000000..d091530e7 --- /dev/null +++ b/src/duckdb/src/include/duckdb/storage/table/geo_column_data.hpp @@ -0,0 +1,83 @@ +//===----------------------------------------------------------------------===// +// DuckDB +// +// duckdb/storage/table/geo_column_data.hpp +// +// +//===----------------------------------------------------------------------===// + +#pragma once + +#include "duckdb/storage/table/column_data.hpp" +#include "duckdb/storage/table/validity_column_data.hpp" + +namespace duckdb { + +class GeoColumnData final : public ColumnData { +public: + GeoColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, LogicalType type, + ColumnDataType data_type, optional_ptr parent); + + //! The actual column data + //! The "shape" of this might differ depending on if we "shred" this column or not. + shared_ptr base_column; + + //! Shredding state of the column + GeometryType geom_type = GeometryType::INVALID; + VertexType vert_type = VertexType::XY; + +public: + idx_t GetMaxEntry() override; + + void InitializeChildScanStates(ColumnScanState &state); + + void InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) override; + void InitializeScan(ColumnScanState &state) override; + void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; + + idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, + idx_t scan_count) override; + + idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count, idx_t result_offset = 0) override; + + void Skip(ColumnScanState &state, idx_t count = STANDARD_VECTOR_SIZE) override; + + void InitializeAppend(ColumnAppendState &state) override; + void Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t count) override; + void RevertAppend(row_t new_count) override; + idx_t Fetch(ColumnScanState &state, row_t row_id, Vector &result) override; + void FetchRow(TransactionData transaction, ColumnFetchState &state, const StorageIndex &storage_index, row_t row_id, + Vector &result, idx_t result_idx) override; + void Update(TransactionData transaction, DataTable &data_table, idx_t column_index, Vector &update_vector, + row_t *row_ids, idx_t update_count, idx_t row_group_start) override; + void UpdateColumn(TransactionData transaction, DataTable &data_table, const vector &column_path, + Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t depth, + idx_t row_group_start) override; + unique_ptr GetUpdateStatistics() override; + + unique_ptr CreateCheckpointState(const RowGroup &row_group, + PartialBlockManager &partial_block_manager) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) override; + + bool IsPersistent() override; + bool HasAnyChanges() const override; + PersistentColumnData Serialize() override; + void InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) override; + + void GetColumnSegmentInfo(const QueryContext &context, idx_t row_group_index, vector col_path, + vector &result) override; + + void Verify(RowGroup &parent) override; + + void VisitBlockIds(BlockIdVisitor &visitor) const override; + +private: + static void Specialize(Vector &source, Vector &target, idx_t count, GeometryType geom_type, VertexType vert_type); + static void Reassemble(Vector &source, Vector &target, idx_t count, GeometryType geom_type, VertexType vert_type, + idx_t offset); + static void InterpretStats(BaseStatistics &source, BaseStatistics &target, GeometryType geom_type, + VertexType vert_type); +}; + +} // namespace duckdb diff --git a/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp index 31b99e223..547d56fbb 100644 --- a/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/list_column_data.hpp @@ -50,7 +50,8 @@ class ListColumnData : public ColumnData { unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager) override; - unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) override; bool IsPersistent() override; bool HasAnyChanges() const override; @@ -63,6 +64,8 @@ class ListColumnData : public ColumnData { void SetValidityData(shared_ptr validity_p); void SetChildData(shared_ptr child_column_p); + const BaseStatistics &GetChildStats(const ColumnData &child) const override; + protected: //! The child-column of the list shared_ptr child_column; diff --git a/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp b/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp index 7134e06ea..ed88da77d 100644 --- a/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp @@ -70,7 +70,7 @@ class RowGroupCollection { void InitializeCreateIndexScan(CreateIndexScanState &state); void InitializeScanWithOffset(const QueryContext &context, CollectionScanState &state, const vector &column_ids, idx_t start_row, idx_t end_row); - static bool InitializeScanInRowGroup(const QueryContext &context, CollectionScanState &state, + static bool InitializeScanInRowGroup(ClientContext &context, CollectionScanState &state, RowGroupCollection &collection, SegmentNode &row_group, idx_t vector_index, idx_t max_row); void InitializeParallelScan(ParallelCollectionScanState &state); diff --git a/src/duckdb/src/include/duckdb/storage/table/row_id_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/row_id_column_data.hpp index 19987764f..c58f2907b 100644 --- a/src/duckdb/src/include/duckdb/storage/table/row_id_column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/row_id_column_data.hpp @@ -54,7 +54,8 @@ class RowIdColumnData : public ColumnData { unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager) override; - unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) override; void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t count, Vector &scan_vector) const override; diff --git a/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp b/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp index 7d1e92e37..822edc4cb 100644 --- a/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/scan_state.hpp @@ -132,6 +132,9 @@ struct ColumnScanState { //! Whether or not updates should be allowed UpdateScanType update_scan_type = UpdateScanType::STANDARD; +public: + void PushDownCast(const LogicalType &original_type, const LogicalType &cast_type); + public: void Initialize(const QueryContext &context_p, const LogicalType &type, const StorageIndex &column_id, optional_ptr options); diff --git a/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp index b432ba6d4..7249aaf08 100644 --- a/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/standard_column_data.hpp @@ -53,7 +53,8 @@ class StandardColumnData : public ColumnData { unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager) override; - unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &stats) override; void CheckpointScan(ColumnSegment &segment, ColumnScanState &state, idx_t count, Vector &scan_vector) const override; diff --git a/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp index a64da2ef3..538152b1d 100644 --- a/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/struct_column_data.hpp @@ -15,6 +15,20 @@ namespace duckdb { //! Struct column data represents a struct class StructColumnData : public ColumnData { +public: + struct StructColumnDataChild { + public: + StructColumnDataChild(ColumnData &col, optional_idx vector_index, ColumnScanState &child, bool should_scan) + : col(col), vector_index(vector_index), state(child), should_scan(should_scan) { + } + + public: + ColumnData &col; + optional_idx vector_index; + ColumnScanState &state; + bool should_scan; + }; + public: StructColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, LogicalType type, ColumnDataType data_type, optional_ptr parent); @@ -27,8 +41,7 @@ class StructColumnData : public ColumnData { void InitializeScan(ColumnScanState &state) override; void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; - void IterateFields(ColumnScanState &state, - const std::function &callback); + vector GetStructChildren(ColumnScanState &state) const; idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, idx_t scan_count) override; @@ -53,7 +66,8 @@ class StructColumnData : public ColumnData { unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager) override; - unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) override; bool IsPersistent() override; bool HasAnyChanges() const override; @@ -67,6 +81,9 @@ class StructColumnData : public ColumnData { void SetValidityData(shared_ptr validity_p); void SetChildData(idx_t i, shared_ptr child_column_p); + const ColumnData &GetChildColumn(idx_t index) const; + + const BaseStatistics &GetChildStats(const ColumnData &child) const override; protected: //! The sub-columns of the struct diff --git a/src/duckdb/src/include/duckdb/storage/table/variant_column_data.hpp b/src/duckdb/src/include/duckdb/storage/table/variant_column_data.hpp index 973f8bf72..90646d384 100644 --- a/src/duckdb/src/include/duckdb/storage/table/variant_column_data.hpp +++ b/src/duckdb/src/include/duckdb/storage/table/variant_column_data.hpp @@ -33,7 +33,6 @@ class VariantColumnData : public ColumnData { void InitializeScan(ColumnScanState &state) override; void InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) override; - Vector CreateUnshreddingIntermediate(idx_t count); idx_t Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, idx_t scan_count) override; idx_t ScanCount(ColumnScanState &state, Vector &result, idx_t count, idx_t result_offset = 0) override; @@ -57,7 +56,8 @@ class VariantColumnData : public ColumnData { unique_ptr CreateCheckpointState(const RowGroup &row_group, PartialBlockManager &partial_block_manager) override; - unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) override; + unique_ptr Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) override; bool IsPersistent() override; bool HasAnyChanges() const override; @@ -76,9 +76,14 @@ class VariantColumnData : public ColumnData { void SetChildData(vector> child_data); private: + Vector CreateUnshreddingIntermediate(idx_t count) const; vector> WriteShreddedData(const RowGroup &row_group, const LogicalType &shredded_type, BaseStatistics &stats); + bool PushdownShreddedFieldExtract(const StorageIndex &variant_extract, StorageIndex &out_struct_extract) const; void CreateScanStates(ColumnScanState &state); + idx_t ScanWithCallback(ColumnScanState &state, Vector &result, idx_t target_count, + const std::function &callback) const; LogicalType GetShreddedType(); }; diff --git a/src/duckdb/src/include/duckdb_extension.h b/src/duckdb/src/include/duckdb_extension.h index c023bd8a1..63a809001 100644 --- a/src/duckdb/src/include/duckdb_extension.h +++ b/src/duckdb/src/include/duckdb_extension.h @@ -1416,9 +1416,9 @@ typedef struct { DUCKDB_EXTENSION_EXTERN_C_GUARD_OPEN DUCKDB_CAPI_ENTRY_VISIBILITY DUCKDB_EXTENSION_API bool DUCKDB_EXTENSION_GLUE( \ DUCKDB_EXTENSION_NAME, _init_c_api)(duckdb_extension_info info, struct duckdb_extension_access * access) { \ DUCKDB_EXTENSION_API_INIT(info, access, DUCKDB_EXTENSION_API_VERSION_STRING); \ - duckdb_database db = access->get_database(info); \ + duckdb_database *db = access->get_database(info); \ duckdb_connection conn; \ - if (duckdb_connect(db, &conn) == DuckDBError) { \ + if (duckdb_connect(*db, &conn) == DuckDBError) { \ access->set_error(info, "Failed to open connection to database"); \ return false; \ } \ diff --git a/src/duckdb/src/logging/logging.cpp b/src/duckdb/src/logging/logging.cpp index b0a614627..4585c8d7b 100644 --- a/src/duckdb/src/logging/logging.cpp +++ b/src/duckdb/src/logging/logging.cpp @@ -20,17 +20,6 @@ bool LogConfig::IsConsistent() const { return false; } -LogConfig LogConfig::Create(bool enabled, LogLevel level) { - return LogConfig(enabled, level, LogMode::LEVEL_ONLY, nullptr, nullptr); -} -LogConfig LogConfig::CreateFromEnabled(bool enabled, LogLevel level, unordered_set &enabled_log_types) { - return LogConfig(enabled, level, LogMode::ENABLE_SELECTED, enabled_log_types, nullptr); -} - -LogConfig LogConfig::CreateFromDisabled(bool enabled, LogLevel level, unordered_set &disabled_log_types) { - return LogConfig(enabled, level, LogMode::DISABLE_SELECTED, nullptr, disabled_log_types); -} - LogConfig::LogConfig(bool enabled, LogLevel level_p, LogMode mode_p, optional_ptr> enabled_log_types_p, optional_ptr> disabled_log_types_p) diff --git a/src/duckdb/src/main/appender.cpp b/src/duckdb/src/main/appender.cpp index 858011efe..b46e9fff4 100644 --- a/src/duckdb/src/main/appender.cpp +++ b/src/duckdb/src/main/appender.cpp @@ -15,6 +15,16 @@ #include "duckdb/planner/expression_binder/constant_binder.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" #include "duckdb/execution/expression_executor.hpp" +#include "duckdb/parser/tableref/column_data_ref.hpp" +#include "duckdb/parser/parser.hpp" +#include "duckdb/parser/statement/insert_statement.hpp" +#include "duckdb/parser/statement/delete_statement.hpp" +#include "duckdb/parser/statement/update_statement.hpp" +#include "duckdb/parser/statement/merge_into_statement.hpp" +#include "duckdb/parser/query_node/select_node.hpp" +#include "duckdb/parser/expression/parameter_expression.hpp" +#include "duckdb/parser/tableref/expressionlistref.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { @@ -423,6 +433,64 @@ void BaseAppender::ClearColumns() { throw NotImplementedException("ClearColumns is only supported when directly appending to a table"); } +unique_ptr BaseAppender::GetColumnDataTableRef(ColumnDataCollection &collection, const string &table_name, + const vector &expected_names) { + auto column_data_ref = make_uniq(collection); + column_data_ref->alias = table_name.empty() ? "appended_data" : table_name; + ; + column_data_ref->expected_names = expected_names; + return std::move(column_data_ref); +} + +CommonTableExpressionMap &GetCTEMap(SQLStatement &statement) { + switch (statement.type) { + case StatementType::INSERT_STATEMENT: + return statement.Cast().cte_map; + case StatementType::DELETE_STATEMENT: + return statement.Cast().cte_map; + case StatementType::UPDATE_STATEMENT: + return statement.Cast().cte_map; + case StatementType::MERGE_INTO_STATEMENT: + return statement.Cast().cte_map; + default: + throw InvalidInputException( + "Unsupported statement type for appender: expected INSERT, DELETE, UPDATE or MERGE INTO"); + } +} + +unique_ptr BaseAppender::ParseStatement(unique_ptr table_ref, const string &query, + const string &table_name) { + // Parse the query. + Parser parser; + parser.ParseQuery(query); + + // Must be a single statement. + if (parser.statements.size() != 1) { + throw InvalidInputException("Expected exactly one query for appending data."); + } + + // Create the CTE for the appender. + auto cte = make_uniq(); + cte->select_list.push_back(make_uniq()); + cte->from_table = std::move(table_ref); + + // Create the SELECT CTE. + auto cte_select = make_uniq(); + cte_select->node = std::move(cte); + + // Create the CTE info. + auto cte_info = make_uniq(); + cte_info->query = std::move(cte_select); + cte_info->materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER; + + // Add the appender data as a CTE to the CTE map of the statement. + string alias = table_name.empty() ? "appended_data" : table_name; + auto &cte_map = GetCTEMap(*parser.statements[0]); + cte_map.map.insert(alias, std::move(cte_info)); + + return std::move(parser.statements[0]); +} + //===--------------------------------------------------------------------===// // Table Appender //===--------------------------------------------------------------------===// @@ -501,12 +569,53 @@ Appender::~Appender() { Destructor(); } +vector Appender::GetExpectedNames() { + vector expected_names; + for (idx_t i = 0; i < column_ids.size(); i++) { + auto &col_name = description->columns[column_ids[i].index].Name(); + expected_names.push_back(col_name); + } + return expected_names; +} + +string Appender::ConstructQuery(TableDescription &description_p, const string &table_name, + const vector &expected_names) { + string query = "INSERT INTO "; + if (!description_p.database.empty()) { + query += StringUtil::Format("%s.", SQLIdentifier(description_p.database)); + } + if (!description_p.schema.empty()) { + query += StringUtil::Format("%s.", SQLIdentifier(description_p.schema)); + } + query += StringUtil::Format("%s", SQLIdentifier(description_p.table)); + if (!expected_names.empty()) { + query += "("; + for (idx_t i = 0; i < expected_names.size(); i++) { + if (i > 0) { + query += ", "; + } + query += StringUtil::Format("%s", SQLIdentifier(expected_names[i])); + } + query += ")"; + } + query += " FROM "; + query += table_name; + return query; +} + void Appender::FlushInternal(ColumnDataCollection &collection) { auto context_ref = context.lock(); if (!context_ref) { throw InvalidInputException("Appender: Attempting to flush data to a closed connection"); } - context_ref->Append(*description, collection, &column_ids); + + string table_name = "__duckdb_internal_appended_data"; + auto expected_names = GetExpectedNames(); + auto query = ConstructQuery(*description, table_name, expected_names); + + auto table_ref = GetColumnDataTableRef(collection, table_name, expected_names); + auto stmt = ParseStatement(std::move(table_ref), query, table_name); + context_ref->Append(std::move(stmt)); } void Appender::AppendDefault() { @@ -603,9 +712,11 @@ QueryAppender::~QueryAppender() { void QueryAppender::FlushInternal(ColumnDataCollection &collection) { auto context_ref = context.lock(); if (!context_ref) { - throw InvalidInputException("Appender: Attempting to flush data to a closed connection"); + throw InvalidInputException("Attempting to flush query appender data on a closed connection"); } - context_ref->Append(collection, query, names, table_name); + auto table_ref = GetColumnDataTableRef(collection, table_name, names); + auto parsed_statement = ParseStatement(std::move(table_ref), query, table_name); + context_ref->Append(std::move(parsed_statement)); } //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/main/attached_database.cpp b/src/duckdb/src/main/attached_database.cpp index 3a2ce8896..98a453a33 100644 --- a/src/duckdb/src/main/attached_database.cpp +++ b/src/duckdb/src/main/attached_database.cpp @@ -87,7 +87,7 @@ AttachOptions::AttachOptions(const unordered_map &attach_options, AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type) : CatalogEntry(CatalogType::DATABASE_ENTRY, type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG, 0), - db(db), type(type) { + db(db), type(type), close_lock(make_shared_ptr()) { // This database does not have storage, or uses temporary_objects for in-memory storage. D_ASSERT(type == AttachedDatabaseType::TEMP_DATABASE || type == AttachedDatabaseType::SYSTEM_DATABASE); if (type == AttachedDatabaseType::TEMP_DATABASE) { @@ -104,7 +104,7 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType ty AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, string name_p, string file_path_p, AttachOptions &options) : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p), - attach_options(options.options) { + close_lock(make_shared_ptr()), attach_options(options.options) { if (options.access_mode == AccessMode::READ_ONLY) { type = AttachedDatabaseType::READ_ONLY_DATABASE; } else { @@ -124,7 +124,7 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, StorageExtension &storage_extension_p, ClientContext &context, string name_p, AttachInfo &info, AttachOptions &options) : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db), parent_catalog(&catalog_p), - storage_extension(&storage_extension_p), attach_options(options.options) { + storage_extension(&storage_extension_p), close_lock(make_shared_ptr()), attach_options(options.options) { if (options.access_mode == AccessMode::READ_ONLY) { type = AttachedDatabaseType::READ_ONLY_DATABASE; } else { @@ -199,11 +199,10 @@ string AttachedDatabase::ExtractDatabaseName(const string &dbpath, FileSystem &f } void AttachedDatabase::InvokeCloseIfLastReference(shared_ptr &attached_db) { - { - lock_guard guard(attached_db->close_lock); - if (attached_db.use_count() == 1) { - attached_db->Close(DatabaseCloseAction::CHECKPOINT); - } + auto close_lock = attached_db->close_lock; + lock_guard guard(*close_lock); + if (attached_db.use_count() == 1) { + attached_db->Close(DatabaseCloseAction::CHECKPOINT); } attached_db.reset(); } diff --git a/src/duckdb/src/main/client_context.cpp b/src/duckdb/src/main/client_context.cpp index 998cb9772..f237294ed 100644 --- a/src/duckdb/src/main/client_context.cpp +++ b/src/duckdb/src/main/client_context.cpp @@ -183,7 +183,7 @@ void ClientContext::Destroy() { void ClientContext::ProcessError(ErrorData &error, const string &query) const { error.FinalizeError(); - if (config.errors_as_json) { + if (Settings::Get(*this)) { error.ConvertErrorToJSON(); } else { error.AddErrorLocation(query); @@ -720,8 +720,10 @@ unique_ptr ClientContext::PrepareInternal(ClientContextLock & unique_ptr ClientContext::Prepare(unique_ptr statement) { auto lock = LockContext(); - // prepare the query + // Store the query in case of an error. auto query = statement->query; + + // Try to prepare. try { InitialCleanup(*lock); return PrepareInternal(*lock, std::move(statement)); @@ -1170,6 +1172,7 @@ void ClientContext::RunFunctionInTransactionInternal(ClientContextLock &lock, co if (require_new_transaction) { D_ASSERT(!active_query); transaction.BeginTransaction(); + interrupted = false; } try { fun(); @@ -1225,86 +1228,20 @@ unique_ptr ClientContext::TableInfo(const string &schema_name, return TableInfo(INVALID_CATALOG, schema_name, table_name); } -CommonTableExpressionMap &GetCTEMap(SQLStatement &statement) { - switch (statement.type) { - case StatementType::INSERT_STATEMENT: - return statement.Cast().cte_map; - case StatementType::DELETE_STATEMENT: - return statement.Cast().cte_map; - case StatementType::UPDATE_STATEMENT: - return statement.Cast().cte_map; - case StatementType::MERGE_INTO_STATEMENT: - return statement.Cast().cte_map; - default: - throw InvalidInputException( - "Unsupported statement type for appender: expected INSERT, DELETE, UPDATE or MERGE INTO"); - } -} - -void ClientContext::Append(ColumnDataCollection &collection, const string &query, const vector &column_names, - const string &collection_name) { - // create the CTE for the appender - string alias = collection_name.empty() ? "appended_data" : collection_name; - auto column_data_ref = make_uniq(collection); - column_data_ref->alias = alias; - column_data_ref->expected_names = column_names; - auto cte = make_uniq(); - cte->select_list.push_back(make_uniq()); - cte->from_table = std::move(column_data_ref); - auto cte_select = make_uniq(); - cte_select->node = std::move(cte); - - // parse the query - Parser parser; - parser.ParseQuery(query); - - // must be a single statement with CTEs - if (parser.statements.size() != 1) { - throw InvalidInputException("Expected exactly 1 query for appending data"); - } - - // add the appender data as a CTE to the cte map - auto &cte_map = GetCTEMap(*parser.statements[0]); - auto cte_info = make_uniq(); - cte_info->query = std::move(cte_select); - cte_info->materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER; - - cte_map.map.insert(alias, std::move(cte_info)); - - // now we have the query - run it in a transaction - auto result = Query(std::move(parser.statements[0]), false); +void ClientContext::Append(unique_ptr stmt) { + auto result = Query(std::move(stmt), false); if (result->HasError()) { result->GetErrorObject().Throw("Failed to append: "); } } -void ClientContext::Append(TableDescription &description, ColumnDataCollection &collection, - optional_ptr> column_ids) { +void ClientContext::Append(TableDescription &description, ColumnDataCollection &collection) { string table_name = "__duckdb_internal_appended_data"; - string query = "INSERT INTO "; - if (!description.database.empty()) { - query += StringUtil::Format("%s.", SQLIdentifier(description.database)); - } - if (!description.schema.empty()) { - query += StringUtil::Format("%s.", SQLIdentifier(description.schema)); - } - query += StringUtil::Format("%s", SQLIdentifier(description.table)); - if (column_ids && !column_ids->empty()) { - query += "("; - auto &ids = *column_ids; - for (idx_t i = 0; i < ids.size(); i++) { - if (i > 0) { - query += ", "; - } - auto &col_name = description.columns[ids[i].index].Name(); - query += StringUtil::Format("%s", SQLIdentifier(col_name)); - } - query += ")"; - } - query += " FROM "; - query += table_name; - vector column_names; - Append(collection, query, column_names, table_name); + vector expected_names; + auto query = Appender::ConstructQuery(description, table_name, expected_names); + auto table_ref = BaseAppender::GetColumnDataTableRef(collection, table_name, expected_names); + auto stmt = BaseAppender::ParseStatement(std::move(table_ref), query, table_name); + Append(std::move(stmt)); } void ClientContext::InternalTryBindRelation(Relation &relation, vector &result_columns) { @@ -1424,43 +1361,40 @@ unique_ptr ClientContext::Execute(const shared_ptr &relat return ErrorResult(ErrorData(err_str)); } -SettingLookupResult ClientContext::TryGetCurrentSettingInternal(const string &key, Value &result) const { - // check the client session values - const auto &session_config_map = config.set_variables; - - auto session_value = session_config_map.find(key); - bool found_session_value = session_value != session_config_map.end(); - if (found_session_value) { - result = session_value->second; +SettingLookupResult ClientContext::TryGetCurrentSetting(const string &key, Value &result) const { + optional_ptr option; + // try to get the setting index + auto &db_config = DBConfig::GetConfig(*this); + auto setting_index = db_config.TryGetSettingIndex(key, option); + if (setting_index.IsValid()) { + // generic setting - try to fetch it + auto lookup_result = + config.user_settings.TryGetSetting(db_config.user_settings, setting_index.GetIndex(), result); + if (lookup_result) { + return lookup_result; + } + } + if (option && option->get_setting) { + // legacy callback + result = option->get_setting(*this); return SettingLookupResult(SettingScope::LOCAL); } - // finally check the global session values - return db->TryGetCurrentSetting(key, result); + // setting is not set - get the default value + return DBConfig::TryGetDefaultValue(option, result); } -SettingLookupResult ClientContext::TryGetCurrentSetting(const string &key, Value &result) const { - // first check the built-in settings +SettingLookupResult ClientContext::TryGetCurrentUserSetting(idx_t setting_index, Value &result) const { auto &db_config = DBConfig::GetConfig(*this); - auto option = db_config.GetOptionByName(key); - if (option) { - if (option->get_setting) { - result = option->get_setting(*this); - return SettingLookupResult(SettingScope::LOCAL); - } - // alias - search for the default key - return TryGetCurrentSettingInternal(option->name, result); - } - return TryGetCurrentSettingInternal(key, result); + return config.user_settings.TryGetSetting(db_config.user_settings, setting_index, result); } ParserOptions ClientContext::GetParserOptions() const { - auto &client_config = ClientConfig::GetConfig(*this); ParserOptions options; - options.preserve_identifier_case = DBConfig::GetSetting(*this); - options.integer_division = DBConfig::GetSetting(*this); - options.max_expression_depth = client_config.max_expression_depth; - options.extensions = &DBConfig::GetConfig(*this).parser_extensions; - options.parser_override_setting = DBConfig::GetConfig(*this).options.allow_parser_override_extension; + options.preserve_identifier_case = Settings::Get(*this); + options.integer_division = Settings::Get(*this); + options.max_expression_depth = Settings::Get(*this); + options.extensions = DBConfig::GetConfig(*this).GetCallbackManager(); + options.parser_override_setting = Settings::Get(*this); return options; } @@ -1472,13 +1406,13 @@ ClientProperties ClientContext::GetClientProperties() { timezone = result.ToString(); } ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR; - if (DBConfig::GetSetting(*this)) { + if (Settings::Get(*this)) { arrow_offset_size = ArrowOffsetSize::LARGE; } - bool arrow_use_list_view = DBConfig::GetSetting(*this); - bool arrow_lossless_conversion = DBConfig::GetSetting(*this); - bool arrow_use_string_view = DBConfig::GetSetting(*this); - auto arrow_format_version = DBConfig::GetSetting(*this); + bool arrow_use_list_view = Settings::Get(*this); + bool arrow_lossless_conversion = Settings::Get(*this); + bool arrow_use_string_view = Settings::Get(*this); + auto arrow_format_version = Settings::Get(*this); return {timezone, arrow_offset_size, arrow_use_list_view, @@ -1495,4 +1429,12 @@ bool ClientContext::ExecutionIsFinished() { return active_query->executor->ExecutionIsFinished(); } +LogicalType ClientContext::ParseLogicalType(const string &type) { + auto lock = LockContext(); + LogicalType logical_type; + RunFunctionInTransactionInternal(*lock, + [&]() { logical_type = TypeManager::Get(*db).ParseLogicalType(type, *this); }); + return logical_type; +} + } // namespace duckdb diff --git a/src/duckdb/src/main/config.cpp b/src/duckdb/src/main/config.cpp index b632a4987..2477b4c25 100644 --- a/src/duckdb/src/main/config.cpp +++ b/src/duckdb/src/main/config.cpp @@ -5,6 +5,7 @@ #include "duckdb/common/operator/cast_operators.hpp" #include "duckdb/common/operator/multiply.hpp" #include "duckdb/common/string_util.hpp" +#include "duckdb/main/database.hpp" #include "duckdb/main/settings.hpp" #include "duckdb/storage/storage_extension.hpp" #include "duckdb/common/serializer/serializer.hpp" @@ -26,30 +27,34 @@ bool DBConfigOptions::debug_print_bindings = false; #define DUCKDB_SETTING(_PARAM) \ { \ _PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, nullptr, nullptr, nullptr, nullptr, \ - _PARAM::DefaultScope, _PARAM::DefaultValue, nullptr \ + _PARAM::Scope, _PARAM::DefaultValue, nullptr, _PARAM::SettingIndex \ } #define DUCKDB_SETTING_CALLBACK(_PARAM) \ { \ _PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, nullptr, nullptr, nullptr, nullptr, \ - _PARAM::DefaultScope, _PARAM::DefaultValue, _PARAM::OnSet \ + _PARAM::Scope, _PARAM::DefaultValue, _PARAM::OnSet, _PARAM::SettingIndex \ } #define DUCKDB_GLOBAL(_PARAM) \ { \ _PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, nullptr, _PARAM::ResetGlobal, \ - nullptr, _PARAM::GetSetting, SetScope::AUTOMATIC, nullptr, nullptr \ + nullptr, _PARAM::GetSetting, SettingScopeTarget::INVALID, nullptr, nullptr, optional_idx() \ } #define DUCKDB_LOCAL(_PARAM) \ { \ _PARAM::Name, _PARAM::Description, _PARAM::InputType, nullptr, _PARAM::SetLocal, nullptr, _PARAM::ResetLocal, \ - _PARAM::GetSetting, SetScope::AUTOMATIC, nullptr, nullptr \ + _PARAM::GetSetting, SettingScopeTarget::INVALID, nullptr, nullptr, optional_idx() \ } #define DUCKDB_GLOBAL_LOCAL(_PARAM) \ { \ _PARAM::Name, _PARAM::Description, _PARAM::InputType, _PARAM::SetGlobal, _PARAM::SetLocal, \ - _PARAM::ResetGlobal, _PARAM::ResetLocal, _PARAM::GetSetting, SetScope::AUTOMATIC, nullptr, nullptr \ + _PARAM::ResetGlobal, _PARAM::ResetLocal, _PARAM::GetSetting, SettingScopeTarget::INVALID, nullptr, \ + nullptr, optional_idx() \ } #define FINAL_SETTING \ - { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, SetScope::AUTOMATIC, nullptr, nullptr } + { \ + nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, SettingScopeTarget::INVALID, nullptr, \ + nullptr, optional_idx() \ + } #define DUCKDB_SETTING_ALIAS(_ALIAS, _SETTING_INDEX) \ { _ALIAS, _SETTING_INDEX } @@ -59,15 +64,15 @@ bool DBConfigOptions::debug_print_bindings = false; static const ConfigurationOption internal_options[] = { DUCKDB_GLOBAL(AccessModeSetting), - DUCKDB_GLOBAL(AllocatorBackgroundThreadsSetting), + DUCKDB_SETTING_CALLBACK(AllocatorBackgroundThreadsSetting), DUCKDB_GLOBAL(AllocatorBulkDeallocationFlushThresholdSetting), DUCKDB_GLOBAL(AllocatorFlushThresholdSetting), - DUCKDB_GLOBAL(AllowCommunityExtensionsSetting), + DUCKDB_SETTING_CALLBACK(AllowCommunityExtensionsSetting), DUCKDB_SETTING(AllowExtensionsMetadataMismatchSetting), - DUCKDB_GLOBAL(AllowParserOverrideExtensionSetting), + DUCKDB_SETTING_CALLBACK(AllowParserOverrideExtensionSetting), DUCKDB_GLOBAL(AllowPersistentSecretsSetting), - DUCKDB_GLOBAL(AllowUnredactedSecretsSetting), - DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting), + DUCKDB_SETTING_CALLBACK(AllowUnredactedSecretsSetting), + DUCKDB_SETTING_CALLBACK(AllowUnsignedExtensionsSetting), DUCKDB_GLOBAL(AllowedDirectoriesSetting), DUCKDB_GLOBAL(AllowedPathsSetting), DUCKDB_SETTING(ArrowLargeBufferSizeSetting), @@ -75,13 +80,13 @@ static const ConfigurationOption internal_options[] = { DUCKDB_SETTING(ArrowOutputListViewSetting), DUCKDB_SETTING_CALLBACK(ArrowOutputVersionSetting), DUCKDB_SETTING(AsofLoopJoinThresholdSetting), - DUCKDB_GLOBAL(AutoinstallExtensionRepositorySetting), - DUCKDB_GLOBAL(AutoinstallKnownExtensionsSetting), - DUCKDB_GLOBAL(AutoloadKnownExtensionsSetting), + DUCKDB_SETTING(AutoinstallExtensionRepositorySetting), + DUCKDB_SETTING(AutoinstallKnownExtensionsSetting), + DUCKDB_SETTING(AutoloadKnownExtensionsSetting), DUCKDB_GLOBAL(BlockAllocatorMemorySetting), DUCKDB_SETTING(CatalogErrorMaxSchemasSetting), DUCKDB_GLOBAL(CheckpointThresholdSetting), - DUCKDB_GLOBAL(CustomExtensionRepositorySetting), + DUCKDB_SETTING(CustomExtensionRepositorySetting), DUCKDB_LOCAL(CustomProfilingSettingsSetting), DUCKDB_GLOBAL(CustomUserAgentSetting), DUCKDB_SETTING(DebugAsofIejoinSetting), @@ -94,24 +99,24 @@ static const ConfigurationOption internal_options[] = { DUCKDB_SETTING(DebugVerifyBlocksSetting), DUCKDB_SETTING_CALLBACK(DebugVerifyVectorSetting), DUCKDB_SETTING_CALLBACK(DebugWindowModeSetting), - DUCKDB_GLOBAL(DefaultBlockSizeSetting), + DUCKDB_SETTING_CALLBACK(DefaultBlockSizeSetting), DUCKDB_SETTING_CALLBACK(DefaultCollationSetting), DUCKDB_SETTING_CALLBACK(DefaultNullOrderSetting), DUCKDB_SETTING_CALLBACK(DefaultOrderSetting), DUCKDB_GLOBAL(DefaultSecretStorageSetting), - DUCKDB_GLOBAL(DisableDatabaseInvalidationSetting), + DUCKDB_SETTING_CALLBACK(DisableDatabaseInvalidationSetting), DUCKDB_SETTING(DisableTimestamptzCastsSetting), DUCKDB_GLOBAL(DisabledCompressionMethodsSetting), DUCKDB_GLOBAL(DisabledFilesystemsSetting), DUCKDB_GLOBAL(DisabledLogTypes), DUCKDB_GLOBAL(DisabledOptimizersSetting), - DUCKDB_GLOBAL(DuckDBAPISetting), + DUCKDB_SETTING_CALLBACK(DuckDBAPISetting), DUCKDB_SETTING(DynamicOrFilterThresholdSetting), - DUCKDB_GLOBAL(EnableExternalAccessSetting), - DUCKDB_GLOBAL(EnableExternalFileCacheSetting), + DUCKDB_SETTING_CALLBACK(EnableExternalAccessSetting), + DUCKDB_SETTING_CALLBACK(EnableExternalFileCacheSetting), DUCKDB_SETTING(EnableFSSTVectorsSetting), DUCKDB_LOCAL(EnableHTTPLoggingSetting), - DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting), + DUCKDB_SETTING(EnableHTTPMetadataCacheSetting), DUCKDB_GLOBAL(EnableLogging), DUCKDB_SETTING(EnableMacroDependenciesSetting), DUCKDB_SETTING(EnableObjectCacheSetting), @@ -120,34 +125,35 @@ static const ConfigurationOption internal_options[] = { DUCKDB_LOCAL(EnableProgressBarPrintSetting), DUCKDB_SETTING(EnableViewDependenciesSetting), DUCKDB_GLOBAL(EnabledLogTypes), - DUCKDB_LOCAL(ErrorsAsJSONSetting), + DUCKDB_SETTING(ErrorsAsJSONSetting), DUCKDB_SETTING(ExperimentalMetadataReuseSetting), - DUCKDB_LOCAL(ExplainOutputSetting), + DUCKDB_SETTING_CALLBACK(ExplainOutputSetting), DUCKDB_GLOBAL(ExtensionDirectoriesSetting), - DUCKDB_GLOBAL(ExtensionDirectorySetting), - DUCKDB_GLOBAL(ExternalThreadsSetting), - DUCKDB_LOCAL(FileSearchPathSetting), - DUCKDB_GLOBAL(ForceBitpackingModeSetting), - DUCKDB_GLOBAL(ForceCompressionSetting), + DUCKDB_SETTING(ExtensionDirectorySetting), + DUCKDB_SETTING_CALLBACK(ExternalThreadsSetting), + DUCKDB_SETTING(FileSearchPathSetting), + DUCKDB_SETTING_CALLBACK(ForceBitpackingModeSetting), + DUCKDB_SETTING_CALLBACK(ForceCompressionSetting), DUCKDB_GLOBAL(ForceVariantShredding), - DUCKDB_LOCAL(HomeDirectorySetting), + DUCKDB_SETTING(GeometryMinimumShreddingSize), + DUCKDB_SETTING_CALLBACK(HomeDirectorySetting), DUCKDB_LOCAL(HTTPLoggingOutputSetting), - DUCKDB_GLOBAL(HTTPProxySetting), - DUCKDB_GLOBAL(HTTPProxyPasswordSetting), - DUCKDB_GLOBAL(HTTPProxyUsernameSetting), + DUCKDB_SETTING(HTTPProxySetting), + DUCKDB_SETTING(HTTPProxyPasswordSetting), + DUCKDB_SETTING(HTTPProxyUsernameSetting), DUCKDB_SETTING(IeeeFloatingPointOpsSetting), DUCKDB_SETTING(ImmediateTransactionModeSetting), DUCKDB_SETTING(IndexScanMaxCountSetting), DUCKDB_SETTING_CALLBACK(IndexScanPercentageSetting), DUCKDB_SETTING(IntegerDivisionSetting), - DUCKDB_LOCAL(LambdaSyntaxSetting), + DUCKDB_SETTING_CALLBACK(LambdaSyntaxSetting), DUCKDB_SETTING(LateMaterializationMaxRowsSetting), - DUCKDB_GLOBAL(LockConfigurationSetting), - DUCKDB_LOCAL(LogQueryPathSetting), + DUCKDB_SETTING(LockConfigurationSetting), + DUCKDB_SETTING_CALLBACK(LogQueryPathSetting), DUCKDB_GLOBAL(LoggingLevel), DUCKDB_GLOBAL(LoggingMode), DUCKDB_GLOBAL(LoggingStorage), - DUCKDB_LOCAL(MaxExpressionDepthSetting), + DUCKDB_SETTING(MaxExpressionDepthSetting), DUCKDB_GLOBAL(MaxMemorySetting), DUCKDB_GLOBAL(MaxTempDirectorySizeSetting), DUCKDB_SETTING(MaxVacuumTasksSetting), @@ -158,9 +164,9 @@ static const ConfigurationOption internal_options[] = { DUCKDB_SETTING_CALLBACK(OrderedAggregateThresholdSetting), DUCKDB_SETTING(PartitionedWriteFlushThresholdSetting), DUCKDB_SETTING(PartitionedWriteMaxOpenFilesSetting), - DUCKDB_GLOBAL(PasswordSetting), + DUCKDB_SETTING(PasswordSetting), DUCKDB_SETTING_CALLBACK(PerfectHtThresholdSetting), - DUCKDB_GLOBAL(PinThreadsSetting), + DUCKDB_SETTING_CALLBACK(PinThreadsSetting), DUCKDB_SETTING(PivotFilterThresholdSetting), DUCKDB_SETTING(PivotLimitSetting), DUCKDB_SETTING(PreferRangeJoinsSetting), @@ -172,7 +178,7 @@ static const ConfigurationOption internal_options[] = { DUCKDB_LOCAL(ProfilingModeSetting), DUCKDB_LOCAL(ProgressBarTimeSetting), DUCKDB_SETTING(ScalarSubqueryErrorOnMultipleRowsSetting), - DUCKDB_GLOBAL(SchedulerProcessPartialSetting), + DUCKDB_SETTING(SchedulerProcessPartialSetting), DUCKDB_LOCAL(SchemaSetting), DUCKDB_LOCAL(SearchPathSetting), DUCKDB_GLOBAL(SecretDirectorySetting), @@ -180,21 +186,21 @@ static const ConfigurationOption internal_options[] = { DUCKDB_GLOBAL(StorageCompatibilityVersionSetting), DUCKDB_LOCAL(StreamingBufferSizeSetting), DUCKDB_GLOBAL(TempDirectorySetting), - DUCKDB_GLOBAL(TempFileEncryptionSetting), + DUCKDB_SETTING_CALLBACK(TempFileEncryptionSetting), DUCKDB_GLOBAL(ThreadsSetting), - DUCKDB_GLOBAL(UsernameSetting), + DUCKDB_SETTING(UsernameSetting), DUCKDB_SETTING_CALLBACK(ValidateExternalFileCacheSetting), - DUCKDB_GLOBAL(VariantMinimumShreddingSize), + DUCKDB_SETTING(VariantMinimumShreddingSizeSetting), DUCKDB_SETTING(WriteBufferRowGroupCountSetting), - DUCKDB_GLOBAL(ZstdMinStringLengthSetting), + DUCKDB_SETTING(ZstdMinStringLengthSetting), FINAL_SETTING}; -static const ConfigurationAlias setting_aliases[] = {DUCKDB_SETTING_ALIAS("memory_limit", 90), +static const ConfigurationAlias setting_aliases[] = {DUCKDB_SETTING_ALIAS("memory_limit", 91), DUCKDB_SETTING_ALIAS("null_order", 38), - DUCKDB_SETTING_ALIAS("profiling_output", 109), - DUCKDB_SETTING_ALIAS("user", 124), + DUCKDB_SETTING_ALIAS("profiling_output", 110), + DUCKDB_SETTING_ALIAS("user", 125), DUCKDB_SETTING_ALIAS("wal_autocheckpoint", 22), - DUCKDB_SETTING_ALIAS("worker_threads", 123), + DUCKDB_SETTING_ALIAS("worker_threads", 124), FINAL_ALIAS}; vector DBConfig::GetOptions() { @@ -286,10 +292,10 @@ void DBConfig::SetOptionByName(const string &name, const Value &value) { return; } - auto param = extension_parameters.find(name); - if (param != extension_parameters.end()) { - Value target_value = value.DefaultCastAs(param->second.type); - SetOption(name, std::move(target_value)); + ExtensionOption extension_option; + if (TryGetExtensionOption(name, extension_option)) { + Value target_value = value.DefaultCastAs(extension_option.type); + SetOption(extension_option.setting_index.GetIndex(), std::move(target_value)); } else { options.unrecognized_options[name] = value; } @@ -304,7 +310,6 @@ void DBConfig::SetOptionsByName(const case_insensitive_map_t &values) { } void DBConfig::SetOption(optional_ptr db, const ConfigurationOption &option, const Value &value) { - lock_guard l(config_lock); Value input = value.DefaultCastAs(ParseLogicalType(option.parameter_type)); if (option.default_value) { // generic option @@ -312,52 +317,58 @@ void DBConfig::SetOption(optional_ptr db, const ConfigurationO SettingCallbackInfo info(*this, db); option.set_callback(info, input); } - options.set_variables.emplace(option.name, std::move(input)); + user_settings.SetUserSetting(option.setting_idx.GetIndex(), std::move(input)); return; } if (!option.set_global) { throw InvalidInputException("Could not set option \"%s\" as a global option", option.name); } + lock_guard guard(config_lock); D_ASSERT(option.reset_global); option.set_global(db.get(), *this, input); } void DBConfig::ResetOption(optional_ptr db, const ConfigurationOption &option) { - lock_guard l(config_lock); if (option.default_value) { // generic option - options.set_variables.erase(option.name); + user_settings.ClearSetting(option.setting_idx.GetIndex()); return; } if (!option.reset_global) { throw InternalException("Could not reset option \"%s\" as a global option", option.name); } + lock_guard guard(config_lock); D_ASSERT(option.set_global); option.reset_global(db.get(), *this); } -void DBConfig::SetOption(const String &name, Value value) { - lock_guard l(config_lock); - options.set_variables[name.ToStdString()] = std::move(value); +void DBConfig::SetOption(idx_t setting_index, Value value) { + user_settings.SetUserSetting(setting_index, std::move(value)); +} + +void DBConfig::SetOption(const string &name, Value value) { + optional_ptr option; + auto setting_index = TryGetSettingIndex(name, option); + if (!setting_index.IsValid()) { + throw InternalException("Unrecognized option %s in DBConfig::SetOption", name); + } + SetOption(setting_index.GetIndex(), std::move(value)); } -void DBConfig::ResetOption(const String &name) { - lock_guard l(config_lock); - auto extension_option = extension_parameters.find(name.ToStdString()); - D_ASSERT(extension_option != extension_parameters.end()); - auto &default_value = extension_option->second.default_value; +void DBConfig::ResetOption(const ExtensionOption &extension_option) { + auto &default_value = extension_option.default_value; + auto setting_index = extension_option.setting_index.GetIndex(); if (!default_value.IsNull()) { // Default is not NULL, override the setting - options.set_variables[name.ToStdString()] = default_value; + user_settings.SetUserSetting(setting_index, default_value); } else { // Otherwise just remove it from the 'set_variables' map - options.set_variables.erase(name.ToStdString()); + user_settings.ClearSetting(setting_index); } } -void DBConfig::ResetGenericOption(const String &name) { - lock_guard l(config_lock); - options.set_variables.erase(name.ToStdString()); +void DBConfig::ResetGenericOption(idx_t setting_index) { + user_settings.ClearSetting(setting_index); } LogicalType DBConfig::ParseLogicalType(const string &type) { @@ -442,36 +453,43 @@ LogicalType DBConfig::ParseLogicalType(const string &type) { return LogicalType::STRUCT(struct_members); } - LogicalType type_id = StringUtil::CIEquals(type, "ANY") ? LogicalType::ANY : TransformStringToLogicalTypeId(type); - if (type_id == LogicalTypeId::USER) { + const auto type_id = StringUtil::CIEquals(type, "ANY") ? LogicalTypeId::ANY : TransformStringToLogicalTypeId(type); + if (type_id == LogicalTypeId::UNBOUND) { throw InternalException("Error while generating extension function overloads - unrecognized logical type %s", type); } return type_id; } -bool DBConfig::HasExtensionOption(const string &name) { - lock_guard l(config_lock); - return extension_parameters.find(name) != extension_parameters.end(); +bool DBConfig::HasExtensionOption(const string &name) const { + return user_settings.HasExtensionOption(name); +} + +bool DBConfig::TryGetExtensionOption(const String &name, ExtensionOption &result) const { + return user_settings.TryGetExtensionOption(name, result); } void DBConfig::AddExtensionOption(const string &name, string description, LogicalType parameter, const Value &default_value, set_option_callback_t function, SetScope default_scope) { - lock_guard l(config_lock); - extension_parameters.insert(make_pair( - name, ExtensionOption(std::move(description), std::move(parameter), function, default_value, default_scope))); + ExtensionOption extension_option(std::move(description), std::move(parameter), function, default_value, + default_scope); + auto setting_index = user_settings.AddExtensionOption(name, std::move(extension_option)); // copy over unrecognized options, if they match the new extension option auto iter = options.unrecognized_options.find(name); if (iter != options.unrecognized_options.end()) { - options.set_variables[name] = iter->second; + user_settings.SetUserSetting(setting_index, iter->second); options.unrecognized_options.erase(iter); } - if (!default_value.IsNull() && options.set_variables.find(name) == options.set_variables.end()) { + if (!default_value.IsNull() && !user_settings.IsSet(setting_index)) { // Default value is set, insert it into the 'set_variables' list - options.set_variables[name] = default_value; + user_settings.SetUserSetting(setting_index, default_value); } } +case_insensitive_map_t DBConfig::GetExtensionSettings() const { + return user_settings.GetExtensionSettings(); +} + bool DBConfig::IsInMemoryDatabase(const char *database_path) { if (!database_path) { // Entirely empty @@ -488,7 +506,11 @@ bool DBConfig::IsInMemoryDatabase(const char *database_path) { } CastFunctionSet &DBConfig::GetCastFunctions() { - return *cast_functions; + return type_manager->GetCastFunctions(); +} + +TypeManager &DBConfig::GetTypeManager() { + return *type_manager; } CollationBinding &DBConfig::GetCollationBinding() { @@ -523,7 +545,7 @@ void DBConfig::SetDefaultTempDirectory() { } void DBConfig::CheckLock(const String &name) { - if (!options.lock_configuration) { + if (!Settings::Get(*this)) { // not locked return; } @@ -600,7 +622,7 @@ idx_t DBConfig::ParseMemoryLimit(const string &arg) { if (!error.empty()) { if (error == "Memory cannot be negative") { - result = -1; + result = DConstants::INVALID_INDEX; } else { throw ParserException(error); } @@ -665,44 +687,47 @@ OrderType DBConfig::ResolveOrder(ClientContext &context, OrderType order_type) c if (order_type != OrderType::ORDER_DEFAULT) { return order_type; } - return GetSetting(context); + return Settings::Get(context); } -Value DBConfig::GetSettingInternal(const ClientContext &context, const char *setting, const char *default_value) { - Value result_val; - if (context.TryGetCurrentSetting(setting, result_val)) { - return result_val; - } - return Value(default_value); +SettingLookupResult DBConfig::TryGetCurrentUserSetting(idx_t setting_index, Value &result) const { + return user_settings.TryGetSetting(setting_index, result); } -Value DBConfig::GetSettingInternal(const DBConfig &config, const char *setting, const char *default_value) { - Value result_val; - if (config.TryGetCurrentSetting(setting, result_val)) { - return result_val; +SettingLookupResult DBConfig::TryGetDefaultValue(optional_ptr option, Value &result) { + if (!option || !option->default_value) { + return SettingLookupResult(); } - return Value(default_value); -} - -Value DBConfig::GetSettingInternal(const DatabaseInstance &db, const char *setting, const char *default_value) { - return GetSettingInternal(DBConfig::GetConfig(db), setting, default_value); + auto input_type = ParseLogicalType(option->parameter_type); + result = Value(option->default_value).DefaultCastAs(input_type); + return SettingLookupResult(SettingScope::GLOBAL); } SettingLookupResult DBConfig::TryGetCurrentSetting(const string &key, Value &result) const { - const auto &global_config_map = options.set_variables; + optional_ptr option; + auto setting_index = TryGetSettingIndex(key, option); + if (setting_index.IsValid()) { + auto lookup_result = TryGetCurrentUserSetting(setting_index.GetIndex(), result); + if (lookup_result) { + return lookup_result; + } + } + return TryGetDefaultValue(option, result); +} - auto global_value = global_config_map.find(key); - if (global_value != global_config_map.end()) { - result = global_value->second; - return SettingLookupResult(SettingScope::GLOBAL); +optional_idx DBConfig::TryGetSettingIndex(const String &name, optional_ptr &option) const { + ExtensionOption extension_option; + if (TryGetExtensionOption(name, extension_option)) { + // extension setting + return extension_option.setting_index; } - auto option = GetOptionByName(key); - if (option && option->default_value) { - auto input_type = ParseLogicalType(option->parameter_type); - result = Value(option->default_value).DefaultCastAs(input_type); - return SettingLookupResult(SettingScope::GLOBAL); + option = GetOptionByName(name); + if (option) { + // built-in setting + return option->setting_idx; } - return SettingLookupResult(); + // unknown setting + return optional_idx(); } OrderByNullType DBConfig::ResolveNullOrder(ClientContext &context, OrderType order_type, @@ -710,7 +735,7 @@ OrderByNullType DBConfig::ResolveNullOrder(ClientContext &context, OrderType ord if (null_type != OrderByNullType::ORDER_DEFAULT) { return null_type; } - auto null_order = GetSetting(context); + auto null_order = Settings::Get(context); switch (null_order) { case DefaultOrderByNullType::NULLS_FIRST: return OrderByNullType::NULLS_FIRST; @@ -725,11 +750,16 @@ OrderByNullType DBConfig::ResolveNullOrder(ClientContext &context, OrderType ord } } +string GetDefaultUserAgent() { + return StringUtil::Format("duckdb/%s(%s)", DuckDB::LibraryVersion(), DuckDB::Platform()); +} + const string DBConfig::UserAgent() const { auto user_agent = GetDefaultUserAgent(); - if (!options.duckdb_api.empty()) { - user_agent += " " + options.duckdb_api; + auto duckdb_api = Settings::Get(*this); + if (!duckdb_api.empty()) { + user_agent += " " + duckdb_api; } if (!options.custom_user_agent.empty()) { @@ -738,12 +768,48 @@ const string DBConfig::UserAgent() const { return user_agent; } -string DBConfig::SanitizeAllowedPath(const string &path) const { - auto path_sep = file_system->PathSeparator(path); +ExtensionCallbackManager &DBConfig::GetCallbackManager() { + return *callback_manager; +} + +const ExtensionCallbackManager &DBConfig::GetCallbackManager() const { + return *callback_manager; +} + +string DBConfig::SanitizeAllowedPath(const string &path_p) const { + auto path_sep = file_system->PathSeparator(path_p); + auto path = path_p; if (path_sep != "/") { // allowed_directories/allowed_path always uses forward slashes regardless of the OS - return StringUtil::Replace(path, path_sep, "/"); + path = StringUtil::Replace(path_p, path_sep, "/"); + } + + auto elements = StringUtil::Split(path, "/"); + path.clear(); // later reconstructed + deque path_stack; + for (idx_t i = 0; i < elements.size(); i++) { + if (elements[i].empty() || elements[i] == ".") { + // we ignore empty and `.` + continue; + } + if (elements[i] == "..") { + // .. pops from stack if possible, if already at root its ignored + if (!path_stack.empty()) { + path_stack.pop_back(); + } + } else { + path_stack.push_back(elements[i]); + } } + // we lost the leading / in the split/loop so leats put it back + if (path_p[0] == '/') { + path = "/"; + } + while (!path_stack.empty()) { + path += path_stack.front() + '/'; + path_stack.pop_front(); + } + return path; } @@ -765,15 +831,17 @@ void DBConfig::AddAllowedPath(const string &path) { } bool DBConfig::CanAccessFile(const string &input_path, FileType type) { - if (options.enable_external_access) { + if (Settings::Get(*this)) { // all external access is allowed return true; } string path = SanitizeAllowedPath(input_path); + if (options.allowed_paths.count(path) > 0) { // path is explicitly allowed return true; } + if (options.allowed_directories.empty()) { // no prefix directories specified return false; @@ -798,27 +866,6 @@ bool DBConfig::CanAccessFile(const string &input_path, FileType type) { return false; } D_ASSERT(StringUtil::EndsWith(prefix, "/")); - // path is inside an allowed directory - HOWEVER, we could still exit the allowed directory using ".." - // we check if we ever exit the allowed directory using ".." by looking at the path fragments - idx_t directory_level = 0; - idx_t current_pos = prefix.size(); - for (; current_pos < path.size(); current_pos++) { - idx_t dir_begin = current_pos; - // find either the end of the path or the directory separator - for (; path[current_pos] != '/' && current_pos < path.size(); current_pos++) { - } - idx_t path_length = current_pos - dir_begin; - if (path_length == 2 && path[dir_begin] == '.' && path[dir_begin + 1] == '.') { - // go up a directory - if (directory_level == 0) { - // we cannot go up past the prefix - return false; - } - --directory_level; - } else if (path_length > 0) { - directory_level++; - } - } return true; } diff --git a/src/duckdb/src/main/connection.cpp b/src/duckdb/src/main/connection.cpp index 5546594a8..586e8755a 100644 --- a/src/duckdb/src/main/connection.cpp +++ b/src/duckdb/src/main/connection.cpp @@ -204,15 +204,6 @@ unique_ptr Connection::ExtractPlan(const string &query) { return context->ExtractPlan(query); } -void Connection::Append(TableDescription &description, DataChunk &chunk) { - if (chunk.size() == 0) { - return; - } - ColumnDataCollection collection(Allocator::Get(*context), chunk.GetTypes()); - collection.Append(chunk); - Append(description, collection); -} - void Connection::Append(TableDescription &description, ColumnDataCollection &collection) { context->Append(description, collection); } diff --git a/src/duckdb/src/main/connection_manager.cpp b/src/duckdb/src/main/connection_manager.cpp index 436c89eff..f97d373aa 100644 --- a/src/duckdb/src/main/connection_manager.cpp +++ b/src/duckdb/src/main/connection_manager.cpp @@ -11,7 +11,7 @@ ConnectionManager::ConnectionManager() : connection_count(0), current_connection void ConnectionManager::AddConnection(ClientContext &context) { lock_guard lock(connections_lock); - for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) { + for (auto &callback : ExtensionCallback::Iterate(context)) { callback->OnConnectionOpened(context); } connections[context] = weak_ptr(context.shared_from_this()); @@ -20,7 +20,7 @@ void ConnectionManager::AddConnection(ClientContext &context) { void ConnectionManager::RemoveConnection(ClientContext &context) { lock_guard lock(connections_lock); - for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) { + for (auto &callback : ExtensionCallback::Iterate(context)) { callback->OnConnectionClosed(context); } connections.erase(context); diff --git a/src/duckdb/src/main/database.cpp b/src/duckdb/src/main/database.cpp index 6badf7f9d..30cbed3a8 100644 --- a/src/duckdb/src/main/database.cpp +++ b/src/duckdb/src/main/database.cpp @@ -5,6 +5,7 @@ #include "duckdb/execution/index/index_type_set.hpp" #include "duckdb/execution/operator/helper/physical_set.hpp" #include "duckdb/function/cast/cast_function_set.hpp" +#include "duckdb/common/types/type_manager.hpp" #include "duckdb/function/compression_function.hpp" #include "duckdb/main/attached_database.hpp" #include "duckdb/main/client_context.hpp" @@ -34,6 +35,7 @@ #include "mbedtls_wrapper.hpp" #include "duckdb/main/database_file_path_manager.hpp" #include "duckdb/main/result_set_manager.hpp" +#include "duckdb/main/extension_callback_manager.hpp" #ifndef DUCKDB_NO_THREADS #include "duckdb/common/thread.hpp" @@ -47,13 +49,14 @@ DBConfig::DBConfig() { encoding_functions->Initialize(*this); arrow_extensions = make_uniq(); arrow_extensions->Initialize(*this); - cast_functions = make_uniq(*this); + type_manager = make_uniq(*this); collation_bindings = make_uniq(); index_types = make_uniq(); error_manager = make_uniq(); secret_manager = make_uniq(); http_util = make_shared_ptr(); - storage_extensions["__open_file__"] = OpenFileStorageExtension::Create(); + callback_manager = make_uniq(); + callback_manager->Register("__open_file__", OpenFileStorageExtension::Create()); } DBConfig::DBConfig(bool read_only) : DBConfig::DBConfig() { @@ -171,15 +174,15 @@ shared_ptr DatabaseInstance::CreateAttachedDatabase(ClientCont if (!options.db_type.empty()) { // Find the storage extension for this database file. auto extension_name = ExtensionHelper::ApplyExtensionAlias(options.db_type); - auto entry = config.storage_extensions.find(extension_name); - if (entry == config.storage_extensions.end()) { + auto storage_extension = StorageExtension::Find(config, extension_name); + if (!storage_extension) { throw BinderException("Unrecognized storage type \"%s\"", options.db_type); } - if (entry->second->attach != nullptr && entry->second->create_transaction_manager != nullptr) { + if (storage_extension->attach != nullptr && storage_extension->create_transaction_manager != nullptr) { // Use the storage extension to create the initial database. - attached_database = - make_shared_ptr(*this, catalog, *entry->second, context, info.name, info, options); + attached_database = make_shared_ptr(*this, catalog, *storage_extension, context, + info.name, info, options); return attached_database; } @@ -220,7 +223,7 @@ void DatabaseInstance::LoadExtensionSettings() { // copy the map, to protect against modifications during auto unrecognized_options_copy = config.options.unrecognized_options; - if (config.options.autoload_known_extensions) { + if (Settings::Get(*this)) { if (unrecognized_options_copy.empty()) { // Nothing to do return; @@ -243,14 +246,14 @@ void DatabaseInstance::LoadExtensionSettings() { "To set the %s setting, the %s extension needs to be loaded. But it could not be autoloaded.", name, extension_name); } - auto it = config.extension_parameters.find(name); - if (it == config.extension_parameters.end()) { + ExtensionOption extension_option; + if (!config.TryGetExtensionOption(name, extension_option)) { throw InternalException("Extension %s did not provide the '%s' config setting", extension_name, name); } // if the extension provided the option, it should no longer be unrecognized. D_ASSERT(config.options.unrecognized_options.find(name) == config.options.unrecognized_options.end()); auto &context = *con.context; - PhysicalSet::SetExtensionVariable(context, it->second, name, SetScope::GLOBAL, value); + PhysicalSet::SetExtensionVariable(context, extension_option, name, SetScope::GLOBAL, value); extension_options.push_back(name); } @@ -287,11 +290,13 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf log_manager = make_uniq(*this, LogConfig()); log_manager->Initialize(); - external_file_cache = make_uniq(*this, config.options.enable_external_file_cache); + bool enable_external_file_cache = Settings::Get(config); + external_file_cache = make_uniq(*this, enable_external_file_cache); result_set_manager = make_uniq(*this); scheduler = make_uniq(*this); - object_cache = make_uniq(); + object_cache = make_uniq(*config.buffer_pool); + config.buffer_pool->SetObjectCache(object_cache.get()); connection_manager = make_uniq(); extension_manager = make_uniq(*this); @@ -310,8 +315,8 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf if (!config.file_system) { throw InternalException("No file system!?"); } - auto entry = config.storage_extensions.find(config.options.database_type); - if (entry == config.storage_extensions.end()) { + auto storage_extension = StorageExtension::Find(config, config.options.database_type); + if (!storage_extension) { ExtensionHelper::LoadExternalExtension(*this, *config.file_system, config.options.database_type); } } @@ -323,7 +328,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf } // only increase thread count after storage init because we get races on catalog otherwise - scheduler->SetThreads(config.options.maximum_threads, config.options.external_threads); + scheduler->SetThreads(config.options.maximum_threads, Settings::Get(config)); scheduler->RelaunchThreads(); } @@ -414,8 +419,9 @@ Allocator &Allocator::Get(AttachedDatabase &db) { void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path) { config.options = new_config.options; + config.user_settings = new_config.user_settings; - if (config.options.duckdb_api.empty()) { + if (Settings::Get(*this).empty()) { config.SetOptionByName("duckdb_api", "cpp"); } @@ -432,13 +438,12 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path if (config.options.access_mode == AccessMode::UNDEFINED) { config.options.access_mode = AccessMode::READ_WRITE; } - config.extension_parameters = new_config.extension_parameters; if (new_config.file_system) { config.file_system = std::move(new_config.file_system); } else { config.file_system = make_uniq(FileSystem::CreateLocal()); } - if (database_path && !config.options.enable_external_access) { + if (database_path && !Settings::Get(*this)) { config.AddAllowedPath(database_path); config.AddAllowedPath(database_path + string(".wal")); if (!config.options.temporary_directory.empty()) { @@ -448,9 +453,6 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path if (new_config.secret_manager) { config.secret_manager = std::move(new_config.secret_manager); } - if (!new_config.storage_extensions.empty()) { - config.storage_extensions = std::move(new_config.storage_extensions); - } if (config.options.maximum_memory == DConstants::INVALID_INDEX) { config.SetDefaultMaxMemory(); } @@ -461,11 +463,15 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path if (!config.allocator) { config.allocator = make_uniq(); } - config.block_allocator = make_uniq(*config.allocator, config.options.default_block_alloc_size, + auto default_block_size = Settings::Get(config); + config.block_allocator = make_uniq(*config.allocator, default_block_size, DBConfig::GetSystemAvailableMemory(*config.file_system) * 8 / 10, config.options.block_allocator_size); config.replacement_scans = std::move(new_config.replacement_scans); - config.parser_extensions = std::move(new_config.parser_extensions); + if (new_config.callback_manager) { + config.callback_manager = std::move(new_config.callback_manager); + new_config.callback_manager = make_uniq(); + } config.error_manager = std::move(new_config.error_manager); if (!config.error_manager) { config.error_manager = make_uniq(); diff --git a/src/duckdb/src/main/database_manager.cpp b/src/duckdb/src/main/database_manager.cpp index 80b78ee57..d3a27cf5d 100644 --- a/src/duckdb/src/main/database_manager.cpp +++ b/src/duckdb/src/main/database_manager.cpp @@ -7,10 +7,11 @@ #include "duckdb/main/database.hpp" #include "duckdb/main/database_path_and_type.hpp" #include "duckdb/main/extension_helper.hpp" +#include "duckdb/parser/parsed_data/alter_database_info.hpp" +#include "duckdb/storage/storage_extension.hpp" #include "duckdb/storage/storage_manager.hpp" #include "duckdb/transaction/duck_transaction.hpp" #include "duckdb/transaction/duck_transaction_manager.hpp" -#include "duckdb/parser/parsed_data/alter_database_info.hpp" namespace duckdb { @@ -320,7 +321,7 @@ void DatabaseManager::GetDatabaseType(ClientContext &context, AttachInfo &info, } auto extension_name = ExtensionHelper::ApplyExtensionAlias(options.db_type); - if (config.storage_extensions.find(extension_name) != config.storage_extensions.end()) { + if (StorageExtension::Find(config, extension_name)) { // If the database type is already registered, we don't need to load it again. return; } diff --git a/src/duckdb/src/main/extension/extension_helper.cpp b/src/duckdb/src/main/extension/extension_helper.cpp index 9058f19e1..a9737342d 100644 --- a/src/duckdb/src/main/extension/extension_helper.cpp +++ b/src/duckdb/src/main/extension/extension_helper.cpp @@ -181,18 +181,16 @@ string ExtensionHelper::AddExtensionInstallHintToErrorMsg(DatabaseInstance &db, const string &extension_name) { string install_hint; - auto &config = db.config; - if (!ExtensionHelper::CanAutoloadExtension(extension_name)) { install_hint = "Please try installing and loading the " + extension_name + " extension:\nINSTALL " + extension_name + ";\nLOAD " + extension_name + ";\n\n"; - } else if (!config.options.autoload_known_extensions) { + } else if (!Settings::Get(db)) { install_hint = "Please try installing and loading the " + extension_name + " extension by running:\nINSTALL " + extension_name + ";\nLOAD " + extension_name + ";\n\nAlternatively, consider enabling auto-install " "and auto-load by running:\nSET autoinstall_known_extensions=1;\nSET autoload_known_extensions=1;"; - } else if (!config.options.autoinstall_known_extensions) { + } else if (!Settings::Get(db)) { install_hint = "Please try installing the " + extension_name + " extension by running:\nINSTALL " + extension_name + ";\n\nAlternatively, consider enabling autoinstall by running:\nSET autoinstall_known_extensions=1;"; @@ -209,11 +207,10 @@ bool ExtensionHelper::TryAutoLoadExtension(ClientContext &context, const string if (context.db->ExtensionIsLoaded(extension_name)) { return true; } - auto &dbconfig = DBConfig::GetConfig(context); try { - if (dbconfig.options.autoinstall_known_extensions) { - auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl( - StringValue::Get(DBConfig::GetConfig(context).options.autoinstall_extension_repo)); + if (Settings::Get(context)) { + auto autoinstall_repo_setting = Settings::Get(context); + auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(autoinstall_repo_setting); ExtensionInstallOptions options; options.repository = autoinstall_repo; ExtensionHelper::InstallExtension(context, extension_name, options); @@ -225,10 +222,10 @@ bool ExtensionHelper::TryAutoLoadExtension(ClientContext &context, const string } } -static string GetAutoInstallExtensionsRepository(const DBConfigOptions &options) { - string repository_url = options.autoinstall_extension_repo; +static string GetAutoInstallExtensionsRepository(const DBConfig &config) { + string repository_url = Settings::Get(config); if (repository_url.empty()) { - repository_url = options.custom_extension_repo; + repository_url = Settings::Get(config); } return repository_url; } @@ -240,8 +237,8 @@ bool ExtensionHelper::TryAutoLoadExtension(DatabaseInstance &instance, const str auto &dbconfig = DBConfig::GetConfig(instance); try { auto &fs = FileSystem::GetFileSystem(instance); - if (dbconfig.options.autoinstall_known_extensions) { - auto repository_url = GetAutoInstallExtensionsRepository(dbconfig.options); + if (Settings::Get(instance)) { + auto repository_url = GetAutoInstallExtensionsRepository(dbconfig); auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(repository_url); ExtensionInstallOptions options; options.repository = autoinstall_repo; @@ -274,7 +271,7 @@ static ExtensionUpdateResult UpdateExtensionInternal(ClientContext &context, Dat // Parse the version of the extension before updating auto ext_binary_handle = fs.OpenFile(full_extension_path, FileOpenFlags::FILE_FLAGS_READ); auto parsed_metadata = ExtensionHelper::ParseExtensionMetaData(*ext_binary_handle); - if (!parsed_metadata.AppearsValid() && !DBConfig::GetSetting(context)) { + if (!parsed_metadata.AppearsValid() && !Settings::Get(context)) { throw IOException( "Failed to update extension: '%s', the metadata of the extension appears invalid! To resolve this, either " "reinstall the extension using 'FORCE INSTALL %s', manually remove the file '%s', or enable '" @@ -388,8 +385,8 @@ void ExtensionHelper::AutoLoadExtension(DatabaseInstance &db, const string &exte try { auto fs = FileSystem::CreateLocal(); #ifndef DUCKDB_WASM - if (dbconfig.options.autoinstall_known_extensions) { - auto repository_url = GetAutoInstallExtensionsRepository(dbconfig.options); + if (Settings::Get(db)) { + auto repository_url = GetAutoInstallExtensionsRepository(dbconfig); auto autoinstall_repo = ExtensionRepository::GetRepositoryByUrl(repository_url); ExtensionInstallOptions options; options.repository = autoinstall_repo; diff --git a/src/duckdb/src/main/extension/extension_install.cpp b/src/duckdb/src/main/extension/extension_install.cpp index 5241810b0..346aa65a9 100644 --- a/src/duckdb/src/main/extension/extension_install.cpp +++ b/src/duckdb/src/main/extension/extension_install.cpp @@ -100,8 +100,9 @@ vector ExtensionHelper::GetExtensionDirectoryPath(DatabaseInstance &db, vector extension_directories; auto &config = db.config; - if (!config.options.extension_directory.empty()) { - extension_directories.push_back(config.options.extension_directory); + auto custom_extension_directory = Settings::Get(config); + if (!custom_extension_directory.empty()) { + extension_directories.push_back(custom_extension_directory); } if (!config.options.extension_directories.empty()) { @@ -219,10 +220,25 @@ static unsafe_unique_array ReadExtensionFileFromDisk(FileSystem &fs, con } static void WriteExtensionFileToDisk(QueryContext &query_context, FileSystem &fs, const string &path, void *data, - idx_t data_size) { - auto target_file = fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_APPEND | - FileFlags::FILE_FLAGS_FILE_CREATE_NEW); + idx_t data_size, DBConfig &config) { + if (!Settings::Get(config)) { + const bool signature_valid = ExtensionHelper::CheckExtensionBufferSignature( + static_cast(data), data_size, Settings::Get(config)); + if (!signature_valid) { + throw IOException("Attempting to install an extension file that doesn't have a valid signature, see " + "https://duckdb.org/docs/stable/operations_manual/securing_duckdb/securing_extensions"); + } + } + + // Now signature has been checked (if signature checking is enabled) + + // Open target_file, at this points ending with '.duckdb_extension' + auto target_file = + fs.OpenFile(path, FileFlags::FILE_FLAGS_WRITE | FileFlags::FILE_FLAGS_READ | FileFlags::FILE_FLAGS_APPEND | + FileFlags::FILE_FLAGS_FILE_CREATE_NEW | FileFlags::FILE_FLAGS_ENABLE_EXTENSION_INSTALL); + // Write content to the file target_file->Write(query_context, data, data_size); + target_file->Close(); target_file.reset(); } @@ -269,7 +285,7 @@ static void CheckExtensionMetadataOnInstall(DatabaseInstance &db, void *in_buffe auto metadata_mismatch_error = parsed_metadata.GetInvalidMetadataError(); - if (!metadata_mismatch_error.empty() && !DBConfig::GetSetting(db)) { + if (!metadata_mismatch_error.empty() && !Settings::Get(db)) { throw IOException("Failed to install '%s'\n%s", extension_name, metadata_mismatch_error); } @@ -283,9 +299,23 @@ static void CheckExtensionMetadataOnInstall(DatabaseInstance &db, void *in_buffe // 3. Crash after extension move: extension is now uninstalled, new metadata file present static void WriteExtensionFiles(QueryContext &query_context, FileSystem &fs, const string &temp_path, const string &local_extension_path, void *in_buffer, idx_t file_size, - ExtensionInstallInfo &info) { + ExtensionInstallInfo &info, DBConfig &config) { + // temp_path ends with '.duckdb_extension' + if (!StringUtil::EndsWith(temp_path, ".duckdb_extension")) { + throw InternalException("Extension install temp_path of '%s' is not valid, should end in '.duckdb_extension'", + temp_path); + } + // local_extension_path ends with '.duckdb_extension', and given it will be written only after signature checks, + // it's now loadable + if (!StringUtil::EndsWith(local_extension_path, ".duckdb_extension")) { + throw InternalException("Extension install local_extension_path of '%s' is not valid, should end in " + "'.duckdb_extension'", + temp_path); + } + // Write extension to tmp file - WriteExtensionFileToDisk(query_context, fs, temp_path, in_buffer, file_size); + WriteExtensionFileToDisk(query_context, fs, temp_path, in_buffer, file_size, config); + // When this exit, signature has already being checked (if enabled by config) // Write metadata to tmp file auto metadata_tmp_path = temp_path + ".info"; @@ -310,7 +340,7 @@ static unique_ptr DirectInstallExtension(DatabaseInstance if (context) { auto &db = DatabaseInstance::GetDatabase(*context); if (extension == "httpfs" && !db.ExtensionIsLoaded("httpfs") && - db.config.options.autoload_known_extensions) { + Settings::Get(*context)) { ExtensionHelper::AutoLoadExtension(*context, "httpfs"); } } @@ -369,7 +399,7 @@ static unique_ptr DirectInstallExtension(DatabaseInstance QueryContext query_context(context); WriteExtensionFiles(query_context, fs, temp_path, local_extension_path, extension_decompressed, - extension_decompressed_size, info); + extension_decompressed_size, info, db.config); return make_uniq(info); } @@ -461,7 +491,7 @@ static unique_ptr InstallFromHttpUrl(DatabaseInstance &db, QueryContext query_context(context); auto fs = FileSystem::CreateLocal(); WriteExtensionFiles(query_context, *fs, temp_path, local_extension_path, (void *)decompressed_body.data(), - decompressed_body.size(), info); + decompressed_body.size(), info, db.config); return make_uniq(info); } @@ -527,11 +557,12 @@ unique_ptr ExtensionHelper::InstallExtensionInternal(Datab auto extension_name = ApplyExtensionAlias(fs.ExtractBaseName(extension)); string local_extension_path = fs.JoinPath(local_path, extension_name + ".duckdb_extension"); - string temp_path = local_extension_path + ".tmp-" + UUID::ToString(UUID::GenerateRandomUUID()); + string temp_path = + local_extension_path + ".tmp-" + UUID::ToString(UUID::GenerateRandomUUID()) + ".duckdb_extension"; if (fs.FileExists(local_extension_path) && !options.force_install) { // File exists: throw error if origin mismatches - if (options.throw_on_origin_mismatch && !DBConfig::GetSetting(db) && + if (options.throw_on_origin_mismatch && !Settings::Get(db) && fs.FileExists(local_extension_path + ".info")) { ThrowErrorOnMismatchingExtensionOrigin(fs, local_extension_path, extension_name, extension, options.repository); diff --git a/src/duckdb/src/main/extension/extension_load.cpp b/src/duckdb/src/main/extension/extension_load.cpp index 0b88a2071..50f95a2bb 100644 --- a/src/duckdb/src/main/extension/extension_load.cpp +++ b/src/duckdb/src/main/extension/extension_load.cpp @@ -34,6 +34,7 @@ struct DuckDBExtensionLoadState { //! Create a DuckDBExtensionLoadState reference from a C API opaque pointer static DuckDBExtensionLoadState &Get(duckdb_extension_info info) { D_ASSERT(info); + return *reinterpret_cast(info); } @@ -81,14 +82,14 @@ struct ExtensionAccess { } //! Called by the extension get a pointer to the database that is loading it - static duckdb_database GetDatabase(duckdb_extension_info info) { + static duckdb_database *GetDatabase(duckdb_extension_info info) { auto &load_state = DuckDBExtensionLoadState::Get(info); try { // Create the duckdb_database load_state.database_data = make_uniq(); load_state.database_data->database = make_shared_ptr(load_state.db); - return reinterpret_cast(load_state.database_data.get()); + return reinterpret_cast(load_state.database_data.get()); } catch (std::exception &ex) { load_state.has_error = true; load_state.error_data = ErrorData(ex); @@ -164,9 +165,41 @@ static T TryLoadFunctionFromDLL(void *dll, const string &function_name, const st return (T)function; } -static void ComputeSHA256String(const string &to_hash, string *res) { +static void ComputeSHA256Buffer(const char *buffer, const idx_t start, const idx_t end, string *res) { // Invoke MbedTls function to actually compute sha256 - *res = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(to_hash); + char hash[duckdb_mbedtls::MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES]; + duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(buffer + start, end - start, hash); + *res = std::string(hash, duckdb_mbedtls::MbedTlsWrapper::SHA256_HASH_LENGTH_BYTES); +} + +static void ComputeSHA256String(const string &to_hash, string *res) { + ComputeSHA256Buffer(to_hash.data(), 0, to_hash.length(), res); +} + +static string ComputeFinalHash(const vector &chunks) { + string hash_concatenation; + hash_concatenation.reserve(32 * chunks.size()); // 256 bits -> 32 bytes per chunk + + for (auto &chunk : chunks) { + hash_concatenation += chunk; + } + + string two_level_hash; + ComputeSHA256String(hash_concatenation, &two_level_hash); + + return two_level_hash; +} + +static void IntializeAncillaryData(vector &hash_chunks, vector &splits, idx_t length) { + const idx_t maxLenChunks = 1024ULL * 1024ULL; + const idx_t numChunks = (length + maxLenChunks - 1) / maxLenChunks; + hash_chunks.resize(numChunks); + splits.resize(numChunks + 1); + + for (idx_t i = 0; i < numChunks; i++) { + splits[i] = maxLenChunks * i; + } + splits.back() = length; } static void ComputeSHA256FileSegment(FileHandle *handle, const idx_t start, const idx_t end, string *res) { @@ -189,6 +222,26 @@ static void ComputeSHA256FileSegment(FileHandle *handle, const idx_t start, cons *res = state.Finalize(); } +template +static void ComputeHashesOnSegments(F ComputeHashFun, T handle, const vector &splits, + vector &hash_chunks) { +#ifndef DUCKDB_NO_THREADS + vector threads; + threads.reserve(hash_chunks.size()); + for (idx_t i = 0; i < hash_chunks.size(); i++) { + threads.emplace_back(ComputeHashFun, handle, splits[i], splits[i + 1], &hash_chunks[i]); + } + + for (auto &thread : threads) { + thread.join(); + } +#else + for (idx_t i = 0; i < hash_chunks.size(); i++) { + ComputeHashFun(handle, splits[i], splits[i + 1], &hash_chunks[i]); + } +#endif // DUCKDB_NO_THREADS +} + static string FilterZeroAtEnd(string s) { while (!s.empty() && s.back() == '\0') { s.pop_back(); @@ -257,57 +310,54 @@ ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(FileHandle &hand return ParseExtensionMetaData(metadata_segment.data()); } +static bool CheckKnownSignatures(const string &two_level_hash, const string &signature, + const bool allow_community_extensions) { + for (auto &key : ExtensionHelper::GetPublicKeys(allow_community_extensions)) { + if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, signature, two_level_hash)) { + return true; + } + } + + return false; +} + bool ExtensionHelper::CheckExtensionSignature(FileHandle &handle, ParsedExtensionMetaData &parsed_metadata, const bool allow_community_extensions) { auto signature_offset = handle.GetFileSize() - ParsedExtensionMetaData::SIGNATURE_SIZE; - const idx_t maxLenChunks = 1024ULL * 1024ULL; - const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks; - vector hash_chunks(numChunks); - vector splits(numChunks + 1); + vector hash_chunks; + vector splits; + IntializeAncillaryData(hash_chunks, splits, signature_offset); - for (idx_t i = 0; i < numChunks; i++) { - splits[i] = maxLenChunks * i; - } - splits.back() = signature_offset; + ComputeHashesOnSegments(ComputeSHA256FileSegment, &handle, splits, hash_chunks); -#ifndef DUCKDB_NO_THREADS - vector threads; - threads.reserve(numChunks); - for (idx_t i = 0; i < numChunks; i++) { - threads.emplace_back(ComputeSHA256FileSegment, &handle, splits[i], splits[i + 1], &hash_chunks[i]); - } + const string resulting_hash = ComputeFinalHash(hash_chunks); - for (auto &thread : threads) { - thread.join(); - } -#else - for (idx_t i = 0; i < numChunks; i++) { - ComputeSHA256FileSegment(&handle, splits[i], splits[i + 1], &hash_chunks[i]); - } -#endif // DUCKDB_NO_THREADS + // TODO maybe we should do a stream read / hash update here + handle.Read((void *)parsed_metadata.signature.data(), parsed_metadata.signature.size(), signature_offset); - string hash_concatenation; - hash_concatenation.reserve(32 * numChunks); // 256 bits -> 32 bytes per chunk + return CheckKnownSignatures(resulting_hash, parsed_metadata.signature, allow_community_extensions); +} - for (auto &hash_chunk : hash_chunks) { - hash_concatenation += hash_chunk; - } +bool ExtensionHelper::CheckExtensionBufferSignature(const char *buffer, idx_t buffer_length, const string &signature, + const bool allow_community_extensions) { + vector hash_chunks; + vector splits; + IntializeAncillaryData(hash_chunks, splits, buffer_length); - string two_level_hash; - ComputeSHA256String(hash_concatenation, &two_level_hash); + ComputeHashesOnSegments(ComputeSHA256Buffer, buffer, splits, hash_chunks); - // TODO maybe we should do a stream read / hash update here - handle.Read((void *)parsed_metadata.signature.data(), parsed_metadata.signature.size(), signature_offset); + const string resulting_hash = ComputeFinalHash(hash_chunks); - for (auto &key : ExtensionHelper::GetPublicKeys(allow_community_extensions)) { - if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, parsed_metadata.signature, two_level_hash)) { - return true; - break; - } - } + return CheckKnownSignatures(resulting_hash, signature, allow_community_extensions); +} - return false; +bool ExtensionHelper::CheckExtensionBufferSignature(const char *buffer, idx_t total_buffer_length, + const bool allow_community_extensions) { + auto signature_offset = total_buffer_length - ParsedExtensionMetaData::SIGNATURE_SIZE; + string signature = std::string(buffer + signature_offset, ParsedExtensionMetaData::SIGNATURE_SIZE); + + return CheckExtensionBufferSignature(buffer, signature_offset, signature, allow_community_extensions); } bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const string &extension, @@ -315,7 +365,7 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const #ifdef DUCKDB_DISABLE_EXTENSION_LOAD throw PermissionException("Loading external extensions is disabled through a compile time flag"); #else - if (!db.config.options.enable_external_access) { + if (!Settings::Get(db)) { throw PermissionException("Loading external extensions is disabled through configuration"); } auto filename = fs.ConvertSeparators(extension); @@ -365,8 +415,9 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const // Collect all directories to search for extensions vector search_directories; - if (!db.config.options.extension_directory.empty()) { - search_directories.push_back(db.config.options.extension_directory); + auto custom_extension_directory = Settings::Get(db); + if (!custom_extension_directory.empty()) { + search_directories.push_back(custom_extension_directory); } if (!db.config.options.extension_directories.empty()) { @@ -402,6 +453,12 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const direct_load = true; filename = fs.ExpandPath(filename); } + if (!StringUtil::EndsWith(filename, ".duckdb_extension")) { + throw PermissionException( + "DuckDB extensions are files ending with '.duckdb_extension', loading different " + "files is not possible, error while loading from '%s', consider 'INSTALL ; LOAD ;'", + filename); + } if (!fs.FileExists(filename)) { string message; bool exact_match = ExtensionHelper::CreateSuggestions(extension, message); @@ -423,11 +480,11 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const metadata_mismatch_error = StringUtil::Format("Failed to load '%s', %s", extension, metadata_mismatch_error); } - if (!db.config.options.allow_unsigned_extensions) { + if (!Settings::Get(db)) { bool signature_valid; if (parsed_metadata.AppearsValid()) { - signature_valid = - CheckExtensionSignature(*handle, parsed_metadata, db.config.options.allow_community_extensions); + bool allow_community_extensions = Settings::Get(db); + signature_valid = CheckExtensionSignature(*handle, parsed_metadata, allow_community_extensions); } else { signature_valid = false; } @@ -439,7 +496,7 @@ bool ExtensionHelper::TryInitialLoad(DatabaseInstance &db, FileSystem &fs, const if (!signature_valid) { throw IOException(db.config.error_manager->FormatException(ErrorType::UNSIGNED_EXTENSION, filename)); } - } else if (!DBConfig::GetSetting(db)) { + } else if (!Settings::Get(db)) { if (!metadata_mismatch_error.empty()) { // Unsigned extensions AND configuration allowing n, loading allowed, mainly for // debugging purposes @@ -514,8 +571,7 @@ ExtensionInitResult ExtensionHelper::InitialLoad(DatabaseInstance &db, FileSyste string error; ExtensionInitResult result; if (!TryInitialLoad(db, fs, extension, result, error)) { - auto &config = DBConfig::GetConfig(db); - if (!config.options.autoinstall_known_extensions || !ExtensionHelper::AllowAutoInstall(extension)) { + if (!Settings::Get(db) || !ExtensionHelper::AllowAutoInstall(extension)) { throw IOException(error); } // the extension load failed - try installing the extension diff --git a/src/duckdb/src/main/extension_callback_manager.cpp b/src/duckdb/src/main/extension_callback_manager.cpp new file mode 100644 index 000000000..4d83631c1 --- /dev/null +++ b/src/duckdb/src/main/extension_callback_manager.cpp @@ -0,0 +1,153 @@ +#include "duckdb/main/extension_callback_manager.hpp" +#include "duckdb/parser/parser_extension.hpp" +#include "duckdb/optimizer/optimizer_extension.hpp" +#include "duckdb/planner/operator_extension.hpp" +#include "duckdb/storage/storage_extension.hpp" +#include "duckdb/planner/extension_callback.hpp" + +namespace duckdb { + +struct ExtensionCallbackRegistry { + //! Extensions made to the parser + vector parser_extensions; + //! Extensions made to the optimizer + vector optimizer_extensions; + //! Extensions made to binder + vector> operator_extensions; + //! Extensions made to storage + case_insensitive_map_t> storage_extensions; + //! Set of callbacks that can be installed by extensions + vector> extension_callbacks; +}; + +ExtensionCallbackManager &ExtensionCallbackManager::Get(ClientContext &context) { + return DBConfig::GetConfig(context).GetCallbackManager(); +} + +const ExtensionCallbackManager &ExtensionCallbackManager::Get(const ClientContext &context) { + return DBConfig::GetConfig(context).GetCallbackManager(); +} + +ExtensionCallbackManager &ExtensionCallbackManager::Get(DatabaseInstance &db) { + return DBConfig::GetConfig(db).GetCallbackManager(); +} + +ExtensionCallbackManager::ExtensionCallbackManager() : callback_registry(make_shared_ptr()) { +} +ExtensionCallbackManager::~ExtensionCallbackManager() { +} + +void ExtensionCallbackManager::Register(ParserExtension extension) { + lock_guard guard(registry_lock); + auto new_registry = make_shared_ptr(*callback_registry); + new_registry->parser_extensions.push_back(std::move(extension)); + callback_registry.atomic_store(new_registry); +} + +void ExtensionCallbackManager::Register(OptimizerExtension extension) { + lock_guard guard(registry_lock); + auto new_registry = make_shared_ptr(*callback_registry); + new_registry->optimizer_extensions.push_back(std::move(extension)); + callback_registry.atomic_store(new_registry); +} + +void ExtensionCallbackManager::Register(shared_ptr extension) { + lock_guard guard(registry_lock); + auto new_registry = make_shared_ptr(*callback_registry); + new_registry->operator_extensions.push_back(std::move(extension)); + callback_registry.atomic_store(new_registry); +} + +void ExtensionCallbackManager::Register(const string &name, shared_ptr extension) { + lock_guard guard(registry_lock); + auto new_registry = make_shared_ptr(*callback_registry); + new_registry->storage_extensions[name] = std::move(extension); + callback_registry.atomic_store(new_registry); +} + +void ExtensionCallbackManager::Register(shared_ptr extension) { + lock_guard guard(registry_lock); + auto new_registry = make_shared_ptr(*callback_registry); + new_registry->extension_callbacks.push_back(std::move(extension)); + callback_registry.atomic_store(new_registry); +} + +template +ExtensionCallbackIteratorHelper::ExtensionCallbackIteratorHelper( + const vector &vec, shared_ptr callback_registry) + : vec(vec), callback_registry(std::move(callback_registry)) { +} + +template +ExtensionCallbackIteratorHelper::~ExtensionCallbackIteratorHelper() { +} + +ExtensionCallbackIteratorHelper> ExtensionCallbackManager::OperatorExtensions() const { + auto registry = callback_registry.atomic_load(); + auto &operator_extensions = registry->operator_extensions; + return ExtensionCallbackIteratorHelper>(operator_extensions, std::move(registry)); +} + +ExtensionCallbackIteratorHelper ExtensionCallbackManager::OptimizerExtensions() const { + auto registry = callback_registry.atomic_load(); + auto &optimizer_extensions = registry->optimizer_extensions; + return ExtensionCallbackIteratorHelper(optimizer_extensions, std::move(registry)); +} + +ExtensionCallbackIteratorHelper ExtensionCallbackManager::ParserExtensions() const { + auto registry = callback_registry.atomic_load(); + auto &parser_extensions = registry->parser_extensions; + return ExtensionCallbackIteratorHelper(parser_extensions, std::move(registry)); +} + +ExtensionCallbackIteratorHelper> ExtensionCallbackManager::ExtensionCallbacks() const { + auto registry = callback_registry.atomic_load(); + auto &extension_callbacks = registry->extension_callbacks; + return ExtensionCallbackIteratorHelper>(extension_callbacks, std::move(registry)); +} + +optional_ptr ExtensionCallbackManager::FindStorageExtension(const string &name) const { + auto registry = callback_registry.atomic_load(); + auto entry = registry->storage_extensions.find(name); + if (entry == registry->storage_extensions.end()) { + return nullptr; + } + return entry->second.get(); +} + +bool ExtensionCallbackManager::HasParserExtensions() const { + auto registry = callback_registry.atomic_load(); + return !registry->parser_extensions.empty(); +} + +void OptimizerExtension::Register(DBConfig &config, OptimizerExtension extension) { + config.GetCallbackManager().Register(std::move(extension)); +} + +void ParserExtension::Register(DBConfig &config, ParserExtension extension) { + config.GetCallbackManager().Register(std::move(extension)); +} + +void OperatorExtension::Register(DBConfig &config, shared_ptr extension) { + config.GetCallbackManager().Register(std::move(extension)); +} + +optional_ptr StorageExtension::Find(const DBConfig &config, const string &extension_name) { + return config.GetCallbackManager().FindStorageExtension(extension_name); +} + +void ExtensionCallback::Register(DBConfig &config, shared_ptr extension) { + config.GetCallbackManager().Register(std::move(extension)); +} + +void StorageExtension::Register(DBConfig &config, const string &extension_name, + shared_ptr extension) { + config.GetCallbackManager().Register(extension_name, std::move(extension)); +} + +template class ExtensionCallbackIteratorHelper>; +template class ExtensionCallbackIteratorHelper>; +template class ExtensionCallbackIteratorHelper; +template class ExtensionCallbackIteratorHelper; + +} // namespace duckdb diff --git a/src/duckdb/src/main/extension_install_info.cpp b/src/duckdb/src/main/extension_install_info.cpp index 8c9e69e00..86cc58be2 100644 --- a/src/duckdb/src/main/extension_install_info.cpp +++ b/src/duckdb/src/main/extension_install_info.cpp @@ -1,6 +1,7 @@ #include "duckdb/main/extension_install_info.hpp" #include "duckdb/common/string.hpp" #include "duckdb/common/file_system.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/common/serializer/buffered_file_reader.hpp" #include "duckdb/common/serializer/binary_deserializer.hpp" @@ -45,8 +46,11 @@ string ExtensionRepository::TryConvertUrlToKnownRepository(const string &url) { } ExtensionRepository ExtensionRepository::GetDefaultRepository(optional_ptr config) { - if (config && !config->options.custom_extension_repo.empty()) { - return ExtensionRepository("", config->options.custom_extension_repo); + if (config) { + auto custom_extension_repo = Settings::Get(*config); + if (!custom_extension_repo.empty()) { + return ExtensionRepository("", custom_extension_repo); + } } return GetCoreRepository(); diff --git a/src/duckdb/src/main/extension_manager.cpp b/src/duckdb/src/main/extension_manager.cpp index fbb2b9cea..24459fabf 100644 --- a/src/duckdb/src/main/extension_manager.cpp +++ b/src/duckdb/src/main/extension_manager.cpp @@ -17,16 +17,14 @@ void ExtensionActiveLoad::FinishLoad(ExtensionInstallInfo &install_info) { info.is_loaded = true; info.install_info = make_uniq(install_info); - auto &callbacks = DBConfig::GetConfig(db).extension_callbacks; - for (auto &callback : callbacks) { + for (auto &callback : ExtensionCallback::Iterate(db)) { callback->OnExtensionLoaded(db, extension_name); } DUCKDB_LOG_INFO(db, extension_name); } void ExtensionActiveLoad::LoadFail(const ErrorData &error) { - auto &callbacks = DBConfig::GetConfig(db).extension_callbacks; - for (auto &callback : callbacks) { + for (auto &callback : ExtensionCallback::Iterate(db)) { callback->OnExtensionLoadFail(db, extension_name, error); } DUCKDB_LOG_INFO(db, "Failed to load extension '%s': %s", extension_name, error.Message()); @@ -104,8 +102,7 @@ unique_ptr ExtensionManager::BeginLoad(const string &name) if (info->is_loaded) { return nullptr; } - auto &callbacks = DBConfig::GetConfig(db).extension_callbacks; - for (auto &callback : callbacks) { + for (auto &callback : ExtensionCallback::Iterate(db)) { callback->OnBeginExtensionLoad(db, extension_name); } // extension is not loaded yet and we are in charge of loading it - return diff --git a/src/duckdb/src/main/http/http_util.cpp b/src/duckdb/src/main/http/http_util.cpp index f562dd8cc..8a1008436 100644 --- a/src/duckdb/src/main/http/http_util.cpp +++ b/src/duckdb/src/main/http/http_util.cpp @@ -8,6 +8,7 @@ #include "duckdb/main/client_data.hpp" #include "duckdb/main/database.hpp" #include "duckdb/main/database_file_opener.hpp" +#include "duckdb/main/settings.hpp" #ifndef DISABLE_DUCKDB_REMOTE_INSTALL #ifndef DUCKDB_DISABLE_EXTENSION_LOAD @@ -456,16 +457,16 @@ HTTPUtil::RunRequestWithRetry(const std::function(void) void HTTPParams::Initialize(optional_ptr opener) { auto db = FileOpener::TryGetDatabase(opener); if (db) { - auto &config = db->config; - if (!config.options.http_proxy.empty()) { + auto http_proxy_setting = Settings::Get(*db); + if (!http_proxy_setting.empty()) { idx_t port; string host; - HTTPUtil::ParseHTTPProxyHost(config.options.http_proxy, host, port); + HTTPUtil::ParseHTTPProxyHost(http_proxy_setting, host, port); http_proxy = host; http_proxy_port = port; } - http_proxy_username = config.options.http_proxy_username; - http_proxy_password = config.options.http_proxy_password; + http_proxy_username = Settings::Get(*db); + http_proxy_password = Settings::Get(*db); } auto client_context = FileOpener::TryGetClientContext(opener); diff --git a/src/duckdb/src/main/prepared_statement.cpp b/src/duckdb/src/main/prepared_statement.cpp index 49ff9ac94..69332537a 100644 --- a/src/duckdb/src/main/prepared_statement.cpp +++ b/src/duckdb/src/main/prepared_statement.cpp @@ -70,19 +70,34 @@ case_insensitive_map_t PreparedStatement::GetExpectedParameterTypes unique_ptr PreparedStatement::Execute(case_insensitive_map_t &named_values, bool allow_stream_result) { - auto pending = PendingQuery(named_values, allow_stream_result); - if (pending->HasError()) { - return make_uniq(pending->GetErrorObject()); + if (!success) { + return make_uniq( + ErrorData(InvalidInputException("Attempting to execute an unsuccessfully prepared statement!"))); } - return pending->Execute(); + + try { + VerifyParameters(named_values, named_param_map); + } catch (const std::exception &ex) { + return make_uniq(ErrorData(ex)); + } + + PendingQueryParameters parameters; + parameters.parameters = &named_values; + D_ASSERT(data); + parameters.query_parameters.output_type = + allow_stream_result && data->properties.output_type == QueryResultOutputType::ALLOW_STREAMING + ? QueryResultOutputType::ALLOW_STREAMING + : QueryResultOutputType::FORCE_MATERIALIZED; + + return context->Execute(query, data, parameters); } unique_ptr PreparedStatement::Execute(vector &values, bool allow_stream_result) { - auto pending = PendingQuery(values, allow_stream_result); - if (pending->HasError()) { - return make_uniq(pending->GetErrorObject()); + case_insensitive_map_t named_values; + for (idx_t i = 0; i < values.size(); i++) { + named_values[std::to_string(i + 1)] = BoundParameterData(values[i]); } - return pending->Execute(); + return Execute(named_values, allow_stream_result); } unique_ptr PreparedStatement::PendingQuery(vector &values, bool allow_stream_result) { diff --git a/src/duckdb/src/main/secret/secret.cpp b/src/duckdb/src/main/secret/secret.cpp index 9a39b7176..1e53afb14 100644 --- a/src/duckdb/src/main/secret/secret.cpp +++ b/src/duckdb/src/main/secret/secret.cpp @@ -163,6 +163,11 @@ void KeyValueSecretReader::Initialize(const char **secret_types, idx_t secret_ty } } +KeyValueSecretReader::KeyValueSecretReader(const KeyValueSecret &secret_p, FileOpener &opener_p) : secret(secret_p) { + db = opener_p.TryGetDatabase(); + context = opener_p.TryGetClientContext(); +} + KeyValueSecretReader::KeyValueSecretReader(FileOpener &opener_p, optional_ptr info, const char **secret_types, idx_t secret_types_len) { db = opener_p.TryGetDatabase(); diff --git a/src/duckdb/src/main/settings/autogenerated_settings.cpp b/src/duckdb/src/main/settings/autogenerated_settings.cpp index d15157226..b876fdd8e 100644 --- a/src/duckdb/src/main/settings/autogenerated_settings.cpp +++ b/src/duckdb/src/main/settings/autogenerated_settings.cpp @@ -34,114 +34,11 @@ Value AccessModeSetting::GetSetting(const ClientContext &context) { return Value(StringUtil::Lower(EnumUtil::ToString(config.options.access_mode))); } -//===----------------------------------------------------------------------===// -// Allocator Background Threads -//===----------------------------------------------------------------------===// -void AllocatorBackgroundThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.allocator_background_threads = input.GetValue(); -} - -void AllocatorBackgroundThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.allocator_background_threads = DBConfigOptions().allocator_background_threads; -} - -Value AllocatorBackgroundThreadsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.allocator_background_threads); -} - -//===----------------------------------------------------------------------===// -// Allow Community Extensions -//===----------------------------------------------------------------------===// -void AllowCommunityExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.allow_community_extensions = input.GetValue(); -} - -void AllowCommunityExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.allow_community_extensions = DBConfigOptions().allow_community_extensions; -} - -Value AllowCommunityExtensionsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.allow_community_extensions); -} - //===----------------------------------------------------------------------===// // Allow Parser Override Extension //===----------------------------------------------------------------------===// -void AllowParserOverrideExtensionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.allow_parser_override_extension = input.GetValue(); -} - -void AllowParserOverrideExtensionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.allow_parser_override_extension = DBConfigOptions().allow_parser_override_extension; -} - -Value AllowParserOverrideExtensionSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.allow_parser_override_extension); -} - -//===----------------------------------------------------------------------===// -// Allow Unredacted Secrets -//===----------------------------------------------------------------------===// -void AllowUnredactedSecretsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.allow_unredacted_secrets = input.GetValue(); -} - -void AllowUnredactedSecretsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.allow_unredacted_secrets = DBConfigOptions().allow_unredacted_secrets; -} - -Value AllowUnredactedSecretsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.allow_unredacted_secrets); -} - -//===----------------------------------------------------------------------===// -// Allow Unsigned Extensions -//===----------------------------------------------------------------------===// -void AllowUnsignedExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.allow_unsigned_extensions = input.GetValue(); -} - -void AllowUnsignedExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.allow_unsigned_extensions = DBConfigOptions().allow_unsigned_extensions; -} - -Value AllowUnsignedExtensionsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.allow_unsigned_extensions); +void AllowParserOverrideExtensionSetting::OnSet(SettingCallbackInfo &info, Value ¶meter) { + EnumUtil::FromString(StringValue::Get(parameter)); } //===----------------------------------------------------------------------===// @@ -151,54 +48,6 @@ void ArrowOutputVersionSetting::OnSet(SettingCallbackInfo &info, Value ¶mete EnumUtil::FromString(StringValue::Get(parameter)); } -//===----------------------------------------------------------------------===// -// Autoinstall Extension Repository -//===----------------------------------------------------------------------===// -void AutoinstallExtensionRepositorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.autoinstall_extension_repo = input.GetValue(); -} - -void AutoinstallExtensionRepositorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.autoinstall_extension_repo = DBConfigOptions().autoinstall_extension_repo; -} - -Value AutoinstallExtensionRepositorySetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.autoinstall_extension_repo); -} - -//===----------------------------------------------------------------------===// -// Autoinstall Known Extensions -//===----------------------------------------------------------------------===// -void AutoinstallKnownExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.autoinstall_known_extensions = input.GetValue(); -} - -void AutoinstallKnownExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.autoinstall_known_extensions = DBConfigOptions().autoinstall_known_extensions; -} - -Value AutoinstallKnownExtensionsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.autoinstall_known_extensions); -} - -//===----------------------------------------------------------------------===// -// Autoload Known Extensions -//===----------------------------------------------------------------------===// -void AutoloadKnownExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.autoload_known_extensions = input.GetValue(); -} - -void AutoloadKnownExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.autoload_known_extensions = DBConfigOptions().autoload_known_extensions; -} - -Value AutoloadKnownExtensionsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.autoload_known_extensions); -} - //===----------------------------------------------------------------------===// // Checkpoint Threshold //===----------------------------------------------------------------------===// @@ -206,22 +55,6 @@ void CheckpointThresholdSetting::ResetGlobal(DatabaseInstance *db, DBConfig &con config.options.checkpoint_wal_size = DBConfigOptions().checkpoint_wal_size; } -//===----------------------------------------------------------------------===// -// Custom Extension Repository -//===----------------------------------------------------------------------===// -void CustomExtensionRepositorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.custom_extension_repo = input.GetValue(); -} - -void CustomExtensionRepositorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.custom_extension_repo = DBConfigOptions().custom_extension_repo; -} - -Value CustomExtensionRepositorySetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.custom_extension_repo); -} - //===----------------------------------------------------------------------===// // Custom User Agent //===----------------------------------------------------------------------===// @@ -275,66 +108,6 @@ void DebugWindowModeSetting::OnSet(SettingCallbackInfo &info, Value ¶meter) EnumUtil::FromString(StringValue::Get(parameter)); } -//===----------------------------------------------------------------------===// -// Disable Database Invalidation -//===----------------------------------------------------------------------===// -void DisableDatabaseInvalidationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.disable_database_invalidation = input.GetValue(); -} - -void DisableDatabaseInvalidationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.disable_database_invalidation = DBConfigOptions().disable_database_invalidation; -} - -Value DisableDatabaseInvalidationSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.disable_database_invalidation); -} - -//===----------------------------------------------------------------------===// -// Enable External Access -//===----------------------------------------------------------------------===// -void EnableExternalAccessSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.enable_external_access = input.GetValue(); -} - -void EnableExternalAccessSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.enable_external_access = DBConfigOptions().enable_external_access; -} - -Value EnableExternalAccessSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.enable_external_access); -} - -//===----------------------------------------------------------------------===// -// Enable H T T P Metadata Cache -//===----------------------------------------------------------------------===// -void EnableHTTPMetadataCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.http_metadata_cache_enable = input.GetValue(); -} - -void EnableHTTPMetadataCacheSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.http_metadata_cache_enable = DBConfigOptions().http_metadata_cache_enable; -} - -Value EnableHTTPMetadataCacheSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.http_metadata_cache_enable); -} - //===----------------------------------------------------------------------===// // Enable Progress Bar //===----------------------------------------------------------------------===// @@ -358,203 +131,32 @@ Value EnableProgressBarSetting::GetSetting(const ClientContext &context) { return Value::BOOLEAN(config.enable_progress_bar); } -//===----------------------------------------------------------------------===// -// Errors As J S O N -//===----------------------------------------------------------------------===// -void ErrorsAsJSONSetting::SetLocal(ClientContext &context, const Value &input) { - auto &config = ClientConfig::GetConfig(context); - config.errors_as_json = input.GetValue(); -} - -void ErrorsAsJSONSetting::ResetLocal(ClientContext &context) { - ClientConfig::GetConfig(context).errors_as_json = ClientConfig().errors_as_json; -} - -Value ErrorsAsJSONSetting::GetSetting(const ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - return Value::BOOLEAN(config.errors_as_json); -} - //===----------------------------------------------------------------------===// // Explain Output //===----------------------------------------------------------------------===// -void ExplainOutputSetting::SetLocal(ClientContext &context, const Value &input) { - auto &config = ClientConfig::GetConfig(context); - auto str_input = StringUtil::Upper(input.GetValue()); - config.explain_output_type = EnumUtil::FromString(str_input); -} - -void ExplainOutputSetting::ResetLocal(ClientContext &context) { - ClientConfig::GetConfig(context).explain_output_type = ClientConfig().explain_output_type; -} - -Value ExplainOutputSetting::GetSetting(const ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - return Value(StringUtil::Lower(EnumUtil::ToString(config.explain_output_type))); -} - -//===----------------------------------------------------------------------===// -// Extension Directory -//===----------------------------------------------------------------------===// -void ExtensionDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.extension_directory = input.GetValue(); -} - -void ExtensionDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.extension_directory = DBConfigOptions().extension_directory; -} - -Value ExtensionDirectorySetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.extension_directory); -} - -//===----------------------------------------------------------------------===// -// External Threads -//===----------------------------------------------------------------------===// -void ExternalThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!OnGlobalSet(db, config, input)) { - return; - } - config.options.external_threads = input.GetValue(); -} - -void ExternalThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!OnGlobalReset(db, config)) { - return; - } - config.options.external_threads = DBConfigOptions().external_threads; -} - -Value ExternalThreadsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::UBIGINT(config.options.external_threads); -} - -//===----------------------------------------------------------------------===// -// Home Directory -//===----------------------------------------------------------------------===// -void HomeDirectorySetting::ResetLocal(ClientContext &context) { - ClientConfig::GetConfig(context).home_directory = ClientConfig().home_directory; -} - -Value HomeDirectorySetting::GetSetting(const ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - return Value(config.home_directory); -} - -//===----------------------------------------------------------------------===// -// H T T P Proxy -//===----------------------------------------------------------------------===// -void HTTPProxySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.http_proxy = input.GetValue(); -} - -void HTTPProxySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.http_proxy = DBConfigOptions().http_proxy; -} - -Value HTTPProxySetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.http_proxy); -} - -//===----------------------------------------------------------------------===// -// H T T P Proxy Password -//===----------------------------------------------------------------------===// -void HTTPProxyPasswordSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.http_proxy_password = input.GetValue(); -} - -void HTTPProxyPasswordSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.http_proxy_password = DBConfigOptions().http_proxy_password; -} - -Value HTTPProxyPasswordSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.http_proxy_password); -} - -//===----------------------------------------------------------------------===// -// H T T P Proxy Username -//===----------------------------------------------------------------------===// -void HTTPProxyUsernameSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.http_proxy_username = input.GetValue(); -} - -void HTTPProxyUsernameSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.http_proxy_username = DBConfigOptions().http_proxy_username; -} - -Value HTTPProxyUsernameSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.http_proxy_username); +void ExplainOutputSetting::OnSet(SettingCallbackInfo &info, Value ¶meter) { + EnumUtil::FromString(StringValue::Get(parameter)); } //===----------------------------------------------------------------------===// -// Lock Configuration +// Force Bitpacking Mode //===----------------------------------------------------------------------===// -void LockConfigurationSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.lock_configuration = input.GetValue(); -} - -void LockConfigurationSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.lock_configuration = DBConfigOptions().lock_configuration; -} - -Value LockConfigurationSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.lock_configuration); +void ForceBitpackingModeSetting::OnSet(SettingCallbackInfo &info, Value ¶meter) { + EnumUtil::FromString(StringValue::Get(parameter)); } //===----------------------------------------------------------------------===// -// Max Expression Depth +// Lambda Syntax //===----------------------------------------------------------------------===// -void MaxExpressionDepthSetting::SetLocal(ClientContext &context, const Value &input) { - auto &config = ClientConfig::GetConfig(context); - config.max_expression_depth = input.GetValue(); -} - -void MaxExpressionDepthSetting::ResetLocal(ClientContext &context) { - ClientConfig::GetConfig(context).max_expression_depth = ClientConfig().max_expression_depth; -} - -Value MaxExpressionDepthSetting::GetSetting(const ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - return Value::UBIGINT(config.max_expression_depth); +void LambdaSyntaxSetting::OnSet(SettingCallbackInfo &info, Value ¶meter) { + EnumUtil::FromString(StringValue::Get(parameter)); } //===----------------------------------------------------------------------===// // Pin Threads //===----------------------------------------------------------------------===// -void PinThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - auto str_input = StringUtil::Upper(input.GetValue()); - config.options.pin_threads = EnumUtil::FromString(str_input); -} - -void PinThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.pin_threads = DBConfigOptions().pin_threads; -} - -Value PinThreadsSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(StringUtil::Lower(EnumUtil::ToString(config.options.pin_threads))); -} - -//===----------------------------------------------------------------------===// -// Scheduler Process Partial -//===----------------------------------------------------------------------===// -void SchedulerProcessPartialSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.scheduler_process_partial = input.GetValue(); -} - -void SchedulerProcessPartialSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.scheduler_process_partial = DBConfigOptions().scheduler_process_partial; -} - -Value SchedulerProcessPartialSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.scheduler_process_partial); +void PinThreadsSetting::OnSet(SettingCallbackInfo &info, Value ¶meter) { + EnumUtil::FromString(StringValue::Get(parameter)); } //===----------------------------------------------------------------------===// @@ -571,36 +173,4 @@ void ValidateExternalFileCacheSetting::OnSet(SettingCallbackInfo &info, Value &p EnumUtil::FromString(StringValue::Get(parameter)); } -//===----------------------------------------------------------------------===// -// Variant Minimum Shredding Size -//===----------------------------------------------------------------------===// -void VariantMinimumShreddingSize::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.variant_minimum_shredding_size = input.GetValue(); -} - -void VariantMinimumShreddingSize::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.variant_minimum_shredding_size = DBConfigOptions().variant_minimum_shredding_size; -} - -Value VariantMinimumShreddingSize::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BIGINT(config.options.variant_minimum_shredding_size); -} - -//===----------------------------------------------------------------------===// -// Zstd Min String Length -//===----------------------------------------------------------------------===// -void ZstdMinStringLengthSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.zstd_min_string_length = input.GetValue(); -} - -void ZstdMinStringLengthSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.zstd_min_string_length = DBConfigOptions().zstd_min_string_length; -} - -Value ZstdMinStringLengthSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::UBIGINT(config.options.zstd_min_string_length); -} - } // namespace duckdb diff --git a/src/duckdb/src/main/settings/custom_settings.cpp b/src/duckdb/src/main/settings/custom_settings.cpp index 9c5635815..cf05f7f4f 100644 --- a/src/duckdb/src/main/settings/custom_settings.cpp +++ b/src/duckdb/src/main/settings/custom_settings.cpp @@ -12,7 +12,6 @@ #include "duckdb/main/settings.hpp" #include "duckdb/common/enums/access_mode.hpp" -#include "duckdb/common/enums/cache_validation_mode.hpp" #include "duckdb/common/enum_util.hpp" #include "duckdb/catalog/catalog_search_path.hpp" #include "duckdb/common/string_util.hpp" @@ -48,10 +47,6 @@ constexpr const char *EnabledLogTypes::Name; constexpr const char *DisabledLogTypes::Name; constexpr const char *DisabledFilesystemsSetting::Name; -const string GetDefaultUserAgent() { - return StringUtil::Format("duckdb/%s(%s)", DuckDB::LibraryVersion(), DuckDB::Platform()); -} - namespace { template @@ -78,18 +73,10 @@ bool AccessModeSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, cons //===----------------------------------------------------------------------===// // Allocator Background Threads //===----------------------------------------------------------------------===// -bool AllocatorBackgroundThreadsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (db) { - TaskScheduler::GetScheduler(*db).SetAllocatorBackgroundThreads(input.GetValue()); - } - return true; -} - -bool AllocatorBackgroundThreadsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - if (db) { - TaskScheduler::GetScheduler(*db).SetAllocatorBackgroundThreads(DBConfigOptions().allocator_background_threads); +void AllocatorBackgroundThreadsSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (info.db) { + TaskScheduler::GetScheduler(*info.db).SetAllocatorBackgroundThreads(input.GetValue()); } - return true; } //===----------------------------------------------------------------------===// @@ -143,46 +130,10 @@ Value AllocatorFlushThresholdSetting::GetSetting(const ClientContext &context) { //===----------------------------------------------------------------------===// // Allow Community Extensions //===----------------------------------------------------------------------===// -bool AllowCommunityExtensionsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (db && !config.options.allow_community_extensions) { - auto new_value = input.GetValue(); - if (new_value) { - throw InvalidInputException("Cannot upgrade allow_community_extensions setting while database is running"); - } - return false; +void AllowCommunityExtensionsSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (info.db && input.GetValue()) { + throw InvalidInputException("Cannot change allow_community_extensions setting while database is running"); } - return true; -} - -bool AllowCommunityExtensionsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - if (db && !config.options.allow_community_extensions) { - if (DBConfigOptions().allow_community_extensions) { - throw InvalidInputException("Cannot upgrade allow_community_extensions setting while database is running"); - } - return false; - } - return true; -} - -//===----------------------------------------------------------------------===// -// Allow Parser Override -//===----------------------------------------------------------------------===// -bool AllowParserOverrideExtensionSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - auto new_value = input.GetValue(); - vector supported_options = {"default", "fallback", "strict", "strict_when_supported"}; - string supported_option_string; - for (const auto &option : supported_options) { - if (StringUtil::CIEquals(new_value, option)) { - return true; - } - } - throw InvalidInputException("Unrecognized value for parser override setting. Valid options are: %s", - StringUtil::Join(supported_options, ", ")); -} - -bool AllowParserOverrideExtensionSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - config.options.allow_parser_override_extension = "default"; - return true; } //===----------------------------------------------------------------------===// @@ -205,59 +156,35 @@ Value AllowPersistentSecretsSetting::GetSetting(const ClientContext &context) { //===----------------------------------------------------------------------===// // Allow Unredacted Secrets //===----------------------------------------------------------------------===// -bool AllowUnredactedSecretsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (db && input.GetValue()) { - throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running"); - } - return true; -} - -bool AllowUnredactedSecretsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - if (db) { +void AllowUnredactedSecretsSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if ((info.db || info.context) && input.GetValue()) { throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running"); } - return true; } //===----------------------------------------------------------------------===// // Disable Database Invalidation //===----------------------------------------------------------------------===// -bool DisableDatabaseInvalidationSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (db && input.GetValue()) { +void DisableDatabaseInvalidationSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (info.db || info.context) { throw InvalidInputException("Cannot change disable_database_invalidation setting while database is running"); } - return true; -} - -bool DisableDatabaseInvalidationSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - if (db) { - throw InvalidInputException("Cannot change disable_database_invalidation setting while database is running"); - } - return true; } //===----------------------------------------------------------------------===// // Allow Unsigned Extensions //===----------------------------------------------------------------------===// -bool AllowUnsignedExtensionsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (db && input.GetValue()) { - throw InvalidInputException("Cannot change allow_unsigned_extensions setting while database is running"); - } - return true; -} - -bool AllowUnsignedExtensionsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - if (db) { +void AllowUnsignedExtensionsSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (info.db && input.GetValue()) { throw InvalidInputException("Cannot change allow_unsigned_extensions setting while database is running"); } - return true; } //===----------------------------------------------------------------------===// // Allowed Directories //===----------------------------------------------------------------------===// void AllowedDirectoriesSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!config.options.enable_external_access) { + if (!Settings::Get(config)) { throw InvalidInputException("Cannot change allowed_directories when enable_external_access is disabled"); } if (!config.file_system) { @@ -271,7 +198,7 @@ void AllowedDirectoriesSetting::SetGlobal(DatabaseInstance *db, DBConfig &config } void AllowedDirectoriesSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!config.options.enable_external_access) { + if (!Settings::Get(config)) { throw InvalidInputException("Cannot change allowed_directories when enable_external_access is disabled"); } config.options.allowed_directories = DBConfigOptions().allowed_directories; @@ -290,7 +217,7 @@ Value AllowedDirectoriesSetting::GetSetting(const ClientContext &context) { // Allowed Paths //===----------------------------------------------------------------------===//void void AllowedPathsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!config.options.enable_external_access) { + if (!Settings::Get(config)) { throw InvalidInputException("Cannot change allowed_paths when enable_external_access is disabled"); } if (!config.file_system) { @@ -305,7 +232,7 @@ void AllowedPathsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, cons } void AllowedPathsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!config.options.enable_external_access) { + if (!Settings::Get(config)) { throw InvalidInputException("Cannot change allowed_paths when enable_external_access is disabled"); } config.options.allowed_paths = DBConfigOptions().allowed_paths; @@ -581,19 +508,9 @@ void CustomUserAgentSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) //===----------------------------------------------------------------------===// // Default Block Size //===----------------------------------------------------------------------===// -void DefaultBlockSizeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { +void DefaultBlockSizeSetting::OnSet(SettingCallbackInfo &, Value &input) { auto block_alloc_size = input.GetValue(); Storage::VerifyBlockAllocSize(block_alloc_size); - config.options.default_block_alloc_size = block_alloc_size; -} - -void DefaultBlockSizeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.default_block_alloc_size = DBConfigOptions().default_block_alloc_size; -} - -Value DefaultBlockSizeSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::UBIGINT(config.options.default_block_alloc_size); } //===----------------------------------------------------------------------===// @@ -674,12 +591,15 @@ void DisabledCompressionMethodsSetting::SetGlobal(DatabaseInstance *db, DBConfig disabled_compression_methods.clear(); break; } - auto compression_type = CompressionTypeFromString(param); - if (compression_type == CompressionType::COMPRESSION_UNCOMPRESSED) { - throw InvalidInputException("Uncompressed compression cannot be disabled"); - } - if (compression_type == CompressionType::COMPRESSION_AUTO) { - throw InvalidInputException("Unrecognized compression method \"%s\"", entry); + auto compression_type = EnumUtil::FromString(param); + switch (compression_type) { + case CompressionType::COMPRESSION_AUTO: + case CompressionType::COMPRESSION_CONSTANT: + case CompressionType::COMPRESSION_EMPTY: + case CompressionType::COMPRESSION_UNCOMPRESSED: + throw InvalidInputException("Compression method %s cannot be disabled", param); + default: + break; } disabled_compression_methods.push_back(compression_type); } @@ -759,83 +679,49 @@ Value DisabledOptimizersSetting::GetSetting(const ClientContext &context) { //===----------------------------------------------------------------------===// // Duckdb Api //===----------------------------------------------------------------------===// -void DuckDBAPISetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - auto new_value = input.GetValue(); - if (db) { +void DuckDBAPISetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (info.db) { throw InvalidInputException("Cannot change duckdb_api setting while database is running"); } - config.options.duckdb_api = new_value; -} - -void DuckDBAPISetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (db) { - throw InvalidInputException("Cannot change duckdb_api setting while database is running"); - } - config.options.duckdb_api = GetDefaultUserAgent(); -} - -Value DuckDBAPISetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.duckdb_api); } //===----------------------------------------------------------------------===// // Enable External Access //===----------------------------------------------------------------------===// -bool EnableExternalAccessSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!db) { - return true; +void EnableExternalAccessSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (!info.db) { + return; } if (input.GetValue()) { - throw InvalidInputException("Cannot change enable_external_access setting while database is running"); + throw InvalidInputException("Cannot enable external access while database is running"); } - if (db && config.options.enable_external_access) { + auto &config = info.config; + if (info.db && Settings::Get(*info.db)) { // we are turning off external access - add any already attached databases to the list of accepted paths - auto &db_manager = DatabaseManager::Get(*db); + auto &db_manager = DatabaseManager::Get(*info.db); auto attached_paths = db_manager.GetAttachedDatabasePaths(); for (auto &path : attached_paths) { config.AddAllowedPath(path); config.AddAllowedPath(path + ".wal"); - config.AddAllowedPath(path + ".checkpoint.wal"); - config.AddAllowedPath(path + ".recovery.wal"); + config.AddAllowedPath(path + ".wal.checkpoint"); + config.AddAllowedPath(path + ".wal.recovery"); } } if (config.options.use_temporary_directory && !config.options.temporary_directory.empty()) { // if temp directory is enabled we can also write there config.AddAllowedDirectory(config.options.temporary_directory); } - return true; -} - -bool EnableExternalAccessSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - if (db) { - throw InvalidInputException("Cannot change enable_external_access setting while database is running"); - } - return true; } //===----------------------------------------------------------------------===// // Enable External File Cache //===----------------------------------------------------------------------===// -void EnableExternalFileCacheSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - config.options.enable_external_file_cache = input.GetValue(); - if (db) { - ExternalFileCache::Get(*db).SetEnabled(config.options.enable_external_file_cache); - } -} - -void EnableExternalFileCacheSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.enable_external_file_cache = DBConfigOptions().enable_external_file_cache; - if (db) { - ExternalFileCache::Get(*db).SetEnabled(config.options.enable_external_file_cache); +void EnableExternalFileCacheSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (info.db) { + ExternalFileCache::Get(*info.db).SetEnabled(input.GetValue()); } } -Value EnableExternalFileCacheSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value(config.options.enable_external_file_cache); -} - //===----------------------------------------------------------------------===// // Enable Logging //===----------------------------------------------------------------------===// @@ -864,7 +750,12 @@ void ForceVariantShredding::SetGlobal(DatabaseInstance *_, DBConfig &config, con value.type().ToString()); } - auto logical_type = TransformStringToLogicalType(value.GetValue()); + auto logical_type = UnboundType::TryParseAndDefaultBind(value.GetValue()); + if (logical_type.id() == LogicalTypeId::INVALID) { + throw InvalidInputException("Could not parse the argument '%s' to 'force_variant_shredding' as a built in type", + value.GetValue()); + } + TypeVisitor::Contains(logical_type, [](const LogicalType &type) { if (type.IsNested()) { if (type.id() != LogicalTypeId::STRUCT && type.id() != LogicalTypeId::LIST) { @@ -1178,76 +1069,26 @@ bool EnableProgressBarSetting::OnLocalReset(ClientContext &context) { //===----------------------------------------------------------------------===// // External Threads //===----------------------------------------------------------------------===// -bool ExternalThreadsSetting::OnGlobalSet(DatabaseInstance *db, DBConfig &config, const Value &input) { - auto new_val = input.GetValue(); - if (new_val < 0) { - throw SyntaxException("Must have a non-negative number of external threads!"); - } - auto new_external_threads = NumericCast(new_val); - if (db) { - TaskScheduler::GetScheduler(*db).SetThreads(config.options.maximum_threads, new_external_threads); +void ExternalThreadsSetting::OnSet(SettingCallbackInfo &info, Value &input) { + auto new_external_threads = input.GetValue(); + if (info.db) { + TaskScheduler::GetScheduler(*info.db).SetThreads(info.config.options.maximum_threads, new_external_threads); } - return true; -} - -bool ExternalThreadsSetting::OnGlobalReset(DatabaseInstance *db, DBConfig &config) { - idx_t new_external_threads = DBConfigOptions().external_threads; - if (db) { - TaskScheduler::GetScheduler(*db).SetThreads(config.options.maximum_threads, new_external_threads); - } - return true; -} - -//===----------------------------------------------------------------------===// -// File Search Path -//===----------------------------------------------------------------------===// -void FileSearchPathSetting::SetLocal(ClientContext &context, const Value &input) { - auto parameter = input.ToString(); - auto &client_data = ClientData::Get(context); - client_data.file_search_path = parameter; -} - -void FileSearchPathSetting::ResetLocal(ClientContext &context) { - auto &client_data = ClientData::Get(context); - client_data.file_search_path.clear(); -} - -Value FileSearchPathSetting::GetSetting(const ClientContext &context) { - auto &client_data = ClientData::Get(context); - return Value(client_data.file_search_path); -} - -//===----------------------------------------------------------------------===// -// Force Bitpacking Mode -//===----------------------------------------------------------------------===// -void ForceBitpackingModeSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - auto mode_str = StringUtil::Lower(input.ToString()); - auto mode = BitpackingModeFromString(mode_str); - if (mode == BitpackingMode::INVALID) { - throw ParserException("Unrecognized option for force_bitpacking_mode, expected none, constant, constant_delta, " - "delta_for, or for"); - } - config.options.force_bitpacking_mode = mode; -} - -void ForceBitpackingModeSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.force_bitpacking_mode = DBConfigOptions().force_bitpacking_mode; -} - -Value ForceBitpackingModeSetting::GetSetting(const ClientContext &context) { - return Value(BitpackingModeToString(context.db->config.options.force_bitpacking_mode)); } //===----------------------------------------------------------------------===// // Force Compression //===----------------------------------------------------------------------===// -void ForceCompressionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { +void ForceCompressionSetting::OnSet(SettingCallbackInfo &info, Value &input) { auto compression = StringUtil::Lower(input.ToString()); if (compression == "none" || compression == "auto") { - config.options.force_compression = CompressionType::COMPRESSION_AUTO; + input = "auto"; } else { - auto compression_type = CompressionTypeFromString(compression); - //! FIXME: do we want to try to retrieve the AttachedDatabase here to get the StorageManager ?? + auto compression_type = EnumUtil::FromString(compression); + if (compression_type == CompressionType::COMPRESSION_CONSTANT || + compression_type == CompressionType::COMPRESSION_EMPTY) { + throw ParserException("auto / constant cannot be used for force_compression"); + } auto compression_availability_result = CompressionTypeIsAvailable(compression_type); if (!compression_availability_result.IsAvailable()) { if (compression_availability_result.IsDeprecated()) { @@ -1258,32 +1099,27 @@ void ForceCompressionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, CompressionTypeToString(compression_type)); } } - if (compression_type == CompressionType::COMPRESSION_AUTO) { - auto compression_types = StringUtil::Join(ListCompressionTypes(), ", "); - throw ParserException("Unrecognized option for PRAGMA force_compression, expected %s", compression_types); - } - config.options.force_compression = compression_type; } } -void ForceCompressionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - config.options.force_compression = DBConfigOptions().force_compression; -} - -Value ForceCompressionSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(*context.db); - return CompressionTypeToString(config.options.force_compression); -} - //===----------------------------------------------------------------------===// // Home Directory //===----------------------------------------------------------------------===// -void HomeDirectorySetting::SetLocal(ClientContext &context, const Value &input) { - auto &config = ClientConfig::GetConfig(context); - if (!input.IsNull() && FileSystem::GetFileSystem(context).IsRemoteFile(input.ToString())) { - throw InvalidInputException("Cannot set the home directory to a remote path"); +void HomeDirectorySetting::OnSet(SettingCallbackInfo &info, Value &input) { + optional_ptr fs; + if (info.context) { + fs = FileSystem::GetFileSystem(*info.context); + } else if (info.db) { + fs = FileSystem::GetFileSystem(*info.db); + } else { + fs = info.config.file_system.get(); + } + if (fs && !input.IsNull()) { + auto new_home_directory = input.ToString(); + if (fs->IsRemoteFile(new_home_directory)) { + throw InvalidInputException("Cannot set the home directory to a remote path"); + } } - config.home_directory = input.IsNull() ? string() : input.ToString(); } //===----------------------------------------------------------------------===// @@ -1345,50 +1181,24 @@ void IndexScanPercentageSetting::OnSet(SettingCallbackInfo &, Value &input) { } } -//===----------------------------------------------------------------------===// -// Lambda Syntax Setting -//===----------------------------------------------------------------------===// -void LambdaSyntaxSetting::SetLocal(ClientContext &context, const Value &input) { - auto setting_type = EnumUtil::FromString(input.ToString()); - auto &config = ClientConfig::GetConfig(context); - config.lambda_syntax = setting_type; -} - -void LambdaSyntaxSetting::ResetLocal(ClientContext &context) { - auto &config = ClientConfig::GetConfig(context); - config.lambda_syntax = LambdaSyntax::DEFAULT; -} - -Value LambdaSyntaxSetting::GetSetting(const ClientContext &context) { - const auto &config = ClientConfig::GetConfig(context); - return Value(EnumUtil::ToString(config.lambda_syntax)); -} - //===----------------------------------------------------------------------===// // Log Query Path //===----------------------------------------------------------------------===// -void LogQueryPathSetting::SetLocal(ClientContext &context, const Value &input) { - auto &client_data = ClientData::Get(context); +void LogQueryPathSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (!info.context) { + throw InvalidInputException("log_query_path can only be set when a context is present"); + } + auto &client_data = ClientData::Get(*info.context); auto path = input.ToString(); if (path.empty()) { // empty path: clean up query writer client_data.log_query_writer = nullptr; } else { - client_data.log_query_writer = make_uniq(FileSystem::GetFileSystem(context), path, + client_data.log_query_writer = make_uniq(FileSystem::GetFileSystem(*info.context), path, BufferedFileWriter::DEFAULT_OPEN_FLAGS); } } -void LogQueryPathSetting::ResetLocal(ClientContext &context) { - auto &client_data = ClientData::Get(context); - client_data.log_query_writer = nullptr; -} - -Value LogQueryPathSetting::GetSetting(const ClientContext &context) { - auto &client_data = ClientData::Get(context); - return client_data.log_query_writer ? Value(client_data.log_query_writer->path) : Value(); -} - //===----------------------------------------------------------------------===// // Max Memory //===----------------------------------------------------------------------===// @@ -1467,21 +1277,6 @@ void OrderedAggregateThresholdSetting::OnSet(SettingCallbackInfo &info, Value &i } } -//===----------------------------------------------------------------------===// -// Password -//===----------------------------------------------------------------------===// -void PasswordSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - // nop -} - -void PasswordSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - // nop -} - -Value PasswordSetting::GetSetting(const ClientContext &context) { - return Value(); -} - //===----------------------------------------------------------------------===// // Perfect Ht Threshold //===----------------------------------------------------------------------===// @@ -1719,7 +1514,7 @@ Value StreamingBufferSizeSetting::GetSetting(const ClientContext &context) { // Temp Directory //===----------------------------------------------------------------------===// void TempDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - if (!config.options.enable_external_access) { + if (!Settings::Get(config)) { throw PermissionException("Modifying the temp_directory has been disabled by configuration"); } config.options.temporary_directory = input.IsNull() ? "" : input.ToString(); @@ -1731,7 +1526,7 @@ void TempDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, con } void TempDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (!config.options.enable_external_access) { + if (!Settings::Get(config)) { throw PermissionException("Modifying the temp_directory has been disabled by configuration"); } config.SetDefaultTempDirectory(); @@ -1750,44 +1545,15 @@ Value TempDirectorySetting::GetSetting(const ClientContext &context) { //===----------------------------------------------------------------------===// // Temporary File Encryption //===----------------------------------------------------------------------===// -void TempFileEncryptionSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - auto setting = input.GetValue(); - if (config.options.temp_file_encryption == setting) { - // setting is the current setting - return; - } - - if (db) { - auto &buffer_manager = BufferManager::GetBufferManager(*db); - if (buffer_manager.HasFilesInTemporaryDirectory()) { - throw PermissionException("Existing temporary files found: Modifying the temp_file_encryption setting " - "while there are existing temporary files is disabled."); - } - } - - config.options.temp_file_encryption = setting; -} - -void TempFileEncryptionSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - if (config.options.temp_file_encryption == true) { - // setting is the current setting +void TempFileEncryptionSetting::OnSet(SettingCallbackInfo &info, Value &input) { + if (!info.db) { return; } - - if (db) { - auto &buffer_manager = BufferManager::GetBufferManager(*db); - if (buffer_manager.HasFilesInTemporaryDirectory()) { - throw PermissionException("Existing temporary files found: Modifying the temp_file_encryption setting " - "while there are existing temporary files is disabled."); - } + auto &buffer_manager = BufferManager::GetBufferManager(*info.db); + if (buffer_manager.HasFilesInTemporaryDirectory()) { + throw PermissionException("Existing temporary files found: Modifying the temp_file_encryption setting " + "while there are existing temporary files is disabled."); } - - config.options.temp_file_encryption = true; -} - -Value TempFileEncryptionSetting::GetSetting(const ClientContext &context) { - auto &config = DBConfig::GetConfig(context); - return Value::BOOLEAN(config.options.temp_file_encryption); } //===----------------------------------------------------------------------===// @@ -1800,7 +1566,7 @@ void ThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Val } auto new_maximum_threads = NumericCast(new_val); if (db) { - TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, config.options.external_threads); + TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, Settings::Get(config)); } config.options.maximum_threads = new_maximum_threads; } @@ -1808,7 +1574,7 @@ void ThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Val void ThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { idx_t new_maximum_threads = config.GetSystemMaxThreads(*config.file_system); if (db) { - TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, config.options.external_threads); + TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, Settings::Get(config)); } config.options.maximum_threads = new_maximum_threads; } @@ -1818,19 +1584,4 @@ Value ThreadsSetting::GetSetting(const ClientContext &context) { return Value::BIGINT(NumericCast(config.options.maximum_threads)); } -//===----------------------------------------------------------------------===// -// Username -//===----------------------------------------------------------------------===// -void UsernameSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) { - // nop -} - -void UsernameSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) { - // nop -} - -Value UsernameSetting::GetSetting(const ClientContext &context) { - return Value(); -} - } // namespace duckdb diff --git a/src/duckdb/src/main/settings/settings.cpp b/src/duckdb/src/main/settings/settings.cpp new file mode 100644 index 000000000..3ab1a7d4a --- /dev/null +++ b/src/duckdb/src/main/settings/settings.cpp @@ -0,0 +1,20 @@ +#include "duckdb/main/settings.hpp" +#include "duckdb/main/client_context.hpp" +#include "duckdb/main/config.hpp" + +namespace duckdb { + +bool Settings::TryGetSettingInternal(const ClientContext &context, idx_t setting_index, Value &result) { + return context.TryGetCurrentUserSetting(setting_index, result); +} + +bool Settings::TryGetSettingInternal(const DBConfig &config, idx_t setting_index, Value &result) { + auto lookup_result = config.TryGetCurrentUserSetting(setting_index, result); + return lookup_result; +} + +bool Settings::TryGetSettingInternal(const DatabaseInstance &db, idx_t setting_index, Value &result) { + return TryGetSettingInternal(DBConfig::GetConfig(db), setting_index, result); +} + +} // namespace duckdb diff --git a/src/duckdb/src/main/user_settings.cpp b/src/duckdb/src/main/user_settings.cpp new file mode 100644 index 000000000..9e3ccccc6 --- /dev/null +++ b/src/duckdb/src/main/user_settings.cpp @@ -0,0 +1,172 @@ +#include "duckdb/main/user_settings.hpp" +#include "duckdb/main/settings.hpp" +#include "duckdb/common/types/string.hpp" + +namespace duckdb { + +void UserSettingsMap::SetUserSetting(idx_t setting_index, Value target_value) { + if (setting_index >= settings.size()) { + settings.resize(setting_index + 1); + } + auto &generic_setting = settings[setting_index]; + generic_setting.is_set = true; + generic_setting.value = std::move(target_value); +} + +void UserSettingsMap::ClearSetting(idx_t setting_index) { + if (setting_index >= settings.size()) { + // never set + return; + } + auto &generic_setting = settings[setting_index]; + generic_setting.is_set = false; + generic_setting.value = Value(); +} + +bool UserSettingsMap::IsSet(idx_t setting_index) const { + if (setting_index >= settings.size()) { + // never set + return false; + } + return settings[setting_index].is_set; +} + +bool UserSettingsMap::TryGetSetting(idx_t setting_index, Value &result_value) const { + if (setting_index >= settings.size()) { + // never set + return false; + } + auto &generic_setting = settings[setting_index]; + if (!generic_setting.is_set) { + return false; + } + result_value = generic_setting.value; + return true; +} + +//===--------------------------------------------------------------------===// +// GlobalUserSettings +//===--------------------------------------------------------------------===// +GlobalUserSettings::GlobalUserSettings() : settings_version(0) { +} + +GlobalUserSettings::GlobalUserSettings(const GlobalUserSettings &other) + : settings_map(other.settings_map), extension_parameters(other.extension_parameters), + settings_version(other.settings_version.load()) { +} + +GlobalUserSettings &GlobalUserSettings::operator=(const GlobalUserSettings &other) { + settings_map = other.settings_map; + extension_parameters = other.extension_parameters; + settings_version = other.settings_version.load(); + return *this; +} + +void GlobalUserSettings::SetUserSetting(idx_t setting_index, Value target_value) { + lock_guard guard(lock); + settings_map.SetUserSetting(setting_index, std::move(target_value)); + ++settings_version; +} + +void GlobalUserSettings::ClearSetting(idx_t setting_index) { + lock_guard guard(lock); + settings_map.ClearSetting(setting_index); + ++settings_version; +} + +bool GlobalUserSettings::IsSet(idx_t setting_index) const { + lock_guard guard(lock); + return settings_map.IsSet(setting_index); +} + +SettingLookupResult GlobalUserSettings::TryGetSetting(idx_t setting_index, Value &result_value) const { + lock_guard guard(lock); + if (!settings_map.TryGetSetting(setting_index, result_value)) { + return SettingLookupResult(); + } + return SettingLookupResult(SettingScope::GLOBAL); +} + +bool GlobalUserSettings::HasExtensionOption(const string &name) const { + lock_guard l(lock); + return extension_parameters.find(name) != extension_parameters.end(); +} + +idx_t GlobalUserSettings::AddExtensionOption(const string &name, ExtensionOption extension_option) { + lock_guard l(lock); + auto setting_index = GeneratedSettingInfo::MaxSettingIndex + extension_parameters.size(); + extension_option.setting_index = setting_index; + extension_parameters.insert(make_pair(name, std::move(extension_option))); + ++settings_version; + return setting_index; +} + +case_insensitive_map_t GlobalUserSettings::GetExtensionSettings() const { + lock_guard l(lock); + return extension_parameters; +} + +bool GlobalUserSettings::TryGetExtensionOption(const String &name, ExtensionOption &result) const { + lock_guard l(lock); + auto entry = extension_parameters.find(name.ToStdString()); + if (entry == extension_parameters.end()) { + return false; + } + result = entry->second; + return true; +} + +shared_ptr GlobalUserSettings::GetSettings(shared_ptr &cache) const { + auto current_cache = cache.atomic_load(std::memory_order_relaxed); + auto current_version = settings_version.load(std::memory_order_relaxed); + if (current_cache && current_cache->version == current_version) { + // we have a cached version and it is up to date - done + return current_cache; + } + lock_guard guard(lock); + // check if another thread updated the cache while we were waiting for the lock + if (cache && current_version == cache->version) { + // already written - load + return cache; + } + auto new_cache = make_shared_ptr(settings_version, settings_map); + cache.atomic_store(new_cache); + return new_cache; +} + +CachedGlobalSettings::CachedGlobalSettings(idx_t version, UserSettingsMap settings_p) + : version(version), settings(std::move(settings_p)) { +} + +//===--------------------------------------------------------------------===// +// LocalUserSettings +//===--------------------------------------------------------------------===// +LocalUserSettings::~LocalUserSettings() { +} + +void LocalUserSettings::SetUserSetting(idx_t setting_index, Value target_value) { + settings_map.SetUserSetting(setting_index, std::move(target_value)); +} + +void LocalUserSettings::ClearSetting(idx_t setting_index) { + settings_map.ClearSetting(setting_index); +} + +bool LocalUserSettings::IsSet(idx_t setting_index) const { + return settings_map.IsSet(setting_index); +} + +SettingLookupResult LocalUserSettings::TryGetSetting(const GlobalUserSettings &global_settings, idx_t setting_index, + Value &result_value) const { + if (settings_map.TryGetSetting(setting_index, result_value)) { + return SettingLookupResult(SettingScope::LOCAL); + } + // look-up in global settings + auto cache = global_settings.GetSettings(global_settings_cache); + if (cache->settings.TryGetSetting(setting_index, result_value)) { + return SettingLookupResult(SettingScope::GLOBAL); + } + return SettingLookupResult(); +} + +} // namespace duckdb diff --git a/src/duckdb/src/main/valid_checker.cpp b/src/duckdb/src/main/valid_checker.cpp index d3fcd5bff..4afa56aaf 100644 --- a/src/duckdb/src/main/valid_checker.cpp +++ b/src/duckdb/src/main/valid_checker.cpp @@ -1,6 +1,5 @@ #include "duckdb/main/valid_checker.hpp" - -#include "duckdb/main/database.hpp" +#include "duckdb/main/settings.hpp" namespace duckdb { @@ -14,7 +13,7 @@ void ValidChecker::Invalidate(string error) { } bool ValidChecker::IsInvalidated() { - if (db.config.options.disable_database_invalidation) { + if (Settings::Get(db)) { return false; } return is_invalidated; diff --git a/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp b/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp index b5c422133..b4e92b7cd 100644 --- a/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp +++ b/src/duckdb/src/optimizer/build_probe_side_optimizer.cpp @@ -230,7 +230,7 @@ void BuildProbeSideOptimizer::VisitOperator(LogicalOperator &op) { // if the conditions have no equality, do not flip the children. // There is no physical join operator (yet) that can do an inequality right_semi/anti join. idx_t has_range = 0; - bool prefer_range_joins = DBConfig::GetSetting(context); + bool prefer_range_joins = Settings::Get(context); if (op.type == LogicalOperatorType::LOGICAL_ANY_JOIN || (op.Cast().HasEquality(has_range) && !prefer_range_joins)) { TryFlipJoinChildren(join); diff --git a/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp b/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp index 7098caae4..e31e9b445 100644 --- a/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp +++ b/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp @@ -13,6 +13,7 @@ #include "duckdb/planner/operator/logical_order.hpp" #include "duckdb/planner/operator/logical_projection.hpp" #include "duckdb/main/settings.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { @@ -82,7 +83,7 @@ void ColumnLifetimeAnalyzer::VisitOperator(LogicalOperator &op) { // FIXME: for now, we only push into the projection map for equality (hash) joins idx_t has_range = 0; - bool prefer_range_joins = DBConfig::GetSetting(optimizer.context); + bool prefer_range_joins = Settings::Get(optimizer.context); if (!comp_join.HasEquality(has_range) || prefer_range_joins) { return; } diff --git a/src/duckdb/src/optimizer/expression_heuristics.cpp b/src/duckdb/src/optimizer/expression_heuristics.cpp index 766ac8d88..0bba42962 100644 --- a/src/duckdb/src/optimizer/expression_heuristics.cpp +++ b/src/duckdb/src/optimizer/expression_heuristics.cpp @@ -222,7 +222,7 @@ idx_t ExpressionHeuristics::Cost(Expression &expr) { return 1000; } -idx_t ExpressionHeuristics::Cost(TableFilter &filter) { +idx_t ExpressionHeuristics::Cost(const TableFilter &filter) { switch (filter.filter_type) { case TableFilterType::DYNAMIC_FILTER: case TableFilterType::OPTIONAL_FILTER: diff --git a/src/duckdb/src/optimizer/filter_combiner.cpp b/src/duckdb/src/optimizer/filter_combiner.cpp index e2480b963..9b2f426c6 100644 --- a/src/duckdb/src/optimizer/filter_combiner.cpp +++ b/src/duckdb/src/optimizer/filter_combiner.cpp @@ -354,6 +354,10 @@ FilterPushdownResult FilterCombiner::TryPushdownConstantFilter(TableFilterSet &t if (!TryGetBoundColumnIndex(column_ids, expr, column_index)) { return FilterPushdownResult::NO_PUSHDOWN; } + if (column_index.IsPushdownExtract()) { + //! FIXME: can't push down filters on a column that has a pushed down extract currently + return FilterPushdownResult::NO_PUSHDOWN; + } auto &constant_list = constant_values.find(equiv_set)->second; for (auto &constant_cmp : constant_list) { @@ -400,6 +404,10 @@ FilterPushdownResult FilterCombiner::TryPushdownGenericExpression(LogicalGet &ge auto &column_ids = get.GetColumnIds(); auto expr_filter = make_uniq(std::move(filter_expr)); auto &column_index = column_ids[bindings[0].column_index]; + if (column_index.IsPushdownExtract()) { + //! FIXME: can't support filters on a pushed down extract currently + return FilterPushdownResult::NO_PUSHDOWN; + } get.table_filters.PushFilter(column_index, std::move(expr_filter)); return FilterPushdownResult::PUSHED_DOWN_FULLY; } @@ -426,6 +434,10 @@ FilterPushdownResult FilterCombiner::TryPushdownPrefixFilter(TableFilterSet &tab return FilterPushdownResult::NO_PUSHDOWN; } auto &column_index = column_ids[column_ref.binding.column_index]; + if (column_index.IsPushdownExtract()) { + //! FIXME: can't support filter pushdown on pushed down extract currently + return FilterPushdownResult::NO_PUSHDOWN; + } //! Replace prefix with a set of comparisons auto lower_bound = make_uniq(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(prefix_string)); table_filters.PushFilter(column_index, std::move(lower_bound)); @@ -457,6 +469,11 @@ FilterPushdownResult FilterCombiner::TryPushdownLikeFilter(TableFilterSet &table auto &column_ref = func.children[0]->Cast(); auto &constant_value_expr = func.children[1]->Cast(); auto &column_index = column_ids[column_ref.binding.column_index]; + if (column_index.IsPushdownExtract()) { + //! FIXME: can't support filter pushdown on pushed down extract currently + return FilterPushdownResult::NO_PUSHDOWN; + } + // constant value expr can sometimes be null. if so, push is not null filter, which will // make the filter unsatisfiable and return no results. if (constant_value_expr.value.IsNull()) { @@ -508,6 +525,11 @@ FilterPushdownResult FilterCombiner::TryPushdownInFilter(TableFilterSet &table_f } auto &column_ref = func.children[0]->Cast(); auto &column_index = column_ids[column_ref.binding.column_index]; + if (column_index.IsPushdownExtract()) { + //! FIXME: can't support filter pushdown on pushed down extract currently + return FilterPushdownResult::NO_PUSHDOWN; + } + //! check if all children are const expr bool children_constant = true; for (size_t i {1}; i < func.children.size(); i++) { @@ -603,6 +625,10 @@ FilterPushdownResult FilterCombiner::TryPushdownOrClause(TableFilterSet &table_f if (i == 0) { auto &col_id = column_ids[column_ref->binding.column_index]; column_id = col_id.GetPrimaryIndex(); + if (col_id.IsPushdownExtract()) { + //! FIXME: can't support filter pushdown on pushed down extract currently + return FilterPushdownResult::NO_PUSHDOWN; + } } else if (column_id != column_ids[column_ref->binding.column_index].GetPrimaryIndex()) { return FilterPushdownResult::NO_PUSHDOWN; } diff --git a/src/duckdb/src/optimizer/filter_pushdown.cpp b/src/duckdb/src/optimizer/filter_pushdown.cpp index 7c13386d9..1c1251f8c 100644 --- a/src/duckdb/src/optimizer/filter_pushdown.cpp +++ b/src/duckdb/src/optimizer/filter_pushdown.cpp @@ -9,6 +9,7 @@ #include "duckdb/planner/operator/logical_projection.hpp" #include "duckdb/planner/operator/logical_empty_result.hpp" #include "duckdb/planner/operator/logical_window.hpp" +#include "duckdb/planner/expression/bound_columnref_expression.hpp" namespace duckdb { diff --git a/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp b/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp index 767b918c4..39e60bd69 100644 --- a/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp +++ b/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp @@ -7,6 +7,7 @@ #include "duckdb/optimizer/join_order/plan_enumerator.hpp" #include "duckdb/planner/expression/list.hpp" #include "duckdb/planner/operator/list.hpp" +#include "duckdb/main/settings.hpp" namespace duckdb { @@ -25,7 +26,8 @@ JoinOrderOptimizer JoinOrderOptimizer::CreateChildOptimizer() { unique_ptr JoinOrderOptimizer::Optimize(unique_ptr plan, optional_ptr stats) { - if (depth > query_graph_manager.context.config.max_expression_depth) { + auto max_expression_depth = Settings::Get(query_graph_manager.context); + if (depth > max_expression_depth) { // Very deep plans will eventually consume quite some stack space // Returning the current plan is always a valid choice return plan; diff --git a/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp b/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp index ec39dbd05..07f103925 100644 --- a/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp +++ b/src/duckdb/src/optimizer/join_order/plan_enumerator.cpp @@ -470,7 +470,7 @@ void PlanEnumerator::InitLeafPlans() { // Moerkotte and Thomas Neumannn, see that paper for additional info/documentation bonus slides: // https://db.in.tum.de/teaching/ws1415/queryopt/chapter3.pdf?lang=de void PlanEnumerator::SolveJoinOrder() { - bool force_no_cross_product = DBConfig::GetSetting(query_graph_manager.context); + bool force_no_cross_product = Settings::Get(query_graph_manager.context); // first try to solve the join order exactly if (query_graph_manager.relation_manager.NumRelations() >= THRESHOLD_TO_SWAP_TO_APPROXIMATE) { SolveJoinOrderApproximately(); diff --git a/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp b/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp index 2db600c7a..b78341240 100644 --- a/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp +++ b/src/duckdb/src/optimizer/join_order/relation_statistics_helper.cpp @@ -443,7 +443,7 @@ RelationStats RelationStatisticsHelper::ExtractEmptyResultStats(LogicalEmptyResu return stats; } -idx_t RelationStatisticsHelper::InspectTableFilter(idx_t cardinality, idx_t column_index, TableFilter &filter, +idx_t RelationStatisticsHelper::InspectTableFilter(idx_t cardinality, idx_t column_index, const TableFilter &filter, BaseStatistics &base_stats) { auto cardinality_after_filters = cardinality; switch (filter.filter_type) { diff --git a/src/duckdb/src/optimizer/late_materialization.cpp b/src/duckdb/src/optimizer/late_materialization.cpp index 3b19b3612..6d1a06d9b 100644 --- a/src/duckdb/src/optimizer/late_materialization.cpp +++ b/src/duckdb/src/optimizer/late_materialization.cpp @@ -21,7 +21,7 @@ namespace duckdb { LateMaterialization::LateMaterialization(Optimizer &optimizer) : optimizer(optimizer) { - max_row_count = DBConfig::GetSetting(optimizer.context); + max_row_count = Settings::Get(optimizer.context); } vector LateMaterialization::ConstructRHS(unique_ptr &op) { @@ -371,7 +371,7 @@ bool LateMaterialization::TryLateMaterialization(unique_ptr &op } bool LateMaterialization::OptimizeLargeLimit(LogicalLimit &limit, idx_t limit_val, bool has_offset) { - if (!has_offset && !DBConfig::GetSetting(optimizer.context)) { + if (!has_offset && !Settings::Get(optimizer.context)) { // we avoid optimizing large limits if preserve insertion order is false // since the limit is executed in parallel anyway return false; diff --git a/src/duckdb/src/optimizer/optimizer.cpp b/src/duckdb/src/optimizer/optimizer.cpp index 97585c1f0..c2c4540c1 100644 --- a/src/duckdb/src/optimizer/optimizer.cpp +++ b/src/duckdb/src/optimizer/optimizer.cpp @@ -39,6 +39,7 @@ #include "duckdb/optimizer/late_materialization.hpp" #include "duckdb/optimizer/common_subplan_optimizer.hpp" #include "duckdb/optimizer/window_self_join.hpp" +#include "duckdb/optimizer/optimizer_extension.hpp" #include "duckdb/planner/binder.hpp" #include "duckdb/planner/planner.hpp" @@ -325,7 +326,7 @@ unique_ptr Optimizer::Optimize(unique_ptr plan this->plan = std::move(plan_p); - for (auto &pre_optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) { + for (auto &pre_optimizer_extension : OptimizerExtension::Iterate(context)) { RunOptimizer(OptimizerType::EXTENSION, [&]() { OptimizerExtensionInput input {GetContext(), *this, pre_optimizer_extension.optimizer_info.get()}; if (pre_optimizer_extension.pre_optimize_function) { @@ -336,7 +337,7 @@ unique_ptr Optimizer::Optimize(unique_ptr plan RunBuiltInOptimizers(); - for (auto &optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) { + for (auto &optimizer_extension : OptimizerExtension::Iterate(context)) { RunOptimizer(OptimizerType::EXTENSION, [&]() { OptimizerExtensionInput input {GetContext(), *this, optimizer_extension.optimizer_info.get()}; if (optimizer_extension.optimize_function) { diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp index ac4b6532a..d8c371c42 100644 --- a/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp +++ b/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp @@ -53,9 +53,10 @@ unique_ptr FilterPushdown::PushdownGet(unique_ptr(std::move(op)); } + auto &column_ids = get.GetColumnIds(); //! We generate the table filters that will be executed during the table scan vector pushdown_results; - get.table_filters = combiner.GenerateTableScanFilters(get.GetColumnIds(), pushdown_results); + get.table_filters = combiner.GenerateTableScanFilters(column_ids, pushdown_results); GenerateFilters(); diff --git a/src/duckdb/src/optimizer/pushdown/pushdown_outer_join.cpp b/src/duckdb/src/optimizer/pushdown/pushdown_outer_join.cpp index 648c5e3d4..12958def3 100644 --- a/src/duckdb/src/optimizer/pushdown/pushdown_outer_join.cpp +++ b/src/duckdb/src/optimizer/pushdown/pushdown_outer_join.cpp @@ -71,7 +71,7 @@ static unique_ptr ReplaceIn(unique_ptr expr, const expre } }); - return std::move(expr); + return expr; } //! True if replacing all the `args` expressions occurring in `expr` with a diff --git a/src/duckdb/src/optimizer/remove_unused_columns.cpp b/src/duckdb/src/optimizer/remove_unused_columns.cpp index 7b0e49c6b..8f859bf55 100644 --- a/src/duckdb/src/optimizer/remove_unused_columns.cpp +++ b/src/duckdb/src/optimizer/remove_unused_columns.cpp @@ -23,6 +23,7 @@ #include "duckdb/planner/operator/logical_set_operation.hpp" #include "duckdb/planner/operator/logical_simple.hpp" #include "duckdb/function/scalar/struct_utils.hpp" +#include "duckdb/function/scalar/variant_utils.hpp" #include "duckdb/function/scalar/nested_functions.hpp" #include @@ -337,54 +338,64 @@ static idx_t GetColumnIdsIndexForFilter(vector &column_ids, idx_t f return static_cast(std::distance(column_ids.begin(), it)); } -static ColumnIndex PathToIndex(const vector &path, optional_ptr> cast_expression) { - D_ASSERT(!path.empty()); - ColumnIndex index = ColumnIndex(path[0]); - reference current(index); - for (idx_t i = 1; i < path.size(); i++) { - current.get().AddChildIndex(ColumnIndex(path[i])); - current = current.get().GetChildIndex(0); +//! returns: found_path, depth of the found path +std::pair FindShortestMatchingPath(column_index_set &all_paths, + const ColumnIndex &full_path) { + idx_t depth = 0; + column_index_set::iterator entry; + + ColumnIndex copy; + if (full_path.HasPrimaryIndex()) { + copy = ColumnIndex(full_path.GetPrimaryIndex()); + } else { + copy = ColumnIndex(full_path.GetFieldName()); } - if (cast_expression) { - auto &cast = *cast_expression; - current.get().SetType(cast->return_type); + + reference path_iter(full_path); + reference copy_iter(copy); + while (true) { + if (path_iter.get().HasType()) { + copy_iter.get().SetType(path_iter.get().GetType()); + } + entry = all_paths.find(copy); + if (entry != all_paths.end()) { + //! Path found, we're done + return make_pair(entry, depth); + } + if (!path_iter.get().HasChildren()) { + break; + } + path_iter = path_iter.get().GetChildIndex(0); + + ColumnIndex new_child; + if (path_iter.get().HasPrimaryIndex()) { + new_child = ColumnIndex(path_iter.get().GetPrimaryIndex()); + } else { + new_child = ColumnIndex(path_iter.get().GetFieldName()); + } + + copy_iter.get().AddChildIndex(new_child); + copy_iter = copy_iter.get().GetChildIndex(0); + depth++; } - return index; + return make_pair(all_paths.end(), depth); } void RemoveUnusedColumns::WritePushdownExtractColumns( const ColumnBinding &binding, ReferencedColumn &col, idx_t original_idx, const LogicalType &column_type, - const std::function cast_type)> &callback) { + const std::function cast_type)> &callback) { //! For each struct extract, replace the expression with a BoundColumnRefExpression //! The expression references a binding created for the extracted path, 1 per unique path for (auto &struct_extract : col.struct_extracts) { //! Replace the struct extract expression at the right depth with a BoundColumnRefExpression - auto &full_path = struct_extract.extract_path; - idx_t depth = 0; - column_index_set::iterator entry; - ColumnIndex copy(full_path.GetPrimaryIndex()); - reference path_iter(full_path); - reference copy_iter(copy); - while (true) { - if (path_iter.get().HasType()) { - copy_iter.get().SetType(path_iter.get().GetType()); - } - entry = col.unique_paths.find(copy); - if (entry != col.unique_paths.end()) { - //! Path found, we're done - break; - } - if (!path_iter.get().HasChildren()) { - throw InternalException("This path wasn't found in the registered paths for this expression at all!?"); - } - path_iter = path_iter.get().GetChildIndex(0); - copy_iter.get().AddChildIndex(ColumnIndex(path_iter.get().GetPrimaryIndex())); - copy_iter = copy_iter.get().GetChildIndex(0); - depth++; + auto res = FindShortestMatchingPath(col.unique_paths, full_path); + auto entry = res.first; + auto depth = res.second; + if (entry == col.unique_paths.end()) { + throw InternalException("This path wasn't found in the registered paths for this expression at all!?"); } - D_ASSERT(entry != col.unique_paths.end()); D_ASSERT(struct_extract.components.size() > depth); auto &component = struct_extract.components[depth]; auto &expr = component.cast ? *component.cast : component.extract; @@ -432,7 +443,7 @@ static unique_ptr ConstructStructExtractFromPath(ClientContext &cont } path_iter = path_iter.get().GetChildIndex(0); } - return std::move(target); + return target; } void RemoveUnusedColumns::RewriteExpressions(LogicalProjection &proj, idx_t expression_count) { @@ -461,7 +472,7 @@ void RemoveUnusedColumns::RewriteExpressions(LogicalProjection &proj, idx_t expr //! Pushdown Extract is supported, emit a column for every field WritePushdownExtractColumns( entry->first, entry->second, i, column_type, - [&](const ColumnIndex &extract_path, optional_ptr cast_type) -> idx_t { + [&](const ColumnIndex &extract_path, optional_ptr cast_type) -> idx_t { auto target = make_uniq(column_type, original_binding); target->SetAlias(expr.GetAlias()); auto new_extract = ConstructStructExtractFromPath(context, std::move(target), extract_path); @@ -645,23 +656,24 @@ void RemoveUnusedColumns::RemoveColumnsFromLogicalGet(LogicalGet &get) { auto struct_column_index = old_column_ids[col_sel_idx].GetPrimaryIndex(); //! Pushdown Extract is supported, emit a column for every field - WritePushdownExtractColumns(entry->first, entry->second, col_sel_idx, column_type, - [&](const ColumnIndex &extract_path, optional_ptr cast_type) -> idx_t { - ColumnIndex new_index(struct_column_index, {extract_path}); - new_index.SetPushdownExtractType(column_type, cast_type); - - auto column_binding_index = new_column_ids.size(); - auto entry = child_map.find(new_index); - if (entry == child_map.end()) { - //! Adds the binding for the child only if it doesn't exist yet - entry = child_map.emplace(new_index, column_binding_index).first; - created_bindings[new_index.GetPrimaryIndex()]++; - - new_column_ids.emplace_back(std::move(new_index)); - original_ids.emplace_back(col_sel_idx); - } - return entry->second; - }); + WritePushdownExtractColumns( + entry->first, entry->second, col_sel_idx, column_type, + [&](const ColumnIndex &extract_path, optional_ptr cast_type) -> idx_t { + ColumnIndex new_index(struct_column_index, {extract_path}); + new_index.SetPushdownExtractType(column_type, cast_type); + + auto column_binding_index = new_column_ids.size(); + auto entry = child_map.find(new_index); + if (entry == child_map.end()) { + //! Adds the binding for the child only if it doesn't exist yet + entry = child_map.emplace(new_index, column_binding_index).first; + created_bindings[new_index.GetPrimaryIndex()]++; + + new_column_ids.emplace_back(std::move(new_index)); + original_ids.emplace_back(col_sel_idx); + } + return entry->second; + }); } if (new_column_ids.empty()) { // this generally means we are only interested in whether or not anything exists in the table (e.g. @@ -710,64 +722,126 @@ BaseColumnPrunerMode BaseColumnPruner::GetMode() const { return mode; } -bool BaseColumnPruner::HandleStructExtractRecursive(unique_ptr &expr_p, - optional_ptr &colref, - vector &indexes, - vector &expressions) { - auto &expr = *expr_p; - if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) { - return false; - } - auto &function = expr.Cast(); - if (function.function.name != "struct_extract_at" && function.function.name != "struct_extract" && - function.function.name != "array_extract") { - return false; +bool BaseColumnPruner::HandleStructExtract(unique_ptr &expr_p, + optional_ptr &colref, + reference &path_ref, + vector &expressions) { + auto &function = expr_p->Cast(); + auto &child = function.children[0]; + D_ASSERT(child->return_type.id() == LogicalTypeId::STRUCT); + auto &bind_data = function.bind_info->Cast(); + // struct extract, check if left child is a bound column ref + if (child->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) { + // column reference - check if it is a struct + auto &ref = child->Cast(); + if (ref.return_type.id() != LogicalTypeId::STRUCT) { + return false; + } + colref = &ref; + auto &path = path_ref.get(); + path.AddChildIndex(ColumnIndex(bind_data.index)); + path_ref = path.GetChildIndex(0); + expressions.emplace_back(expr_p); + return true; } - if (!function.bind_info) { + // not a column reference - try to handle this recursively + if (!HandleExtractRecursive(child, colref, path_ref, expressions)) { return false; } + auto &path = path_ref.get(); + path.AddChildIndex(ColumnIndex(bind_data.index)); + path_ref = path.GetChildIndex(0); + + expressions.emplace_back(expr_p); + return true; +} + +bool BaseColumnPruner::HandleVariantExtract(unique_ptr &expr_p, + optional_ptr &colref, + reference &path_ref, + vector &expressions) { + auto &function = expr_p->Cast(); auto &child = function.children[0]; - if (child->return_type.id() != LogicalTypeId::STRUCT) { + D_ASSERT(child->return_type.id() == LogicalTypeId::VARIANT); + auto &bind_data = function.bind_info->Cast(); + if (bind_data.component.lookup_mode != VariantChildLookupMode::BY_KEY) { + //! We don't push down variant extract on ARRAY values return false; } - auto &bind_data = function.bind_info->Cast(); - // struct extract, check if left child is a bound column ref + // variant extract, check if left child is a bound column ref if (child->GetExpressionClass() == ExpressionClass::BOUND_COLUMN_REF) { - // column reference - check if it is a struct + // column reference - check if it is a variant auto &ref = child->Cast(); - if (ref.return_type.id() != LogicalTypeId::STRUCT) { + if (ref.return_type.id() != LogicalTypeId::VARIANT) { return false; } colref = &ref; - indexes.push_back(bind_data.index); + + auto &path = path_ref.get(); + path.AddChildIndex(ColumnIndex(bind_data.component.key)); + path_ref = path.GetChildIndex(0); + expressions.emplace_back(expr_p); return true; } // not a column reference - try to handle this recursively - if (!HandleStructExtractRecursive(child, colref, indexes, expressions)) { + if (!HandleExtractRecursive(child, colref, path_ref, expressions)) { return false; } - indexes.push_back(bind_data.index); + + auto &path = path_ref.get(); + path.AddChildIndex(ColumnIndex(bind_data.component.key)); + path_ref = path.GetChildIndex(0); + expressions.emplace_back(expr_p); return true; } -bool BaseColumnPruner::HandleStructExtract(unique_ptr *expression, - optional_ptr> cast_expression) { +bool BaseColumnPruner::HandleExtractRecursive(unique_ptr &expr_p, + optional_ptr &colref, + reference &path_ref, + vector &expressions) { + auto &expr = *expr_p; + if (expr.GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) { + return false; + } + auto &function = expr.Cast(); + if (function.function.name != "struct_extract_at" && function.function.name != "struct_extract" && + function.function.name != "array_extract" && function.function.name != "variant_extract") { + return false; + } + if (!function.bind_info) { + return false; + } + auto &child = function.children[0]; + auto child_type = child->return_type.id(); + switch (child_type) { + case LogicalTypeId::STRUCT: + return HandleStructExtract(expr_p, colref, path_ref, expressions); + case LogicalTypeId::VARIANT: + return HandleVariantExtract(expr_p, colref, path_ref, expressions); + default: + return false; + } +} + +bool BaseColumnPruner::HandleExtractExpression(unique_ptr *expression, + optional_ptr> cast_expression) { optional_ptr colref; - vector indexes; vector expressions; - if (!HandleStructExtractRecursive(*expression, colref, indexes, expressions)) { + ColumnIndex path(0); + reference path_ref(path); + if (!HandleExtractRecursive(*expression, colref, path_ref, expressions)) { return false; } if (cast_expression) { auto &top_level = expressions.back(); top_level.cast = cast_expression; + path_ref.get().SetType((*cast_expression)->return_type); } - auto index = PathToIndex(indexes, cast_expression); - AddBinding(*colref, std::move(index), expressions); + AddBinding(*colref, path.GetChildIndex(0), expressions); return true; } @@ -779,8 +853,20 @@ void BaseColumnPruner::MergeChildColumns(vector ¤t_child_colu } // if we are already extract sub-fields, add it (if it is not there yet) for (auto &binding : current_child_columns) { - if (binding.GetPrimaryIndex() != new_child_column.GetPrimaryIndex()) { - continue; + if (binding.HasPrimaryIndex()) { + if (!new_child_column.HasPrimaryIndex()) { + continue; + } + if (binding.GetPrimaryIndex() != new_child_column.GetPrimaryIndex()) { + continue; + } + } else { + if (new_child_column.HasPrimaryIndex()) { + continue; + } + if (binding.GetFieldName() != new_child_column.GetFieldName()) { + continue; + } } // found a match: sub-field is already projected // check if we have child columns @@ -827,26 +913,13 @@ void ReferencedColumn::AddPath(const ColumnIndex &path) { } path.VerifySinglePath(); - //! Do not add the path if it is a child of an existing path - ColumnIndex copy(path.GetPrimaryIndex()); - reference path_iter(path); - reference copy_iter(copy); - while (true) { - if (path_iter.get().HasType()) { - copy_iter.get().SetType(path_iter.get().GetType()); - } - //! Create a subset of the path up to an increasing depth, so we can check if the parent path already exists - if (unique_paths.count(copy)) { - //! The parent path already exists, don't add the new path - return; - } - if (!path_iter.get().HasChildren()) { - break; - } - path_iter = path_iter.get().GetChildIndex(0); - copy_iter.get().AddChildIndex(ColumnIndex(path_iter.get().GetPrimaryIndex())); - copy_iter = copy_iter.get().GetChildIndex(0); + auto res = FindShortestMatchingPath(unique_paths, path); + auto entry = res.first; + if (entry != unique_paths.end()) { + //! The parent path already exists, don't add the new path + return; } + //! No parent path exists, but child paths could already be added, remove them if they exist auto it = unique_paths.begin(); for (; it != unique_paths.end();) { @@ -912,14 +985,14 @@ void BaseColumnPruner::VisitExpression(unique_ptr *expression) { //! Check if this is a struct extract wrapped in a cast optional_ptr> cast_child; if (TryGetCastChild(*expression, cast_child)) { - if (HandleStructExtract(cast_child.get(), expression)) { + if (HandleExtractExpression(cast_child.get(), expression)) { // already handled return; } } //! Check if this is a struct extract - if (HandleStructExtract(expression)) { + if (HandleExtractExpression(expression)) { // already handled return; } diff --git a/src/duckdb/src/optimizer/row_group_pruner.cpp b/src/duckdb/src/optimizer/row_group_pruner.cpp index 5d293bb52..558bac04f 100644 --- a/src/duckdb/src/optimizer/row_group_pruner.cpp +++ b/src/duckdb/src/optimizer/row_group_pruner.cpp @@ -8,6 +8,7 @@ #include "duckdb/planner/operator/logical_order.hpp" #include "duckdb/storage/table/row_group_reorderer.hpp" #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" +#include "duckdb/planner/expression/bound_columnref_expression.hpp" namespace duckdb { diff --git a/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp b/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp index 8b5a71dc8..2a0f67ebf 100644 --- a/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp +++ b/src/duckdb/src/optimizer/rule/timestamp_comparison.cpp @@ -5,6 +5,7 @@ #include "duckdb/common/constants.hpp" #include "duckdb/execution/expression_executor.hpp" #include "duckdb/planner/expression/bound_cast_expression.hpp" +#include "duckdb/planner/expression/bound_columnref_expression.hpp" #include "duckdb/planner/expression/bound_conjunction_expression.hpp" #include "duckdb/planner/expression/bound_comparison_expression.hpp" #include "duckdb/planner/expression/bound_constant_expression.hpp" diff --git a/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp b/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp index 9709a1290..9ee30747b 100644 --- a/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp +++ b/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp @@ -5,6 +5,10 @@ namespace duckdb { static unique_ptr StatisticsOperationsNumericNumericCast(const BaseStatistics &input, const LogicalType &target) { + // Bail out if the stats are not numeric + if (input.GetStatsType() != StatisticsType::NUMERIC_STATS) { + return nullptr; + } if (!NumericStats::HasMinMax(input)) { return nullptr; } diff --git a/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp b/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp index 708221883..362830447 100644 --- a/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp +++ b/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp @@ -15,7 +15,7 @@ namespace duckdb { -static void GetColumnIndex(unique_ptr &expr, idx_t &index, string &alias) { +static void GetColumnIndex(const unique_ptr &expr, idx_t &index, string &alias) { if (expr->type == ExpressionType::BOUND_REF) { auto &bound_ref = expr->Cast(); index = bound_ref.index; @@ -59,7 +59,7 @@ FilterPropagateResult StatisticsPropagator::PropagateTableFilter(ColumnBinding s return filter.CheckStatistics(stats); } -void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFilter &filter) { +void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, const TableFilter &filter) { // FIXME: update stats... switch (filter.filter_type) { case TableFilterType::CONJUNCTION_AND: { @@ -79,7 +79,7 @@ void StatisticsPropagator::UpdateFilterStatistics(BaseStatistics &input, TableFi } } -static bool IsConstantOrNullFilter(TableFilter &table_filter) { +static bool IsConstantOrNullFilter(const TableFilter &table_filter) { if (table_filter.filter_type != TableFilterType::EXPRESSION_FILTER) { return false; } @@ -91,7 +91,7 @@ static bool IsConstantOrNullFilter(TableFilter &table_filter) { return ConstantOrNull::IsConstantOrNull(func, Value::BOOLEAN(true)); } -static bool CanReplaceConstantOrNull(TableFilter &table_filter) { +static bool CanReplaceConstantOrNull(const TableFilter &table_filter) { if (!IsConstantOrNullFilter(table_filter)) { throw InternalException("CanReplaceConstantOrNull() called on unexepected Table Filter"); } diff --git a/src/duckdb/src/optimizer/topn_window_elimination.cpp b/src/duckdb/src/optimizer/topn_window_elimination.cpp index e0d9f3e19..25c69df3f 100644 --- a/src/duckdb/src/optimizer/topn_window_elimination.cpp +++ b/src/duckdb/src/optimizer/topn_window_elimination.cpp @@ -360,7 +360,7 @@ TopNWindowElimination::TryCreateUnnestOperator(unique_ptr op, if (params.limit <= 1) { // LIMIT 1 -> we do not need to unnest - return std::move(op); + return op; } // Create unnest expression for aggregate args @@ -420,10 +420,16 @@ TopNWindowElimination::CreateProjectionOperator(unique_ptr op, const auto op_column_bindings = op->GetColumnBindings(); vector> proj_exprs; - // Only project necessary group columns + // Only project necessary group columns, but in the same order as they appear in the aggregate operator. + // For that, we need the group_idxs ordered by value. + std::set ordered_group_projection_idxs; for (const auto &group_idx : group_idxs) { - proj_exprs.push_back( - make_uniq(op->types[group_idx.second], op_column_bindings[group_idx.second])); + ordered_group_projection_idxs.insert(group_idx.second); + } + + for (const idx_t group_projection_idx : ordered_group_projection_idxs) { + proj_exprs.push_back(make_uniq(op->types[group_projection_idx], + op_column_bindings[group_projection_idx])); } auto aggregate_column_ref = diff --git a/src/duckdb/src/optimizer/window_self_join.cpp b/src/duckdb/src/optimizer/window_self_join.cpp index a3879b27e..c0c8d2a51 100644 --- a/src/duckdb/src/optimizer/window_self_join.cpp +++ b/src/duckdb/src/optimizer/window_self_join.cpp @@ -4,6 +4,8 @@ #include "duckdb/planner/operator/logical_window.hpp" #include "duckdb/planner/operator/logical_comparison_join.hpp" #include "duckdb/planner/operator/logical_aggregate.hpp" +#include "duckdb/planner/operator/logical_dummy_scan.hpp" +#include "duckdb/planner/operator/logical_expression_get.hpp" #include "duckdb/planner/operator/logical_projection.hpp" #include "duckdb/planner/expression/bound_window_expression.hpp" #include "duckdb/planner/expression/bound_columnref_expression.hpp" @@ -17,6 +19,24 @@ namespace duckdb { class WindowSelfJoinTableRebinder : public LogicalOperatorVisitor { public: + static bool CanRebind(const LogicalOperator &op) { + switch (op.type) { + case LogicalOperatorType::LOGICAL_GET: + case LogicalOperatorType::LOGICAL_EXPRESSION_GET: + case LogicalOperatorType::LOGICAL_PROJECTION: + case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY: + case LogicalOperatorType::LOGICAL_DUMMY_SCAN: + case LogicalOperatorType::LOGICAL_FILTER: + if (!op.children.empty()) { + return CanRebind(*op.children[0]); + } + return true; + default: + break; + } + return false; + } + explicit WindowSelfJoinTableRebinder(Optimizer &optimizer) : optimizer(optimizer) { } @@ -46,6 +66,19 @@ class WindowSelfJoinTableRebinder : public LogicalOperatorVisitor { agg.aggregate_index = new_agg_idx; agg.group_index = new_grp_idx; } + if (op.type == LogicalOperatorType::LOGICAL_EXPRESSION_GET) { + auto &get = op.Cast(); + auto new_idx = optimizer.binder.GenerateTableIndex(); + table_map[get.table_index] = new_idx; + get.table_index = new_idx; + } + if (op.type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) { + auto &dummy = op.Cast(); + auto new_idx = optimizer.binder.GenerateTableIndex(); + table_map[dummy.table_index] = new_idx; + dummy.table_index = new_idx; + } + // TODO: Handle other operators defining tables if needed // But Get/Projection/Aggregate are most common in subplans. @@ -63,6 +96,46 @@ class WindowSelfJoinTableRebinder : public LogicalOperatorVisitor { } VisitExpressionChildren(**expression); } + + unique_ptr TranslateAggregate(const BoundWindowExpression &w_expr) { + auto agg_func = *w_expr.aggregate; + unique_ptr bind_info; + if (w_expr.bind_info) { + bind_info = w_expr.bind_info->Copy(); + } else { + bind_info = nullptr; + } + + vector> children; + for (auto &child : w_expr.children) { + auto child_copy = child->Copy(); + VisitExpression(&child_copy); // Update bindings + children.push_back(std::move(child_copy)); + } + + unique_ptr filter; + if (w_expr.filter_expr) { + filter = w_expr.filter_expr->Copy(); + VisitExpression(&filter); // Update bindings + } + + auto aggr_type = w_expr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT; + + auto result = make_uniq(std::move(agg_func), std::move(children), std::move(filter), + std::move(bind_info), aggr_type); + + if (!w_expr.arg_orders.empty()) { + result->order_bys = make_uniq(); + auto &orders = result->order_bys->orders; + for (auto &order : w_expr.arg_orders) { + auto order_copy = order.Copy(); + VisitExpression(&order_copy.expression); // Update bindings + orders.emplace_back(std::move(order_copy)); + } + } + + return std::move(result); + } }; WindowSelfJoinOptimizer::WindowSelfJoinOptimizer(Optimizer &optimizer) : optimizer(optimizer) { @@ -77,6 +150,26 @@ unique_ptr WindowSelfJoinOptimizer::Optimize(unique_ptr WindowSelfJoinOptimizer::OptimizeInternal(unique_ptr op, ColumnBindingReplacer &replacer) { if (op->type == LogicalOperatorType::LOGICAL_WINDOW) { @@ -85,23 +178,18 @@ unique_ptr WindowSelfJoinOptimizer::OptimizeInternal(unique_ptr // Check recursively window.children[0] = OptimizeInternal(std::move(window.children[0]), replacer); - if (window.expressions.size() != 1) { - return op; - } - if (window.expressions[0]->type != ExpressionType::WINDOW_AGGREGATE) { + if (!WindowSelfJoinTableRebinder::CanRebind(*window.children[0])) { return op; } - auto &w_expr = window.expressions[0]->Cast(); - if (w_expr.aggregate->name != "count" && w_expr.aggregate->name != "count_star") { - return op; - } - if (!w_expr.orders.empty()) { - return op; - } - if (w_expr.partitions.empty()) { - return op; + auto &w_expr0 = window.expressions[0]->Cast(); + for (auto &expr : window.expressions) { + auto &w_expr = expr->Cast(); + if (!CanOptimize(w_expr, w_expr0)) { + return op; + } } + auto &partitions = w_expr0.partitions; // --- Transformation --- @@ -119,34 +207,17 @@ unique_ptr WindowSelfJoinOptimizer::OptimizeInternal(unique_ptr vector> aggregates; // Create Aggregate Operator - for (auto &part : w_expr.partitions) { + for (auto &part : partitions) { auto part_copy = part->Copy(); rebinder.VisitExpression(&part_copy); // Update bindings groups.push_back(std::move(part_copy)); } - auto count_func = *w_expr.aggregate; - unique_ptr bind_info; - if (w_expr.bind_info) { - bind_info = w_expr.bind_info->Copy(); - } else { - bind_info = nullptr; - } - - vector> children; - for (auto &child : w_expr.children) { - auto child_copy = child->Copy(); - rebinder.VisitExpression(&child_copy); // Update bindings - children.push_back(std::move(child_copy)); + for (auto &expr : window.expressions) { + auto &w_expr = expr->Cast(); + aggregates.emplace_back(rebinder.TranslateAggregate(w_expr)); } - auto aggr_type = w_expr.distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT; - - auto agg_expr = make_uniq(std::move(count_func), std::move(children), nullptr, - std::move(bind_info), aggr_type); - - aggregates.push_back(std::move(agg_expr)); - // args: group_index, aggregate_index, ... auto agg_op = make_uniq(group_index, aggregate_index, std::move(aggregates)); @@ -161,12 +232,11 @@ unique_ptr WindowSelfJoinOptimizer::OptimizeInternal(unique_ptr // Inner Join on the partition keys auto join = make_uniq(JoinType::INNER); - for (size_t i = 0; i < w_expr.partitions.size(); ++i) { + for (size_t i = 0; i < partitions.size(); ++i) { JoinCondition cond; cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM; - cond.left = w_expr.partitions[i]->Copy(); - cond.right = - make_uniq(w_expr.partitions[i]->return_type, ColumnBinding(group_index, i)); + cond.left = partitions[i]->Copy(); + cond.right = make_uniq(partitions[i]->return_type, ColumnBinding(group_index, i)); join->conditions.push_back(std::move(cond)); } @@ -174,13 +244,14 @@ unique_ptr WindowSelfJoinOptimizer::OptimizeInternal(unique_ptr join->children.push_back(std::move(agg_op)); join->ResolveOperatorTypes(); - // Replace Count binding - // Old window column: (window.window_index, 0) - // New constant column: (aggregate_index, 0) - ColumnBinding old_binding(window.window_index, 0); - ColumnBinding new_binding(aggregate_index, 0); - - replacer.replacement_bindings.emplace_back(old_binding, new_binding); + // Replace aggregate bindings + // Old window column: (window.window_index, x) + // New constant column: (aggregate_index, x) + for (idx_t column_index = 0; column_index < window.expressions.size(); ++column_index) { + ColumnBinding old_binding(window.window_index, column_index); + ColumnBinding new_binding(aggregate_index, column_index); + replacer.replacement_bindings.emplace_back(old_binding, new_binding); + } return std::move(join); } else if (!op->children.empty()) { diff --git a/src/duckdb/src/parallel/executor.cpp b/src/duckdb/src/parallel/executor.cpp index 9a9cf4703..9ab72c3c7 100644 --- a/src/duckdb/src/parallel/executor.cpp +++ b/src/duckdb/src/parallel/executor.cpp @@ -8,6 +8,7 @@ #include "duckdb/execution/physical_operator.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/main/client_data.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/parallel/meta_pipeline.hpp" #include "duckdb/parallel/pipeline_complete_event.hpp" #include "duckdb/parallel/pipeline_event.hpp" @@ -593,7 +594,7 @@ PendingExecutionResult Executor::ExecuteTask(bool dry_run) { if (!HasError()) { // we (partially) processed a task and no exceptions were thrown // give back control to the caller - if (task && DBConfig::GetConfig(context).options.scheduler_process_partial) { + if (task && Settings::Get(context)) { auto &token = *task->token; TaskScheduler::GetScheduler(context).ScheduleTask(token, task); task.reset(); diff --git a/src/duckdb/src/parallel/pipeline.cpp b/src/duckdb/src/parallel/pipeline.cpp index 1e5a20b4a..d48cc1241 100644 --- a/src/duckdb/src/parallel/pipeline.cpp +++ b/src/duckdb/src/parallel/pipeline.cpp @@ -157,7 +157,7 @@ bool Pipeline::IsOrderDependent() const { return true; } } - if (!DBConfig::GetSetting(executor.context)) { + if (!Settings::Get(executor.context)) { return false; } if (sink && sink->SinkOrderDependent()) { @@ -255,6 +255,10 @@ void Pipeline::AddDependency(shared_ptr &pipeline) { pipeline->parents.push_back(weak_ptr(shared_from_this())); } +vector> Pipeline::GetDependencies() const { + return dependencies; +} + string Pipeline::ToString() const { TextTreeRenderer renderer; return renderer.ToString(*this); diff --git a/src/duckdb/src/parallel/pipeline_executor.cpp b/src/duckdb/src/parallel/pipeline_executor.cpp index 274dc8b99..7b1ad5424 100644 --- a/src/duckdb/src/parallel/pipeline_executor.cpp +++ b/src/duckdb/src/parallel/pipeline_executor.cpp @@ -262,8 +262,8 @@ PipelineExecuteResult PipelineExecutor::Execute(idx_t max_chunks) { } if (result == OperatorResultType::FINISHED) { + D_ASSERT(in_process_operators.empty()); exhausted_pipeline = true; - break; } } while (chunk_budget.Next()); diff --git a/src/duckdb/src/parallel/task_scheduler.cpp b/src/duckdb/src/parallel/task_scheduler.cpp index b5ed2db24..0a0635c70 100644 --- a/src/duckdb/src/parallel/task_scheduler.cpp +++ b/src/duckdb/src/parallel/task_scheduler.cpp @@ -5,6 +5,7 @@ #include "duckdb/common/numeric_utils.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/main/database.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/storage/block_allocator.hpp" #ifndef DUCKDB_NO_THREADS #include "concurrentqueue.h" @@ -226,9 +227,9 @@ ProducerToken::~ProducerToken() { TaskScheduler::TaskScheduler(DatabaseInstance &db) : db(db), queue(make_uniq()), allocator_flush_threshold(db.config.options.allocator_flush_threshold), - allocator_background_threads(db.config.options.allocator_background_threads), requested_thread_count(0), + allocator_background_threads(Settings::Get(db)), requested_thread_count(0), current_thread_count(1) { - SetAllocatorBackgroundThreads(db.config.options.allocator_background_threads); + SetAllocatorBackgroundThreads(allocator_background_threads); } TaskScheduler::~TaskScheduler() { @@ -299,8 +300,10 @@ void TaskScheduler::ExecuteForever(atomic *marker) { } } if (queue->Dequeue(task)) { - auto process_mode = config.options.scheduler_process_partial ? TaskExecutionMode::PROCESS_PARTIAL - : TaskExecutionMode::PROCESS_ALL; + auto process_mode = TaskExecutionMode::PROCESS_ALL; + if (Settings::Get(config)) { + process_mode = TaskExecutionMode::PROCESS_PARTIAL; + } auto execute_result = task->Execute(process_mode); switch (execute_result) { @@ -519,7 +522,8 @@ void TaskScheduler::RelaunchThreadsInternal(int32_t n) { auto &config = DBConfig::GetConfig(db); auto new_thread_count = NumericCast(n); if (threads.size() == new_thread_count) { - current_thread_count = NumericCast(threads.size() + config.options.external_threads); + auto external_threads = Settings::Get(config); + current_thread_count = NumericCast(threads.size() + external_threads); return; } if (threads.size() > new_thread_count) { @@ -542,9 +546,10 @@ void TaskScheduler::RelaunchThreadsInternal(int32_t n) { // Whether to pin threads to cores static constexpr idx_t THREAD_PIN_THRESHOLD = 64; - const auto pin_threads = db.config.options.pin_threads == ThreadPinMode::ON || - (db.config.options.pin_threads == ThreadPinMode::AUTO && - std::thread::hardware_concurrency() > THREAD_PIN_THRESHOLD); + auto pin_thread_mode = Settings::Get(db); + const auto pin_threads = + pin_thread_mode == ThreadPinMode::ON || + (pin_thread_mode == ThreadPinMode::AUTO && std::thread::hardware_concurrency() > THREAD_PIN_THRESHOLD); for (idx_t i = 0; i < create_new_threads; i++) { // launch a thread and assign it a cancellation marker auto marker = unique_ptr>(new atomic(true)); @@ -565,7 +570,8 @@ void TaskScheduler::RelaunchThreadsInternal(int32_t n) { markers.push_back(std::move(marker)); } } - current_thread_count = NumericCast(threads.size() + config.options.external_threads); + auto external_threads = Settings::Get(config); + current_thread_count = NumericCast(threads.size() + external_threads); BlockAllocator::Get(db).FlushAll(); #endif } diff --git a/src/duckdb/src/parser/expression/lambda_expression.cpp b/src/duckdb/src/parser/expression/lambda_expression.cpp index 2b14abd61..7e0a812a2 100644 --- a/src/duckdb/src/parser/expression/lambda_expression.cpp +++ b/src/duckdb/src/parser/expression/lambda_expression.cpp @@ -1,10 +1,10 @@ #include "duckdb/parser/expression/lambda_expression.hpp" +#include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/types/hash.hpp" +#include "duckdb/parser/expression/columnref_expression.hpp" #include "duckdb/parser/expression/function_expression.hpp" -#include "duckdb/common/serializer/serializer.hpp" - namespace duckdb { LambdaExpression::LambdaExpression() : ParsedExpression(ExpressionType::LAMBDA, ExpressionClass::LAMBDA) { diff --git a/src/duckdb/src/parser/expression/type_expression.cpp b/src/duckdb/src/parser/expression/type_expression.cpp new file mode 100644 index 000000000..22289eff7 --- /dev/null +++ b/src/duckdb/src/parser/expression/type_expression.cpp @@ -0,0 +1,132 @@ +#include "duckdb/parser/expression/type_expression.hpp" +#include "duckdb/common/exception.hpp" +#include "duckdb/common/types/value.hpp" +#include "duckdb/common/string_util.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/common/types/hash.hpp" +namespace duckdb { + +TypeExpression::TypeExpression(string catalog, string schema, string type_name, + vector> children_p) + : ParsedExpression(ExpressionType::TYPE, ExpressionClass::TYPE), catalog(std::move(catalog)), + schema(std::move(schema)), type_name(std::move(type_name)), children(std::move(children_p)) { + D_ASSERT(!this->type_name.empty()); +} + +TypeExpression::TypeExpression(string type_name, vector> children) + : TypeExpression(INVALID_CATALOG, INVALID_SCHEMA, std::move(type_name), std::move(children)) { +} + +TypeExpression::TypeExpression() : ParsedExpression(ExpressionType::TYPE, ExpressionClass::TYPE) { +} + +string TypeExpression::ToString() const { + string result; + if (!catalog.empty()) { + result += KeywordHelper::WriteOptionallyQuoted(catalog) + "."; + } + if (!schema.empty()) { + result += KeywordHelper::WriteOptionallyQuoted(schema) + "."; + } + + auto ¶ms = children; + + // LIST and ARRAY have special syntax + if (result.empty() && StringUtil::CIEquals(type_name, "LIST") && params.size() == 1) { + return params[0]->ToString() + "[]"; + } + if (result.empty() && StringUtil::CIEquals(type_name, "ARRAY") && params.size() == 2) { + auto &type_param = params[0]; + auto &size_param = params[1]; + return type_param->ToString() + "[" + size_param->ToString() + "]"; + } + // So does STRUCT, MAP and UNION + if (result.empty() && StringUtil::CIEquals(type_name, "STRUCT")) { + if (params.empty()) { + return "STRUCT"; + } + string struct_result = "STRUCT("; + for (idx_t i = 0; i < params.size(); i++) { + struct_result += KeywordHelper::WriteOptionallyQuoted(params[i]->GetAlias()) + " " + params[i]->ToString(); + if (i < params.size() - 1) { + struct_result += ", "; + } + } + struct_result += ")"; + return struct_result; + } + if (result.empty() && StringUtil::CIEquals(type_name, "UNION")) { + if (params.empty()) { + return "UNION"; + } + string union_result = "UNION("; + for (idx_t i = 0; i < params.size(); i++) { + union_result += KeywordHelper::WriteOptionallyQuoted(params[i]->GetAlias()) + " " + params[i]->ToString(); + if (i < params.size() - 1) { + union_result += ", "; + } + } + union_result += ")"; + return union_result; + } + + if (result.empty() && StringUtil::CIEquals(type_name, "MAP") && params.size() == 2) { + return "MAP(" + params[0]->ToString() + ", " + params[1]->ToString() + ")"; + } + + if (result.empty() && StringUtil::CIEquals(type_name, "VARCHAR") && !params.empty()) { + if (params.back()->HasAlias() && StringUtil::CIEquals(params.back()->GetAlias(), "collation")) { + // Special case for VARCHAR with collation + auto collate_expr = params.back()->Cast(); + return StringUtil::Format("VARCHAR COLLATE %s", SQLIdentifier(StringValue::Get(collate_expr.value))); + } + } + + result += KeywordHelper::WriteOptionallyQuoted(type_name, '"', true, KeywordCategory::KEYWORD_COL_NAME); + + if (!params.empty()) { + result += "("; + for (idx_t i = 0; i < params.size(); i++) { + result += params[i]->ToString(); + if (i < params.size() - 1) { + result += ", "; + } + } + result += ")"; + } + return result; +} + +unique_ptr TypeExpression::Copy() const { + vector> copy_children; + copy_children.reserve(children.size()); + for (const auto &child : children) { + copy_children.push_back(child->Copy()); + } + + auto copy = make_uniq(catalog, schema, type_name, std::move(copy_children)); + copy->CopyProperties(*this); + + return std::move(copy); +} + +bool TypeExpression::Equal(const TypeExpression &a, const TypeExpression &b) { + if (a.catalog != b.catalog || a.schema != b.schema || a.type_name != b.type_name) { + return false; + } + return ParsedExpression::ListEquals(a.children, b.children); +} + +void TypeExpression::Verify() const { + D_ASSERT(!type_name.empty()); +} + +hash_t TypeExpression::Hash() const { + hash_t result = ParsedExpression::Hash(); + result = CombineHash(result, duckdb::Hash(catalog.c_str())); + result = CombineHash(result, duckdb::Hash(schema.c_str())); + result = CombineHash(result, duckdb::Hash(type_name.c_str())); + return result; +} + +} // namespace duckdb diff --git a/src/duckdb/src/parser/keyword_helper.cpp b/src/duckdb/src/parser/keyword_helper.cpp index 80cea773b..fd488170f 100644 --- a/src/duckdb/src/parser/keyword_helper.cpp +++ b/src/duckdb/src/parser/keyword_helper.cpp @@ -4,15 +4,15 @@ namespace duckdb { -bool KeywordHelper::IsKeyword(const string &text) { - return Parser::IsKeyword(text) != KeywordCategory::KEYWORD_NONE; +bool KeywordHelper::IsKeyword(const string &text, KeywordCategory category) { + return Parser::IsKeyword(text) != category; } KeywordCategory KeywordHelper::KeywordCategoryType(const string &text) { return Parser::IsKeyword(text); } -bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps) { +bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps, KeywordCategory category) { for (size_t i = 0; i < text.size(); i++) { if (i > 0 && (text[i] >= '0' && text[i] <= '9')) { continue; @@ -30,7 +30,7 @@ bool KeywordHelper::RequiresQuotes(const string &text, bool allow_caps) { } return true; } - return IsKeyword(text); + return IsKeyword(text, category); } string KeywordHelper::EscapeQuotes(const string &text, char quote) { @@ -43,8 +43,8 @@ string KeywordHelper::WriteQuoted(const string &text, char quote) { return string(1, quote) + EscapeQuotes(text, quote) + string(1, quote); } -string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote, bool allow_caps) { - if (!RequiresQuotes(text, allow_caps)) { +string KeywordHelper::WriteOptionallyQuoted(const string &text, char quote, bool allow_caps, KeywordCategory category) { + if (!RequiresQuotes(text, allow_caps, category)) { return text; } return WriteQuoted(text, quote); diff --git a/src/duckdb/src/parser/parsed_data/alter_table_info.cpp b/src/duckdb/src/parser/parsed_data/alter_table_info.cpp index 8d50e3dd6..b0d3d8b27 100644 --- a/src/duckdb/src/parser/parsed_data/alter_table_info.cpp +++ b/src/duckdb/src/parser/parsed_data/alter_table_info.cpp @@ -671,4 +671,79 @@ string SetSortedByInfo::ToString() const { return result; } +//===--------------------------------------------------------------------===// +// SetTblPropertiesInfo +//===--------------------------------------------------------------------===// +SetTableOptionsInfo::SetTableOptionsInfo() : AlterTableInfo(AlterTableType::SET_TABLE_OPTIONS) { +} + +SetTableOptionsInfo::SetTableOptionsInfo(AlterEntryData data, + case_insensitive_map_t> table_options) + : AlterTableInfo(AlterTableType::SET_TABLE_OPTIONS, std::move(data)), table_options(std::move(table_options)) { +} + +SetTableOptionsInfo::~SetTableOptionsInfo() { +} + +unique_ptr SetTableOptionsInfo::Copy() const { + case_insensitive_map_t> table_options_copy; + for (auto &option : table_options) { + table_options_copy.emplace(option.first, option.second->Copy()); + } + return make_uniq(GetAlterEntryData(), std::move(table_options_copy)); +} + +string SetTableOptionsInfo::ToString() const { + string result = "ALTER TABLE "; + result += QualifierToString(catalog, schema, name); + result += " SET ("; + idx_t i = 0; + for (auto &entry : table_options) { + if (i > 0) { + result += ", "; + } + result += KeywordHelper::WriteQuoted(entry.first, '\'') + "=" + entry.second->ToString(); + i++; + } + result += ")"; + return result; +} + +//===--------------------------------------------------------------------===// +// SetTblPropertiesInfo +//===--------------------------------------------------------------------===// +ResetTableOptionsInfo::ResetTableOptionsInfo() : AlterTableInfo(AlterTableType::RESET_TABLE_OPTIONS) { +} + +ResetTableOptionsInfo::ResetTableOptionsInfo(AlterEntryData data, case_insensitive_set_t table_options) + : AlterTableInfo(AlterTableType::RESET_TABLE_OPTIONS, std::move(data)), table_options(std::move(table_options)) { +} + +ResetTableOptionsInfo::~ResetTableOptionsInfo() { +} + +unique_ptr ResetTableOptionsInfo::Copy() const { + case_insensitive_set_t table_options_copy; + for (auto &option : table_options) { + table_options_copy.emplace(option); + } + return make_uniq(GetAlterEntryData(), table_options_copy); +} + +string ResetTableOptionsInfo::ToString() const { + string result = "ALTER TABLE "; + result += QualifierToString(catalog, schema, name); + result += " RESET ("; + idx_t i = 0; + for (auto &entry : table_options) { + if (i > 0) { + result += ", "; + } + result += KeywordHelper::WriteQuoted(entry, '\''); + i++; + } + result += ")"; + return result; +} + } // namespace duckdb diff --git a/src/duckdb/src/parser/parsed_data/create_table_info.cpp b/src/duckdb/src/parser/parsed_data/create_table_info.cpp index 539f08ba6..68a5ee6d8 100644 --- a/src/duckdb/src/parser/parsed_data/create_table_info.cpp +++ b/src/duckdb/src/parser/parsed_data/create_table_info.cpp @@ -23,6 +23,15 @@ unique_ptr CreateTableInfo::Copy() const { for (auto &constraint : constraints) { result->constraints.push_back(constraint->Copy()); } + for (auto &partition : partition_keys) { + result->partition_keys.push_back(partition->Copy()); + } + for (auto &order : sort_keys) { + result->sort_keys.push_back(order->Copy()); + } + for (auto &option : options) { + result->options.emplace(option.first, option.second->Copy()); + } if (query) { result->query = unique_ptr_cast(query->Copy()); } @@ -37,8 +46,34 @@ string CreateTableInfo::ToString() const { ret += TableCatalogEntry::ColumnNamesToSQL(columns); ret += " AS " + query->ToString(); } else { - ret += TableCatalogEntry::ColumnsToSQL(columns, constraints) + ";"; + ret += TableCatalogEntry::ColumnsToSQL(columns, constraints); + if (!partition_keys.empty()) { + ret += " PARTITIONED BY ("; + for (auto &partition : partition_keys) { + ret += partition->ToString() + ","; + } + ret.pop_back(); + ret += ")"; + } + if (!sort_keys.empty()) { + ret += " SORTED BY ("; + for (auto &order : sort_keys) { + ret += order->ToString() + ","; + } + ret.pop_back(); + ret += ")"; + } + if (!options.empty()) { + ret += " WITH ("; + for (auto &entry : options) { + ret += "'" + entry.first + "'=" + entry.second->ToString() + ","; + } + ret.pop_back(); + ret += ")"; + } + ret += ";"; } + return ret; } diff --git a/src/duckdb/src/parser/parsed_data/create_type_info.cpp b/src/duckdb/src/parser/parsed_data/create_type_info.cpp index c48799402..95d9bee19 100644 --- a/src/duckdb/src/parser/parsed_data/create_type_info.cpp +++ b/src/duckdb/src/parser/parsed_data/create_type_info.cpp @@ -41,13 +41,6 @@ string CreateTypeInfo::ToString() const { // CREATE TYPE mood AS ENUM (SELECT 'happy') D_ASSERT(query); result += " AS ENUM (" + query->ToString() + ")"; - } else if (type.id() == LogicalTypeId::USER) { - result += " AS "; - auto extra_info = type.AuxInfo(); - D_ASSERT(extra_info); - D_ASSERT(extra_info->type == ExtraTypeInfoType::USER_TYPE_INFO); - auto &user_info = extra_info->Cast(); - result += QualifierToString(user_info.catalog, user_info.schema, user_info.user_type_name); } else { result += " AS "; result += type.ToString(); diff --git a/src/duckdb/src/parser/parsed_expression.cpp b/src/duckdb/src/parser/parsed_expression.cpp index 2732e760c..5d270b8ff 100644 --- a/src/duckdb/src/parser/parsed_expression.cpp +++ b/src/duckdb/src/parser/parsed_expression.cpp @@ -87,6 +87,8 @@ bool ParsedExpression::Equals(const BaseExpression &other) const { return SubqueryExpression::Equal(Cast(), other.Cast()); case ExpressionClass::WINDOW: return WindowExpression::Equal(Cast(), other.Cast()); + case ExpressionClass::TYPE: + return TypeExpression::Equal(Cast(), other.Cast()); default: throw SerializationException("Unsupported type for expression comparison!"); } diff --git a/src/duckdb/src/parser/parsed_expression_iterator.cpp b/src/duckdb/src/parser/parsed_expression_iterator.cpp index f5746f9f7..f654bcf90 100644 --- a/src/duckdb/src/parser/parsed_expression_iterator.cpp +++ b/src/duckdb/src/parser/parsed_expression_iterator.cpp @@ -84,6 +84,13 @@ void ParsedExpressionIterator::EnumerateChildren( } break; } + case ExpressionClass::TYPE: { + auto &type_expr = expr.Cast(); + for (auto &child : type_expr.GetChildren()) { + callback(child); + } + break; + } case ExpressionClass::LAMBDA: { auto &lambda_expr = expr.Cast(); callback(lambda_expr.lhs); diff --git a/src/duckdb/src/parser/parser.cpp b/src/duckdb/src/parser/parser.cpp index 36b977c6a..b299f3a6c 100644 --- a/src/duckdb/src/parser/parser.cpp +++ b/src/duckdb/src/parser/parser.cpp @@ -1,5 +1,6 @@ #include "duckdb/parser/parser.hpp" +#include "duckdb/main/extension_callback_manager.hpp" #include "duckdb/parser/group_by_node.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" #include "duckdb/parser/parser_extension.hpp" @@ -11,6 +12,7 @@ #include "duckdb/parser/tableref/expressionlistref.hpp" #include "duckdb/parser/transformer.hpp" #include "parser/parser.hpp" + #include "postgres_parser.hpp" namespace duckdb { @@ -229,7 +231,6 @@ void Parser::ParseQuery(const string &query) { Transformer transformer(options); string parser_error; optional_idx parser_error_location; - string parser_override_option = StringUtil::Lower(options.parser_override_setting); { // check if there are any unicode spaces in the string string new_query; @@ -241,11 +242,11 @@ void Parser::ParseQuery(const string &query) { } { if (options.extensions) { - for (auto &ext : *options.extensions) { + for (auto &ext : options.extensions->ParserExtensions()) { if (!ext.parser_override) { continue; } - if (StringUtil::CIEquals(parser_override_option, "default")) { + if (options.parser_override_setting == AllowParserOverride::DEFAULT_OVERRIDE) { continue; } auto result = ext.parser_override(ext.parser_info.get(), query); @@ -253,17 +254,20 @@ void Parser::ParseQuery(const string &query) { statements = std::move(result.statements); return; } - if (StringUtil::CIEquals(parser_override_option, "strict")) { + if (options.parser_override_setting == AllowParserOverride::STRICT_OVERRIDE) { ThrowParserOverrideError(result); } - if (StringUtil::CIEquals(parser_override_option, "strict_when_supported")) { + if (options.parser_override_setting == AllowParserOverride::STRICT_WHEN_SUPPORTED) { auto statement = GetStatement(query); if (!statement) { break; } bool is_supported = false; switch (statement->type) { + case StatementType::ANALYZE_STATEMENT: + case StatementType::VACUUM_STATEMENT: case StatementType::CALL_STATEMENT: + case StatementType::MERGE_INTO_STATEMENT: case StatementType::TRANSACTION_STATEMENT: case StatementType::VARIABLE_SET_STATEMENT: case StatementType::LOAD_STATEMENT: @@ -273,6 +277,8 @@ void Parser::ParseQuery(const string &query) { case StatementType::DROP_STATEMENT: case StatementType::ALTER_STATEMENT: case StatementType::PRAGMA_STATEMENT: + case StatementType::INSERT_STATEMENT: + case StatementType::UPDATE_STATEMENT: case StatementType::COPY_DATABASE_STATEMENT: is_supported = true; break; @@ -299,7 +305,7 @@ void Parser::ParseQuery(const string &query) { if (is_supported) { ThrowParserOverrideError(result); } - } else if (StringUtil::CIEquals(parser_override_option, "fallback")) { + } else if (options.parser_override_setting == AllowParserOverride::FALLBACK_OVERRIDE) { continue; } } @@ -334,7 +340,7 @@ void Parser::ParseQuery(const string &query) { // no-op // return here would require refactoring into another function. o.w. will just no-op in order to run wrap up // code at the end of this function - } else if (!options.extensions || options.extensions->empty()) { + } else if (!options.extensions || !options.extensions->HasParserExtensions()) { throw ParserException::SyntaxError(query, parser_error, parser_error_location); } else { // split sql string into statements and re-parse using extension @@ -370,7 +376,7 @@ void Parser::ParseQuery(const string &query) { // LCOV_EXCL_START // let extensions parse the statement which DuckDB failed to parse bool parsed_single_statement = false; - for (auto &ext : *options.extensions) { + for (auto &ext : options.extensions->ParserExtensions()) { D_ASSERT(!parsed_single_statement); if (!ext.parse_function) { continue; diff --git a/src/duckdb/src/parser/query_node/set_operation_node.cpp b/src/duckdb/src/parser/query_node/set_operation_node.cpp index 30d36defc..9ab492ed5 100644 --- a/src/duckdb/src/parser/query_node/set_operation_node.cpp +++ b/src/duckdb/src/parser/query_node/set_operation_node.cpp @@ -127,7 +127,7 @@ unique_ptr SetOperationNode::SerializeChildNode(Serializer &serialize } bool SetOperationNode::SerializeChildList(Serializer &serializer) const { - return serializer.ShouldSerialize(6); + return serializer.ShouldSerialize(7); } } // namespace duckdb diff --git a/src/duckdb/src/parser/tableref/pivotref.cpp b/src/duckdb/src/parser/tableref/pivotref.cpp index 8874fdee7..ffcc0ad38 100644 --- a/src/duckdb/src/parser/tableref/pivotref.cpp +++ b/src/duckdb/src/parser/tableref/pivotref.cpp @@ -2,6 +2,15 @@ #include "duckdb/parser/expression_util.hpp" #include "duckdb/common/limits.hpp" +#include "duckdb/common/exception/conversion_exception.hpp" +#include "duckdb/parser/expression/cast_expression.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/function_expression.hpp" +#include "duckdb/parser/expression/columnref_expression.hpp" +#include "duckdb/common/serializer/serializer.hpp" +#include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/common/types/value.hpp" + namespace duckdb { //===--------------------------------------------------------------------===// @@ -129,6 +138,169 @@ PivotColumnEntry PivotColumnEntry::Copy() const { return result; } +static bool TryFoldConstantForBackwardsCompatability(const ParsedExpression &expr, Value &value) { + switch (expr.GetExpressionType()) { + case ExpressionType::FUNCTION: { + auto &function = expr.Cast(); + if (function.function_name == "struct_pack") { + unordered_set unique_names; + child_list_t values; + values.reserve(function.children.size()); + for (const auto &child : function.children) { + if (!unique_names.insert(child->GetAlias()).second) { + return false; + } + Value child_value; + if (!TryFoldConstantForBackwardsCompatability(*child, child_value)) { + return false; + } + values.emplace_back(child->GetAlias(), std::move(child_value)); + } + value = Value::STRUCT(std::move(values)); + return true; + } else if (function.function_name == "list_value") { + vector values; + values.reserve(function.children.size()); + for (const auto &child : function.children) { + Value child_value; + if (!TryFoldConstantForBackwardsCompatability(*child, child_value)) { + return false; + } + values.emplace_back(std::move(child_value)); + } + + // figure out child type + LogicalType child_type(LogicalTypeId::SQLNULL); + for (auto &child_value : values) { + child_type = LogicalType::ForceMaxLogicalType(child_type, child_value.type()); + } + + // finally create the list + value = Value::LIST(child_type, values); + return true; + } else if (function.function_name == "map") { + Value keys; + if (!TryFoldConstantForBackwardsCompatability(*function.children[0], keys)) { + return false; + } + + Value values; + if (!TryFoldConstantForBackwardsCompatability(*function.children[1], values)) { + return false; + } + + vector keys_unpacked = ListValue::GetChildren(keys); + vector values_unpacked = ListValue::GetChildren(values); + + value = Value::MAP(ListType::GetChildType(keys.type()), ListType::GetChildType(values.type()), + keys_unpacked, values_unpacked); + return true; + } else { + return false; + } + } + case ExpressionType::VALUE_CONSTANT: { + auto &constant = expr.Cast(); + value = constant.value; + return true; + } + case ExpressionType::OPERATOR_CAST: { + auto &cast = expr.Cast(); + Value dummy_value; + if (!TryFoldConstantForBackwardsCompatability(*cast.child, dummy_value)) { + return false; + } + + // Try to default bind cast + LogicalType cast_type; + try { + cast_type = UnboundType::TryDefaultBind(cast.cast_type); + } catch (...) { + return false; + } + + if (cast_type == LogicalType::INVALID || cast_type == LogicalTypeId::UNBOUND) { + return false; + } + + string error_message; + if (!dummy_value.DefaultTryCastAs(cast_type, value, &error_message)) { + return false; + } + return true; + } + default: + return false; + } +} + +static bool TryFoldForBackwardsCompatibility(const unique_ptr &expr, vector &values) { + if (!expr) { + return true; + } + + switch (expr->GetExpressionType()) { + case ExpressionType::COLUMN_REF: { + auto &colref = expr->Cast(); + if (colref.IsQualified()) { + return false; + } + values.emplace_back(colref.GetColumnName()); + return true; + } + case ExpressionType::FUNCTION: { + auto &function = expr->Cast(); + if (function.function_name != "row") { + return false; + } + for (auto &child : function.children) { + if (!TryFoldForBackwardsCompatibility(child, values)) { + return false; + } + } + return true; + } + default: { + Value val; + if (!TryFoldConstantForBackwardsCompatability(*expr, val)) { + return false; + } + values.push_back(std::move(val)); + return true; + } + } +} + +void PivotColumnEntry::Serialize(Serializer &serializer) const { + if (serializer.ShouldSerialize(7) || !expr) { + serializer.WritePropertyWithDefault>(100, "values", values); + serializer.WritePropertyWithDefault>(101, "star_expr", expr); + serializer.WritePropertyWithDefault(102, "alias", alias); + } else { + // We used to only support constant values in pivot entries, and folded expressions in the + // transformer. So we need to seriaize in a backwards compatible way here by trying to fold + // the expression back to constant values. + vector dummy_values; + if (!TryFoldForBackwardsCompatibility(expr, dummy_values)) { + throw SerializationException( + "Cannot serialize arbitrary expression pivot entries when targeting database storage version '%s'", + serializer.GetOptions().serialization_compatibility.duckdb_version); + ; + } + serializer.WritePropertyWithDefault>(100, "values", dummy_values); + serializer.WritePropertyWithDefault>(101, "star_expr", nullptr); + serializer.WritePropertyWithDefault(102, "alias", alias); + } +} + +PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &deserializer) { + PivotColumnEntry result; + deserializer.ReadPropertyWithDefault>(100, "values", result.values); + deserializer.ReadPropertyWithDefault>(101, "star_expr", result.expr); + deserializer.ReadPropertyWithDefault(102, "alias", result.alias); + return result; +} + //===--------------------------------------------------------------------===// // PivotRef //===--------------------------------------------------------------------===// diff --git a/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp b/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp index 256a10200..886114480 100644 --- a/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp +++ b/src/duckdb/src/parser/transform/constraint/transform_constraint.cpp @@ -124,13 +124,19 @@ unique_ptr Transformer::TransformConstraint(duckdb_libpgquery::PGCon case duckdb_libpgquery::PG_CONSTR_DEFAULT: column.SetDefaultValue(TransformExpression(constraint.raw_expr)); return nullptr; - case duckdb_libpgquery::PG_CONSTR_COMPRESSION: - column.SetCompressionType(CompressionTypeFromString(constraint.compression_name)); - if (column.CompressionType() == CompressionType::COMPRESSION_AUTO) { - throw ParserException("Unrecognized option for column compression, expected none, uncompressed, rle, " - "dictionary, pfor, bitpacking, fsst, chimp, patas, zstd, alp, alprd or roaring"); + case duckdb_libpgquery::PG_CONSTR_COMPRESSION: { + auto compression_type = EnumUtil::FromString(constraint.compression_name); + switch (compression_type) { + case CompressionType::COMPRESSION_AUTO: + case CompressionType::COMPRESSION_CONSTANT: + case CompressionType::COMPRESSION_EMPTY: + throw InvalidInputException("Compression method %d cannot be forced", constraint.compression_name); + default: + break; } + column.SetCompressionType(compression_type); return nullptr; + } case duckdb_libpgquery::PG_CONSTR_FOREIGN: return TransformForeignKeyConstraint(constraint, &column.Name()); default: diff --git a/src/duckdb/src/parser/transform/expression/transform_constant.cpp b/src/duckdb/src/parser/transform/expression/transform_constant.cpp index 88fd295ff..2f83a843c 100644 --- a/src/duckdb/src/parser/transform/expression/transform_constant.cpp +++ b/src/duckdb/src/parser/transform/expression/transform_constant.cpp @@ -95,90 +95,4 @@ unique_ptr Transformer::TransformConstant(duckdb_libpgquery::P return std::move(constant); } -bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) { - // We have to construct it like this because we don't have the ClientContext for binding/executing the expr here - switch (expr.GetExpressionType()) { - case ExpressionType::FUNCTION: { - auto &function = expr.Cast(); - if (function.function_name == "struct_pack") { - unordered_set unique_names; - child_list_t values; - values.reserve(function.children.size()); - for (const auto &child : function.children) { - if (!unique_names.insert(child->GetAlias()).second) { - throw BinderException("Duplicate struct entry name \"%s\"", child->GetAlias()); - } - Value child_value; - if (!ConstructConstantFromExpression(*child, child_value)) { - return false; - } - values.emplace_back(child->GetAlias(), std::move(child_value)); - } - value = Value::STRUCT(std::move(values)); - return true; - } else if (function.function_name == "list_value") { - vector values; - values.reserve(function.children.size()); - for (const auto &child : function.children) { - Value child_value; - if (!ConstructConstantFromExpression(*child, child_value)) { - return false; - } - values.emplace_back(std::move(child_value)); - } - - // figure out child type - LogicalType child_type(LogicalTypeId::SQLNULL); - for (auto &child_value : values) { - child_type = LogicalType::ForceMaxLogicalType(child_type, child_value.type()); - } - - // finally create the list - value = Value::LIST(child_type, values); - return true; - } else if (function.function_name == "map") { - Value keys; - if (!ConstructConstantFromExpression(*function.children[0], keys)) { - return false; - } - - Value values; - if (!ConstructConstantFromExpression(*function.children[1], values)) { - return false; - } - - vector keys_unpacked = ListValue::GetChildren(keys); - vector values_unpacked = ListValue::GetChildren(values); - - value = Value::MAP(ListType::GetChildType(keys.type()), ListType::GetChildType(values.type()), - keys_unpacked, values_unpacked); - return true; - } else { - return false; - } - } - case ExpressionType::VALUE_CONSTANT: { - auto &constant = expr.Cast(); - value = constant.value; - return true; - } - case ExpressionType::OPERATOR_CAST: { - auto &cast = expr.Cast(); - Value dummy_value; - if (!ConstructConstantFromExpression(*cast.child, dummy_value)) { - return false; - } - - string error_message; - if (!dummy_value.DefaultTryCastAs(cast.cast_type, value, &error_message)) { - throw ConversionException("Unable to cast %s to %s", dummy_value.ToString(), - EnumUtil::ToString(cast.cast_type.id())); - } - return true; - } - default: - return false; - } -} - } // namespace duckdb diff --git a/src/duckdb/src/parser/transform/expression/transform_expression.cpp b/src/duckdb/src/parser/transform/expression/transform_expression.cpp index 73b42c9dd..0ab5a1f02 100644 --- a/src/duckdb/src/parser/transform/expression/transform_expression.cpp +++ b/src/duckdb/src/parser/transform/expression/transform_expression.cpp @@ -1,5 +1,6 @@ #include "duckdb/common/exception.hpp" #include "duckdb/parser/expression/default_expression.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/parser/transformer.hpp" namespace duckdb { @@ -77,6 +78,8 @@ unique_ptr Transformer::TransformExpression(duckdb_libpgquery: return TransformBooleanTest(PGCast(node)); case duckdb_libpgquery::T_PGMultiAssignRef: return TransformMultiAssignRef(PGCast(node)); + case duckdb_libpgquery::T_PGString: + return TransformValue(PGCast(node)); default: throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node.type), (int)node.type); } diff --git a/src/duckdb/src/parser/transform/helpers/transform_typename.cpp b/src/duckdb/src/parser/transform/helpers/transform_typename.cpp index 917b6cc80..b2492b176 100644 --- a/src/duckdb/src/parser/transform/helpers/transform_typename.cpp +++ b/src/duckdb/src/parser/transform/helpers/transform_typename.cpp @@ -6,315 +6,168 @@ #include "duckdb/common/types/decimal.hpp" #include "duckdb/common/types/vector.hpp" #include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/type_expression.hpp" namespace duckdb { -struct SizeModifiers { - int64_t width = 0; - int64_t scale = 0; - // How many modifiers were found - idx_t count = 0; -}; +unique_ptr Transformer::TransformTypeExpressionInternal(duckdb_libpgquery::PGTypeName &type_name) { + // Parse typename/any qualifications -static SizeModifiers GetSizeModifiers(duckdb_libpgquery::PGTypeName &type_name, LogicalTypeId base_type) { - SizeModifiers result; + string unbound_name; + string schema_name; + string catalog_name; - if (base_type == LogicalTypeId::DECIMAL) { - // Defaults for DECIMAL - result.width = 18; - result.scale = 3; + if (type_name.names->length == 0) { + throw ParserException("Type name cannot be empty"); } + if (type_name.names->length == 1) { + auto unbound_name_cell = type_name.names->head; - if (type_name.typmods) { - for (auto node = type_name.typmods->head; node; node = node->next) { - auto &const_val = *Transformer::PGPointerCast(node->data.ptr_value); - if (const_val.type != duckdb_libpgquery::T_PGAConst || - const_val.val.type != duckdb_libpgquery::T_PGInteger) { - throw ParserException("Expected an integer constant as type modifier"); - } - if (const_val.val.val.ival < 0) { - throw ParserException("Negative modifier not supported"); - } - if (result.count == 0) { - result.width = const_val.val.val.ival; - if (base_type == LogicalTypeId::BIT && const_val.location != -1) { - result.width = 0; - } - } else if (result.count == 1) { - result.scale = const_val.val.val.ival; - } else { - throw ParserException("A maximum of two modifiers is supported"); - } - result.count++; - } - } - return result; -} - -vector Transformer::TransformTypeModifiers(duckdb_libpgquery::PGTypeName &type_name) { - vector type_mods; - if (type_name.typmods) { - for (auto node = type_name.typmods->head; node; node = node->next) { - const auto &const_val = *PGPointerCast(node->data.ptr_value); - if (const_val.type != duckdb_libpgquery::T_PGAConst) { - throw ParserException("Expected a constant as type modifier"); - } - const auto const_expr = TransformValue(const_val.val); - type_mods.push_back(std::move(const_expr->value)); - } - if (type_mods.size() > 9) { - const auto name = PGPointerCast(type_name.names->tail->data.ptr_value)->val.str; - throw ParserException("'%s': a maximum of 9 type modifiers is allowed", name); - } - } - return type_mods; -} - -LogicalType Transformer::TransformTypeNameInternal(duckdb_libpgquery::PGTypeName &type_name) { - if (type_name.names->length > 1) { - // qualified typename - vector names; - for (auto cell = type_name.names->head; cell; cell = cell->next) { - names.push_back(PGPointerCast(cell->data.ptr_value)->val.str); - } - vector type_mods = TransformTypeModifiers(type_name); - switch (type_name.names->length) { - case 2: { - return LogicalType::USER(INVALID_CATALOG, std::move(names[0]), std::move(names[1]), std::move(type_mods)); - } - case 3: { - return LogicalType::USER(std::move(names[0]), std::move(names[1]), std::move(names[2]), - std::move(type_mods)); - } - default: - throw ParserException( - "Too many qualifications for type name - expected [catalog.schema.name] or [schema.name]"); - } + unbound_name = PGPointerCast(unbound_name_cell->data.ptr_value)->val.str; } + if (type_name.names->length == 2) { + auto schema_name_cell = type_name.names->head; + auto unbound_name_cell = schema_name_cell->next; - auto name = PGPointerCast(type_name.names->tail->data.ptr_value)->val.str; - // transform it to the SQL type - LogicalTypeId base_type = TransformStringToLogicalTypeId(name); - - if (base_type == LogicalTypeId::LIST) { - throw ParserException("LIST is not valid as a stand-alone type"); + schema_name = PGPointerCast(schema_name_cell->data.ptr_value)->val.str; + unbound_name = PGPointerCast(unbound_name_cell->data.ptr_value)->val.str; } - if (base_type == LogicalTypeId::ENUM) { - if (!type_name.typmods || type_name.typmods->length == 0) { - throw ParserException("Enum needs a set of entries"); - } - Vector enum_vector(LogicalType::VARCHAR, NumericCast(type_name.typmods->length)); - auto string_data = FlatVector::GetData(enum_vector); - idx_t pos = 0; - for (auto node = type_name.typmods->head; node; node = node->next) { - auto constant_value = PGPointerCast(node->data.ptr_value); - if (constant_value->type != duckdb_libpgquery::T_PGAConst || - constant_value->val.type != duckdb_libpgquery::T_PGString) { - throw ParserException("Enum type requires a set of strings as type modifiers"); - } - string_data[pos++] = StringVector::AddString(enum_vector, constant_value->val.val.str); - } - return LogicalType::ENUM(enum_vector, NumericCast(type_name.typmods->length)); + if (type_name.names->length == 3) { + auto catalog_name_cell = type_name.names->head; + auto schema_name_cell = catalog_name_cell->next; + auto unbound_name_cell = schema_name_cell->next; + + catalog_name = PGPointerCast(catalog_name_cell->data.ptr_value)->val.str; + schema_name = PGPointerCast(schema_name_cell->data.ptr_value)->val.str; + unbound_name = PGPointerCast(unbound_name_cell->data.ptr_value)->val.str; } - if (base_type == LogicalTypeId::GEOMETRY) { - if (!type_name.typmods || type_name.typmods->length == 0) { - return LogicalType::GEOMETRY(); - } - // Expect a single type modifier with the CRS definition - if (type_name.typmods->length != 1) { - throw ParserException( - "GEOMETRY type takes a single optional type modifier with a coordinate system definition"); - } - auto crs_node = PGPointerCast(type_name.typmods->head->data.ptr_value); - if (crs_node->type != duckdb_libpgquery::T_PGAConst || crs_node->val.type != duckdb_libpgquery::T_PGString) { - throw ParserException( - "GEOMETRY type modifier must be a string with a coordinate system definition definition"); - } - return LogicalType::GEOMETRY(crs_node->val.val.str); + if (type_name.names->length >= 4) { + throw ParserException( + "Too many qualifications for type name - expected [catalog.schema.name] or [schema.name]"); } - if (base_type == LogicalTypeId::STRUCT) { - if (!type_name.typmods || type_name.typmods->length == 0) { - throw ParserException("Struct needs a name and entries"); - } - child_list_t children; - case_insensitive_set_t name_collision_set; + D_ASSERT(!unbound_name.empty()); - for (auto node = type_name.typmods->head; node; node = node->next) { - auto &type_val = *PGPointerCast(node->data.ptr_value); - if (type_val.length != 2) { - throw ParserException("Struct entry needs an entry name and a type name"); - } + // The postgres parser emits a bunch of strange type names - we want to normalize them here so that the alias for + // columns from expressions containing these types actually use the DuckDB type name. + // Eventually we should make the parser emit the correct names directly. + auto known_type_id = TransformStringToLogicalTypeId(unbound_name); + if (known_type_id != LogicalTypeId::UNBOUND) { + unbound_name = LogicalTypeIdToString(known_type_id); + } - auto entry_name_node = PGPointerCast(type_val.head->data.ptr_value); - D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString); - auto entry_type_node = PGPointerCast(type_val.tail->data.ptr_value); - D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName); + // Parse type modifiers + vector> type_params; + for (auto typemod = type_name.typmods ? type_name.typmods->head : nullptr; typemod; typemod = typemod->next) { + // Type mods are always a list of (name, node) pairs - auto entry_name = string(entry_name_node->val.str); - D_ASSERT(!entry_name.empty()); + string name_str; + auto typemod_node = PGPointerCast(typemod->data.ptr_value); - if (name_collision_set.find(entry_name) != name_collision_set.end()) { - throw ParserException("Duplicate struct entry name \"%s\"", entry_name); + if (typemod_node->type == duckdb_libpgquery::T_PGList) { + auto &typemod_pair = *PGPointerCast(typemod->data.ptr_value); + if (typemod_pair.length != 2) { + throw ParserException("Expected type modifier to be a pair of (name, value)"); } - name_collision_set.insert(entry_name); - auto entry_type = TransformTypeName(*entry_type_node); - children.push_back(make_pair(entry_name, entry_type)); - } - D_ASSERT(!children.empty()); - return LogicalType::STRUCT(children); - } - if (base_type == LogicalTypeId::VARIANT) { - return LogicalType::VARIANT(); - } - if (base_type == LogicalTypeId::MAP) { - if (!type_name.typmods || type_name.typmods->length != 2) { - throw ParserException("Map type needs exactly two entries, key and value type"); - } - auto key_type = - TransformTypeName(*PGPointerCast(type_name.typmods->head->data.ptr_value)); - auto value_type = - TransformTypeName(*PGPointerCast(type_name.typmods->tail->data.ptr_value)); - - return LogicalType::MAP(std::move(key_type), std::move(value_type)); - } - if (base_type == LogicalTypeId::UNION) { - if (!type_name.typmods || type_name.typmods->length == 0) { - throw ParserException("Union type needs at least one member"); - } - if (type_name.typmods->length > (int)UnionType::MAX_UNION_MEMBERS) { - throw ParserException("Union types can have at most %d members", UnionType::MAX_UNION_MEMBERS); - } + // This is the actual argument node + typemod_node = PGPointerCast(typemod_pair.tail->data.ptr_value); - child_list_t children; - case_insensitive_set_t name_collision_set; - - for (auto node = type_name.typmods->head; node; node = node->next) { - auto &type_val = *PGPointerCast(node->data.ptr_value); - if (type_val.length != 2) { - throw ParserException("Union type member needs a tag name and a type name"); + // Extract name of the type modifier (optional) + auto name_node = PGPointerCast(typemod_pair.head->data.ptr_value); + if (name_node) { + if (name_node->type != duckdb_libpgquery::T_PGString) { + throw ParserException("Expected a constant as type modifier name"); + } + name_str = PGPointerCast(name_node.get())->val.str; } + } - auto entry_name_node = PGPointerCast(type_val.head->data.ptr_value); - D_ASSERT(entry_name_node->type == duckdb_libpgquery::T_PGString); - auto entry_type_node = PGPointerCast(type_val.tail->data.ptr_value); - D_ASSERT(entry_type_node->type == duckdb_libpgquery::T_PGTypeName); + // Extract value of the type modifier + // This is either: + // 1. A constant value + // 2. A expression + // 3. A type name - auto entry_name = string(entry_name_node->val.str); - D_ASSERT(!entry_name.empty()); + if (typemod_node->type == duckdb_libpgquery::T_PGTypeName) { + auto type_node = *PGPointerCast(typemod_node.get()); + auto type_expr = TransformTypeExpression(type_node); + type_expr->SetAlias(std::move(name_str)); + type_params.push_back(std::move(type_expr)); + } else { + // Expression + auto expr = TransformExpression(*typemod_node); - if (name_collision_set.find(entry_name) != name_collision_set.end()) { - throw ParserException("Duplicate union type tag name \"%s\"", entry_name); + // TODO: Allow arbitrary expressions in the future + if (expr->GetExpressionClass() != ExpressionClass::CONSTANT) { + throw ParserException("Expected a constant as type modifier"); } - name_collision_set.insert(entry_name); - - auto entry_type = TransformTypeName(*entry_type_node); - children.push_back(make_pair(entry_name, entry_type)); + expr->SetAlias(std::move(name_str)); + type_params.push_back(std::move(expr)); } - D_ASSERT(!children.empty()); - return LogicalType::UNION(std::move(children)); - } - if (base_type == LogicalTypeId::USER) { - string user_type_name {name}; - vector type_mods = TransformTypeModifiers(type_name); - return LogicalType::USER(user_type_name, type_mods); } - SizeModifiers modifiers = GetSizeModifiers(type_name, base_type); - switch (base_type) { - case LogicalTypeId::VARCHAR: - if (modifiers.count > 1) { - throw ParserException("VARCHAR only supports a single modifier"); - } - // FIXME: create CHECK constraint based on varchar width - modifiers.width = 0; - return LogicalType::VARCHAR; - case LogicalTypeId::DECIMAL: - if (modifiers.count > 2) { - throw ParserException("DECIMAL only supports a maximum of two modifiers"); - } - if (modifiers.count == 1) { - // only width is provided: set scale to 0 - modifiers.scale = 0; - } - if (modifiers.width <= 0 || modifiers.width > Decimal::MAX_WIDTH_DECIMAL) { - throw ParserException("Width must be between 1 and %d!", (int)Decimal::MAX_WIDTH_DECIMAL); - } - if (modifiers.scale > modifiers.width) { - throw ParserException("Scale cannot be bigger than width"); - } - return LogicalType::DECIMAL(NumericCast(modifiers.width), NumericCast(modifiers.scale)); - case LogicalTypeId::INTERVAL: - if (modifiers.count > 1) { - throw ParserException("INTERVAL only supports a single modifier"); - } - modifiers.width = 0; - return LogicalType::INTERVAL; - case LogicalTypeId::BIT: - if (!modifiers.width && type_name.typmods) { - throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString()); - } - return LogicalType(base_type); - case LogicalTypeId::TIMESTAMP: - if (modifiers.count == 0) { - return LogicalType::TIMESTAMP; - } - if (modifiers.count > 1) { - throw ParserException("TIMESTAMP only supports a single modifier"); - } - if (modifiers.width > 10) { - throw ParserException("TIMESTAMP only supports until nano-second precision (9)"); - } - if (modifiers.width == 0) { - return LogicalType::TIMESTAMP_S; - } - if (modifiers.width <= 3) { - return LogicalType::TIMESTAMP_MS; - } - if (modifiers.width <= 6) { - return LogicalType::TIMESTAMP; - } - return LogicalType::TIMESTAMP_NS; - default: - if (modifiers.count > 0) { - throw ParserException("Type %s does not support any modifiers!", LogicalType(base_type).ToString()); - } - return LogicalType(base_type); + auto result = make_uniq(catalog_name, schema_name, unbound_name, std::move(type_params)); + + // Assign query location + if (type_name.location >= 0) { + result->query_location = NumericCast(type_name.location); } + + return std::move(result); } -LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) { +unique_ptr Transformer::TransformTypeExpression(duckdb_libpgquery::PGTypeName &type_name) { if (type_name.type != duckdb_libpgquery::T_PGTypeName) { throw ParserException("Expected a type"); } auto stack_checker = StackCheck(); - auto result_type = TransformTypeNameInternal(type_name); + + auto result = TransformTypeExpressionInternal(type_name); + if (type_name.arrayBounds) { - // array bounds: turn the type into a list + // For both arrays and lists, the inner type is stored as the first type parameter + idx_t extra_stack = 0; for (auto cell = type_name.arrayBounds->head; cell != nullptr; cell = cell->next) { StackCheck(extra_stack++); - auto val = PGPointerCast(cell->data.ptr_value); - if (val->type != duckdb_libpgquery::T_PGInteger) { - throw ParserException("Expected integer value as array bound"); - } - auto array_size = val->val.ival; - if (array_size < 0) { - // -1 if bounds are empty - result_type = LogicalType::LIST(result_type); - } else if (array_size == 0) { - // Empty arrays are not supported - throw ParserException("Arrays must have a size of at least 1"); - } else if (array_size > static_cast(ArrayType::MAX_ARRAY_SIZE)) { - throw ParserException("Arrays must have a size of at most %d", ArrayType::MAX_ARRAY_SIZE); - } else { - result_type = LogicalType::ARRAY(result_type, NumericCast(array_size)); + auto arg = PGPointerCast(cell->data.ptr_value); + + if (arg->type == duckdb_libpgquery::T_PGInteger) { + auto int_node = PGPointerCast(arg.get()); + auto size = int_node->val.ival; + + vector> type_params; + type_params.push_back(std::move(result)); + + if (size == -1) { + // LIST type + result = make_uniq("list", std::move(type_params)); + } else { + // ARRAY type + type_params.push_back(make_uniq(Value::BIGINT(int_node->val.ival))); + result = make_uniq("array", std::move(type_params)); + } + + continue; } + + throw ParserException("ARRAY bounds must only contain expressions"); } } - return result_type; + + // Assign query location + if (type_name.location >= 0) { + result->query_location = NumericCast(type_name.location); + } + + return result; +} + +LogicalType Transformer::TransformTypeName(duckdb_libpgquery::PGTypeName &type_name) { + auto type_expr = TransformTypeExpression(type_name); + return LogicalType::UNBOUND(std::move(type_expr)); } } // namespace duckdb diff --git a/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp b/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp index 203d90fdc..71dc1967d 100644 --- a/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp @@ -223,6 +223,29 @@ unique_ptr Transformer::TransformAlter(duckdb_libpgquery::PGAlterT result->info = make_uniq(std::move(data), std::move(orders)); break; } + case duckdb_libpgquery::PG_AT_SetRelOptions: { + case_insensitive_map_t> options; + if (command->options) { + TransformTableOptions(options, command->options); + } + result->info = make_uniq(std::move(data), std::move(options)); + break; + } + case duckdb_libpgquery::PG_AT_ResetRelOptions: { + case_insensitive_map_t> rel_options_map; + case_insensitive_set_t options; + if (command->options) { + // TransformTableOptions will throw if key values are parsed + TransformTableOptions(rel_options_map, command->options, true); + // make sure RESET only supports single value options + // default of true is allowed + for (auto &option : rel_options_map) { + options.insert(option.first); + } + } + result->info = make_uniq(std::move(data), std::move(options)); + break; + } default: throw NotImplementedException("No support for that ALTER TABLE option yet!"); } diff --git a/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp b/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp index 6ab5d9e68..d9680168d 100644 --- a/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_comment_on.cpp @@ -1,8 +1,9 @@ +#include "duckdb/parser/expression/columnref_expression.hpp" #include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/parser/parsed_data/alter_info.hpp" #include "duckdb/parser/parsed_data/alter_table_info.hpp" -#include "duckdb/parser/statement/alter_statement.hpp" #include "duckdb/parser/parsed_data/comment_on_column_info.hpp" +#include "duckdb/parser/statement/alter_statement.hpp" #include "duckdb/parser/transformer.hpp" namespace duckdb { diff --git a/src/duckdb/src/parser/transform/statement/transform_create_function.cpp b/src/duckdb/src/parser/transform/statement/transform_create_function.cpp index 1525f634d..2632243af 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_function.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_function.cpp @@ -39,12 +39,6 @@ unique_ptr Transformer::TransformMacroFunction(duckdb_libpgquery: // Transform parameter default value if (param.defaultValue) { auto default_expr = TransformExpression(PGPointerCast(param.defaultValue)); - Value default_value; - if (!ConstructConstantFromExpression(*default_expr, default_value)) { - throw ParserException("Invalid default value for parameter '%s': %s", param.name, - default_expr->ToString()); - } - default_expr = make_uniq(std::move(default_value)); default_expr->SetAlias(param.name); macro_func->default_parameters[param.name] = std::move(default_expr); } else if (!macro_func->default_parameters.empty()) { diff --git a/src/duckdb/src/parser/transform/statement/transform_create_index.cpp b/src/duckdb/src/parser/transform/statement/transform_create_index.cpp index 3b13d53ce..47ce484dc 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_index.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_index.cpp @@ -66,7 +66,12 @@ unique_ptr Transformer::TransformCreateIndex(duckdb_libpgquery: auto def_elem = PGPointerCast(cell->data.ptr_value); Value val; if (def_elem->arg) { - val = TransformValue(*PGPointerCast(def_elem->arg))->value; + auto expr = TransformExpression(def_elem->arg); + if (expr->expression_class != ExpressionClass::CONSTANT) { + throw InvalidInputException("Create index option must be a constant value"); + } + auto &const_expr = expr->Cast(); + val = const_expr.value; } else { val = Value::BOOLEAN(true); } diff --git a/src/duckdb/src/parser/transform/statement/transform_create_table.cpp b/src/duckdb/src/parser/transform/statement/transform_create_table.cpp index 412a73cd3..8a180497d 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_table.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_table.cpp @@ -1,6 +1,8 @@ #include "duckdb/catalog/catalog_entry/table_column_type.hpp" #include "duckdb/parser/constraint.hpp" #include "duckdb/parser/expression/collate_expression.hpp" +#include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/type_expression.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" #include "duckdb/parser/statement/create_statement.hpp" #include "duckdb/parser/transformer.hpp" @@ -59,18 +61,30 @@ ColumnDefinition Transformer::TransformColumnDefinition(duckdb_libpgquery::PGCol } else if (!cdef.typeName) { // ALTER TABLE tbl ALTER TYPE USING ... target_type = LogicalType::UNKNOWN; - } else { - target_type = TransformTypeName(*cdef.typeName); - } - - if (cdef.collClause) { + } else if (cdef.collClause) { if (cdef.category == duckdb_libpgquery::COL_GENERATED) { throw ParserException("Collations are not supported on generated columns"); } - if (target_type.id() != LogicalTypeId::VARCHAR) { + + auto typename_expr = TransformTypeExpressionInternal(*cdef.typeName); + if (typename_expr->type != ExpressionType::TYPE) { + throw ParserException("Only type names can have collations!"); + } + + auto &type_expr = typename_expr->Cast(); + if (!StringUtil::CIEquals(type_expr.GetTypeName(), "VARCHAR")) { throw ParserException("Only VARCHAR columns can have collations!"); } - target_type = LogicalType::VARCHAR_COLLATION(TransformCollation(cdef.collClause)); + + // Push back collation as a parameter of the type expression + auto collation = TransformCollation(cdef.collClause); + auto collation_expr = make_uniq(Value(collation)); + collation_expr->SetAlias("collation"); + type_expr.GetChildren().push_back(std::move(collation_expr)); + + target_type = LogicalType::UNBOUND(std::move(typename_expr)); + } else { + target_type = TransformTypeName(*cdef.typeName); } return ColumnDefinition(name, target_type); @@ -134,6 +148,22 @@ unique_ptr Transformer::TransformCreateTable(duckdb_libpgquery: } } + vector> partition_keys; + if (stmt.partition_list) { + TransformExpressionList(*stmt.partition_list, partition_keys); + } + info->partition_keys = std::move(partition_keys); + + vector> order_keys; + if (stmt.sort_list) { + TransformExpressionList(*stmt.sort_list, order_keys); + } + info->sort_keys = std::move(order_keys); + + if (stmt.options) { + TransformTableOptions(info->options, stmt.options); + } + if (!column_count) { throw ParserException("Table must have at least one column!"); } diff --git a/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp b/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp index 16ab1b596..bfb428662 100644 --- a/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_create_table_as.cpp @@ -1,7 +1,8 @@ -#include "duckdb/parser/statement/create_statement.hpp" #include "duckdb/parser/expression/constant_expression.hpp" +#include "duckdb/parser/expression/star_expression.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" #include "duckdb/parser/query_node/select_node.hpp" +#include "duckdb/parser/statement/create_statement.hpp" #include "duckdb/parser/tableref/subqueryref.hpp" #include "duckdb/parser/transformer.hpp" diff --git a/src/duckdb/src/parser/transform/statement/transform_secret.cpp b/src/duckdb/src/parser/transform/statement/transform_secret.cpp index bde6c38f7..749cde6e9 100644 --- a/src/duckdb/src/parser/transform/statement/transform_secret.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_secret.cpp @@ -1,6 +1,7 @@ -#include "duckdb/parser/statement/create_statement.hpp" +#include "duckdb/parser/expression/columnref_expression.hpp" #include "duckdb/parser/expression/constant_expression.hpp" #include "duckdb/parser/expression/function_expression.hpp" +#include "duckdb/parser/statement/create_statement.hpp" #include "duckdb/parser/tableref/basetableref.hpp" #include "duckdb/parser/transformer.hpp" diff --git a/src/duckdb/src/parser/transform/statement/transform_show.cpp b/src/duckdb/src/parser/transform/statement/transform_show.cpp index ebd0ebd8d..cc6afe780 100644 --- a/src/duckdb/src/parser/transform/statement/transform_show.cpp +++ b/src/duckdb/src/parser/transform/statement/transform_show.cpp @@ -31,12 +31,15 @@ unique_ptr Transformer::TransformShow(duckdb_libpgquery::PGVariableSh } else { // describing a set (e.g. SHOW ALL TABLES) - push it in the table name showref->table_name = stmt.set; + showref->show_type = ShowType::SHOW_UNQUALIFIED; } } else if (!stmt.relation->schemaname) { // describing an unqualified relation - check if this is a "special" relation string table_name = StringUtil::Lower(stmt.relation->relname); - if (table_name == "databases" || table_name == "tables" || table_name == "variables") { + if (table_name == "databases" || table_name == "schemas" || table_name == "tables" || + table_name == "variables") { showref->table_name = "\"" + std::move(table_name) + "\""; + showref->show_type = ShowType::SHOW_UNQUALIFIED; } } if (showref->table_name.empty() && showref->show_type != ShowType::SHOW_FROM) { diff --git a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp index dcb2dc036..a48fa76c3 100644 --- a/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp +++ b/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp @@ -8,39 +8,6 @@ namespace duckdb { -bool Transformer::TransformPivotInList(unique_ptr &expr, PivotColumnEntry &entry, bool root_entry) { - switch (expr->GetExpressionType()) { - case ExpressionType::COLUMN_REF: { - auto &colref = expr->Cast(); - if (colref.IsQualified()) { - throw ParserException(expr->GetQueryLocation(), "PIVOT IN list cannot contain qualified column references"); - } - entry.values.emplace_back(colref.GetColumnName()); - return true; - } - case ExpressionType::FUNCTION: { - auto &function = expr->Cast(); - if (function.function_name != "row") { - return false; - } - for (auto &child : function.children) { - if (!TransformPivotInList(child, entry, false)) { - return false; - } - } - return true; - } - default: { - Value val; - if (!Transformer::ConstructConstantFromExpression(*expr, val)) { - return false; - } - entry.values.push_back(std::move(val)); - return true; - } - } -} - PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot) { PivotColumn col; if (pivot.pivot_columns) { @@ -65,19 +32,7 @@ PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, auto expr = TransformExpression(n); PivotColumnEntry entry; entry.alias = expr->GetAlias(); - auto transformed = TransformPivotInList(expr, entry); - if (!transformed) { - // could not transform into list of constant values - if (is_pivot) { - // for pivot - throw an exception - throw ParserException(expr->GetQueryLocation(), - "PIVOT IN list must contain columns or lists of columns"); - } else { - // for unpivot - we can forward the expression immediately - entry.values.clear(); - entry.expr = std::move(expr); - } - } + entry.expr = std::move(expr); col.entries.push_back(std::move(entry)); } } @@ -123,20 +78,6 @@ unique_ptr Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause"); } D_ASSERT(pivot.pivot_expressions.empty()); - } else { - // pivot - auto expected_size = pivot.pivot_expressions.size(); - D_ASSERT(pivot.unpivot_names.empty()); - for (auto &entry : pivot.entries) { - if (entry.expr) { - throw ParserException("PIVOT IN list must contain columns or lists of columns - expressions are " - "only supported for UNPIVOT"); - } - if (entry.values.size() != expected_size) { - throw ParserException("PIVOT IN list - inconsistent amount of rows - expected %d but got %d", - expected_size, entry.values.size()); - } - } } } result->include_nulls = root.include_nulls; diff --git a/src/duckdb/src/parser/transformer.cpp b/src/duckdb/src/parser/transformer.cpp index f3f058899..b489ef086 100644 --- a/src/duckdb/src/parser/transformer.cpp +++ b/src/duckdb/src/parser/transformer.cpp @@ -244,4 +244,29 @@ void Transformer::SetQueryLocation(TableRef &ref, int query_location) { ref.query_location = optional_idx(static_cast(query_location)); } +void Transformer::TransformTableOptions(case_insensitive_map_t> &options, + optional_ptr pg_options, bool throw_if_value) { + if (!pg_options) { + return; + } + + duckdb_libpgquery::PGListCell *cell; + for_each_cell(cell, pg_options->head) { + auto def_elem = PGPointerCast(cell->data.ptr_value); + auto lower_name = StringUtil::Lower(def_elem->defname); + if (options.find(lower_name) != options.end()) { + throw ParserException("Duplicate table property \"%s\"", lower_name); + } + if (!def_elem->arg) { + options.emplace(lower_name, make_uniq(Value())); + continue; + } + auto expr = TransformExpression(def_elem->arg); + if (throw_if_value) { + throw ParserException("\"%s\"", expr->ToString()); + } + options.emplace(lower_name, std::move(expr)); + } +} + } // namespace duckdb diff --git a/src/duckdb/src/planner/binder.cpp b/src/duckdb/src/planner/binder.cpp index fe1b59cf3..5d5be868e 100644 --- a/src/duckdb/src/planner/binder.cpp +++ b/src/duckdb/src/planner/binder.cpp @@ -7,6 +7,7 @@ #include "duckdb/common/helper.hpp" #include "duckdb/main/config.hpp" #include "duckdb/main/database.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/optimizer/optimizer.hpp" #include "duckdb/parser/expression/function_expression.hpp" #include "duckdb/parser/expression/subquery_expression.hpp" @@ -34,10 +35,11 @@ idx_t Binder::GetBinderDepth() const { void Binder::IncreaseDepth() { depth++; - if (depth > context.config.max_expression_depth) { + auto max_expression_depth = Settings::Get(context); + if (depth > max_expression_depth) { throw BinderException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to " "increase the maximum expression depth.", - context.config.max_expression_depth); + max_expression_depth); } } diff --git a/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp index 053576294..9441c419c 100644 --- a/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_aggregate_expression.cpp @@ -160,7 +160,7 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFu if (order.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) { auto &const_expr = order.expression->Cast(); if (!const_expr.value.type().IsIntegral()) { - auto order_by_non_integer_literal = DBConfig::GetSetting(context); + auto order_by_non_integer_literal = Settings::Get(context); if (!order_by_non_integer_literal) { throw BinderException( *order.expression, diff --git a/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp index 0bcb8d213..13988462e 100644 --- a/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_collate_expression.cpp @@ -16,7 +16,7 @@ BindResult ExpressionBinder::BindExpression(CollateExpression &expr, idx_t depth throw ParameterNotResolvedException(); } if (child->return_type.id() != LogicalTypeId::VARCHAR) { - throw BinderException("collations are only supported for type varchar"); + throw BinderException(child->query_location, "collations are only supported for type varchar"); } // Validate the collation, but don't use it auto collation_test = make_uniq_base(Value(child->return_type)); diff --git a/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp index 92a5d0757..43dd22135 100644 --- a/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_function_expression.cpp @@ -13,6 +13,7 @@ #include "duckdb/planner/expression/bound_lambda_expression.hpp" #include "duckdb/planner/expression/bound_reference_expression.hpp" #include "duckdb/planner/expression_binder.hpp" +#include "duckdb/main/settings.hpp" namespace duckdb { @@ -23,8 +24,7 @@ BindResult ExpressionBinder::TryBindLambdaOrJson(FunctionExpression &function, i return BindLambdaFunction(function, func.Cast(), depth); } - auto &config = ClientConfig::GetConfig(context); - auto setting = config.lambda_syntax; + auto setting = Settings::Get(context); bool invalid_syntax = setting == LambdaSyntax::DISABLE_SINGLE_ARROW && syntax_type == LambdaSyntaxType::SINGLE_ARROW; bool warn_deprecated_syntax = setting == LambdaSyntax::DEFAULT && syntax_type == LambdaSyntaxType::SINGLE_ARROW; @@ -220,12 +220,22 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc } // the first child is the list, the second child is the lambda expression - constexpr idx_t list_idx = 0; - constexpr idx_t lambda_expr_idx = 1; - D_ASSERT(function.children[lambda_expr_idx]->GetExpressionClass() == ExpressionClass::LAMBDA); + // constexpr idx_t list_ix = 0; + idx_t lambda_expr_idx = 0; + bool found_lambda = false; + for (idx_t i = 0; i < function.children.size(); i++) { + if (function.children[i]->GetExpressionClass() == ExpressionClass::LAMBDA) { + if (found_lambda) { + return BindResult("Only one lambda expression is supported per lambda function!"); + } + lambda_expr_idx = i; + found_lambda = true; + break; + } + } + // Get lambda expr idx vector function_child_types; - // bind the list ErrorData error; for (idx_t i = 0; i < function.children.size(); i++) { @@ -248,14 +258,6 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc function_child_types.push_back(child->return_type); } - // get the logical type of the children of the list - auto &list_child = BoundExpression::GetExpression(*function.children[list_idx]); - if (list_child->return_type.id() != LogicalTypeId::LIST && list_child->return_type.id() != LogicalTypeId::ARRAY && - list_child->return_type.id() != LogicalTypeId::SQLNULL && - list_child->return_type.id() != LogicalTypeId::UNKNOWN) { - return BindResult("Invalid LIST argument during lambda function binding!"); - } - // bind the lambda parameter auto &lambda_expr = function.children[lambda_expr_idx]->Cast(); BindResult bind_lambda_result = BindExpression(lambda_expr, depth, function_child_types, &bind_lambda_function); @@ -265,11 +267,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc } // successfully bound: replace the node with a BoundExpression - auto alias = function.children[lambda_expr_idx]->GetAlias(); - bind_lambda_result.expression->SetAlias(alias); - if (!alias.empty()) { - bind_lambda_result.expression->SetAlias(alias); - } + bind_lambda_result.expression->SetAlias(lambda_expr.GetAlias()); function.children[lambda_expr_idx] = make_uniq(std::move(bind_lambda_result.expression)); if (binder.GetBindingMode() == BindingMode::EXTRACT_NAMES) { @@ -306,18 +304,22 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc // push back (in reverse order) any nested lambda parameters so that we can later use them in the lambda // expression (rhs). This happens after we bound the lambda expression of this depth. So it is relevant for // correctly binding lambdas one level 'out'. Therefore, the current parameter count does not matter here. - idx_t offset = 0; if (lambda_bindings) { + idx_t offset = 0; + for (idx_t i = lambda_bindings->size(); i > 0; i--) { auto &binding = (*lambda_bindings)[i - 1]; auto &column_names = binding.GetColumnNames(); auto &column_types = binding.GetColumnTypes(); D_ASSERT(column_names.size() == column_types.size()); - for (idx_t column_idx = column_names.size(); column_idx > 0; column_idx--) { - auto bound_lambda_param = make_uniq(column_names[column_idx - 1], - column_types[column_idx - 1], offset); - offset++; + // However, the parameters are ordered within the level + for (idx_t col_idx = 0; col_idx < column_names.size(); col_idx++) { + auto ¶m_name = column_names[col_idx]; + auto ¶m_type = column_types[col_idx]; + + auto bound_lambda_param = make_uniq(param_name, param_type, offset++); + bound_function_expr.children.push_back(std::move(bound_lambda_param)); } } diff --git a/src/duckdb/src/planner/binder/expression/bind_lambda.cpp b/src/duckdb/src/planner/binder/expression/bind_lambda.cpp index 0d6334fc4..c13200473 100644 --- a/src/duckdb/src/planner/binder/expression/bind_lambda.cpp +++ b/src/duckdb/src/planner/binder/expression/bind_lambda.cpp @@ -12,7 +12,7 @@ namespace duckdb { -idx_t GetLambdaParamCount(vector &lambda_bindings) { +static idx_t GetLambdaParamCount(vector &lambda_bindings) { idx_t count = 0; for (auto &binding : lambda_bindings) { count += binding.GetColumnCount(); @@ -20,8 +20,8 @@ idx_t GetLambdaParamCount(vector &lambda_bindings) { return count; } -idx_t GetLambdaParamIndex(vector &lambda_bindings, const BoundLambdaExpression &bound_lambda_expr, - const BoundLambdaRefExpression &bound_lambda_ref_expr) { +static idx_t GetLambdaParamIndex(vector &lambda_bindings, const BoundLambdaExpression &bound_lambda_expr, + const BoundLambdaRefExpression &bound_lambda_ref_expr) { D_ASSERT(bound_lambda_ref_expr.lambda_idx < lambda_bindings.size()); idx_t offset = 0; // count the remaining lambda parameters BEFORE the current lambda parameter, @@ -29,13 +29,13 @@ idx_t GetLambdaParamIndex(vector &lambda_bindings, const BoundLamb for (idx_t i = bound_lambda_ref_expr.lambda_idx + 1; i < lambda_bindings.size(); i++) { offset += lambda_bindings[i].GetColumnCount(); } - offset += lambda_bindings[bound_lambda_ref_expr.lambda_idx].GetColumnCount() - - bound_lambda_ref_expr.binding.column_index - 1; + offset += bound_lambda_ref_expr.binding.column_index; offset += bound_lambda_expr.parameter_count; return offset; } -void ExtractParameter(const ParsedExpression &expr, vector &column_names, vector &column_aliases) { +static void ExtractParameter(const ParsedExpression &expr, vector &column_names, + vector &column_aliases) { auto &column_ref = expr.Cast(); if (column_ref.IsQualified()) { throw BinderException(LambdaExpression::InvalidParametersErrorMessage()); @@ -45,7 +45,7 @@ void ExtractParameter(const ParsedExpression &expr, vector &column_names column_aliases.push_back(column_ref.ToString()); } -void ExtractParameters(LambdaExpression &expr, vector &column_names, vector &column_aliases) { +static void ExtractParameters(LambdaExpression &expr, vector &column_names, vector &column_aliases) { // extract the lambda parameters, which are a single column // reference, or a list of column references (ROW function) string error_message; @@ -164,7 +164,9 @@ void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr &ori // refers to a lambda parameter inside the current lambda function auto logical_type = (*bind_lambda_function)(context, function_child_types, bound_lambda_ref.binding.column_index); - auto index = bound_lambda_expr.parameter_count - bound_lambda_ref.binding.column_index - 1; + + const auto index = bound_lambda_ref.binding.column_index; + replacement = make_uniq(alias, logical_type, index); return; } diff --git a/src/duckdb/src/planner/binder/expression/bind_type_expression.cpp b/src/duckdb/src/planner/binder/expression/bind_type_expression.cpp new file mode 100644 index 000000000..e2e8b9292 --- /dev/null +++ b/src/duckdb/src/planner/binder/expression/bind_type_expression.cpp @@ -0,0 +1,110 @@ +#include "duckdb/catalog/catalog.hpp" +#include "duckdb/execution/expression_executor.hpp" +#include "duckdb/planner/binder.hpp" +#include "duckdb/planner/expression/bound_constant_expression.hpp" +#include "duckdb/planner/expression_binder.hpp" +#include "duckdb/planner/expression_binder/constant_binder.hpp" +#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp" + +namespace duckdb { + +static bool IsValidTypeLookup(optional_ptr entry) { + if (!entry) { + return false; + } + return entry->Cast().user_type.id() != LogicalTypeId::INVALID; +} + +BindResult ExpressionBinder::BindExpression(TypeExpression &type_expr, idx_t depth) { + auto &type_name = type_expr.GetTypeName(); + auto type_schema = type_expr.GetSchema(); + auto type_catalog = type_expr.GetCatalog(); + + QueryErrorContext error_context(type_expr); + EntryLookupInfo type_lookup(CatalogType::TYPE_ENTRY, type_name, error_context); + + optional_ptr entry = nullptr; + + binder.BindSchemaOrCatalog(context, type_catalog, type_schema); + + // Required for WAL lookup to work + if (type_catalog.empty() && !DatabaseManager::Get(context).HasDefaultDatabase()) { + // Look in the system catalog if no catalog was specified + entry = binder.entry_retriever.GetEntry(SYSTEM_CATALOG, type_schema, type_lookup); + } else { + // Try to search from most specific to least specific + // The search path should already have been set to the correct catalog/schema, + // in case we are looking for a type in the same schema as a table we are creating + + entry = binder.entry_retriever.GetEntry(type_catalog, type_schema, type_lookup, OnEntryNotFound::RETURN_NULL); + + if (!IsValidTypeLookup(entry)) { + entry = binder.entry_retriever.GetEntry(type_catalog, INVALID_SCHEMA, type_lookup, + OnEntryNotFound::RETURN_NULL); + } + if (!IsValidTypeLookup(entry)) { + entry = binder.entry_retriever.GetEntry(INVALID_CATALOG, INVALID_SCHEMA, type_lookup, + OnEntryNotFound::RETURN_NULL); + } + if (!IsValidTypeLookup(entry)) { + entry = binder.entry_retriever.GetEntry(SYSTEM_CATALOG, DEFAULT_SCHEMA, type_lookup, + OnEntryNotFound::THROW_EXCEPTION); + } + } + + // By this point we have to have found a type in the catalog + D_ASSERT(entry != nullptr); + auto &type_entry = entry->Cast(); + + // Now handle type parameters + auto &unbound_parameters = type_expr.GetChildren(); + + if (!type_entry.bind_function) { + if (!unbound_parameters.empty()) { + // This type does not support type parameters + throw BinderException(type_expr, "Type '%s' does not take any type parameters", type_name); + } + + // Otherwise, return the user type directly! + auto result_expr = make_uniq(Value::TYPE(type_entry.user_type)); + result_expr->query_location = type_expr.GetQueryLocation(); + return BindResult(std::move(result_expr)); + } + + // Bind value parameters + vector bound_parameters; + + for (auto ¶m : unbound_parameters) { + // Otherwise, try to fold it to a constant value + ConstantBinder binder(this->binder, context, StringUtil::Format("Type parameter for type '%s'", type_name)); + + auto expr = param->Copy(); + auto bound_expr = binder.Bind(expr); + + if (!bound_expr->IsFoldable()) { + throw BinderException(type_expr, "Type parameter expression for type '%s' is not a constant", type_name); + } + + // Shortcut for constant expressions + if (bound_expr->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) { + auto &const_expr = bound_expr->Cast(); + bound_parameters.emplace_back(param->GetAlias(), const_expr.value); + continue; + } + + // Otherwise we need to evaluate the expression + auto bound_param = ExpressionExecutor::EvaluateScalar(context, *bound_expr); + bound_parameters.emplace_back(param->GetAlias(), bound_param); + }; + + // Call the bind function + BindLogicalTypeInput input {context, type_entry.user_type, bound_parameters}; + auto result_type = type_entry.bind_function(input); + + // Return the resulting type! + auto result_expr = make_uniq(Value::TYPE(result_type)); + result_expr->query_location = type_expr.GetQueryLocation(); + return BindResult(std::move(result_expr)); +} + +} // namespace duckdb diff --git a/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp b/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp index ab162808e..40aad85bb 100644 --- a/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp +++ b/src/duckdb/src/planner/binder/query_node/plan_subquery.cpp @@ -80,7 +80,7 @@ static unique_ptr PlanUncorrelatedSubquery(Binder &binder, BoundSubq D_ASSERT(bindings.size() == 1); idx_t table_idx = bindings[0].table_index; - bool error_on_multiple_rows = DBConfig::GetSetting(binder.context); + bool error_on_multiple_rows = Settings::Get(binder.context); // we push an aggregate that returns the FIRST element vector> expressions; diff --git a/src/duckdb/src/planner/binder/statement/bind_copy.cpp b/src/duckdb/src/planner/binder/statement/bind_copy.cpp index 7a6944b4a..b627e7fb1 100644 --- a/src/duckdb/src/planner/binder/statement/bind_copy.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_copy.cpp @@ -422,10 +422,21 @@ vector BindCopyOption(ClientContext &context, TableFunctionBinder &option return result; } } + const bool is_partition_by = StringUtil::CIEquals(name, "partition_by"); + + if (is_partition_by) { + //! When binding the 'partition_by' option, we don't want to resolve a column reference to a SQLValueFunction + //! (like 'user') + option_binder.DisableSQLValueFunctions(); + } auto bound_expr = option_binder.Bind(expr); if (bound_expr->HasParameter()) { throw ParameterNotResolvedException(); } + if (is_partition_by) { + option_binder.EnableSQLValueFunctions(); + } + auto val = ExpressionExecutor::EvaluateScalar(context, *bound_expr, true); if (val.IsNull()) { throw BinderException("NULL is not supported as a valid option for COPY option \"" + name + "\""); diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp index 01467054f..6fd3e090d 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create.cpp @@ -44,6 +44,8 @@ #include "duckdb/common/type_visitor.hpp" #include "duckdb/function/table_macro_function.hpp" #include "duckdb/main/settings.hpp" +#include "duckdb/parser/expression/type_expression.hpp" +#include "duckdb/planner/expression/bound_constant_expression.hpp" namespace duckdb { @@ -166,7 +168,7 @@ void Binder::BindCreateViewInfo(CreateViewInfo &base) { auto &dependencies = base.dependencies; auto &catalog = Catalog::GetCatalog(context, base.catalog); - bool should_create_dependencies = DBConfig::GetSetting(context); + bool should_create_dependencies = Settings::Get(context); if (should_create_dependencies) { view_binder->SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) { if (&catalog != &entry.ParentCatalog()) { @@ -264,14 +266,40 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) { }); } + // Constant-fold all default parameter expressions + for (auto &it : function->default_parameters) { + auto ¶m_name = it.first; + auto ¶m_expr = it.second; + + if (param_expr->type == ExpressionType::VALUE_CONSTANT) { + continue; + } + + ConstantBinder binder(*this, context, StringUtil::Format("Default value for parameter '%s'", param_name)); + auto default_expr = param_expr->Copy(); + auto bound_default = binder.Bind(default_expr); + if (!bound_default->IsFoldable()) { + auto msg = StringUtil::Format("Default value '%s' for parameter '%s' is not a constant expression.", + param_expr->ToString(), param_name); + throw BinderException(msg); + } + + auto default_val = ExpressionExecutor::EvaluateScalar(context, *bound_default); + + // Save this back as a constant expression + auto const_expr = make_uniq(default_val); + const_expr->alias = param_name; + it.second = std::move(const_expr); + } + // Resolve any user type arguments for (idx_t param_idx = 0; param_idx < function->types.size(); param_idx++) { auto &type = function->types[param_idx]; if (type.id() == LogicalTypeId::UNKNOWN) { continue; } - if (type.id() == LogicalTypeId::USER) { - type = TransformStringToLogicalType(type.ToString(), context); + if (type.id() == LogicalTypeId::UNBOUND) { + BindLogicalType(type); } const auto ¶m_name = function->parameters[param_idx]->Cast().GetColumnName(); auto it = function->default_parameters.find(param_name); @@ -304,7 +332,7 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) { macro_binding = this_macro_binding.get(); auto &dependencies = base.dependencies; - const auto should_create_dependencies = DBConfig::GetSetting(context); + const auto should_create_dependencies = Settings::Get(context); const auto binder_callback = [&dependencies, &catalog](CatalogEntry &entry) { if (&catalog != &entry.ParentCatalog()) { // Don't register any cross-catalog dependencies @@ -364,132 +392,49 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) { return BindCreateSchema(info); } -static bool IsValidUserType(optional_ptr entry) { - if (!entry) { - return false; - } - return entry->Cast().user_type.id() != LogicalTypeId::INVALID; -} +LogicalType Binder::BindLogicalTypeInternal(const unique_ptr &type_expr) { + ConstantBinder binder(*this, context, "Type binding"); + auto copy = type_expr->Copy(); + auto expr = binder.Bind(copy); -LogicalType Binder::BindLogicalTypeInternal(const LogicalType &type, optional_ptr catalog, - const string &schema) { - if (type.id() != LogicalTypeId::USER) { - // Nested type, make sure to bind any nested user types recursively - LogicalType result; - switch (type.id()) { - case LogicalTypeId::LIST: { - auto child_type = BindLogicalTypeInternal(ListType::GetChildType(type), catalog, schema); - result = LogicalType::LIST(child_type); - break; - } - case LogicalTypeId::MAP: { - auto key_type = BindLogicalTypeInternal(MapType::KeyType(type), catalog, schema); - auto value_type = BindLogicalTypeInternal(MapType::ValueType(type), catalog, schema); - result = LogicalType::MAP(std::move(key_type), std::move(value_type)); - break; - } - case LogicalTypeId::ARRAY: { - auto child_type = BindLogicalTypeInternal(ArrayType::GetChildType(type), catalog, schema); - auto array_size = ArrayType::GetSize(type); - result = LogicalType::ARRAY(child_type, array_size); - break; - } - case LogicalTypeId::STRUCT: { - auto child_types = StructType::GetChildTypes(type); - child_list_t new_child_types; - for (auto &entry : child_types) { - new_child_types.emplace_back(entry.first, BindLogicalTypeInternal(entry.second, catalog, schema)); - } - result = LogicalType::STRUCT(std::move(new_child_types)); - break; - } - case LogicalTypeId::UNION: { - child_list_t member_types; - for (idx_t i = 0; i < UnionType::GetMemberCount(type); i++) { - auto child_type = BindLogicalTypeInternal(UnionType::GetMemberType(type, i), catalog, schema); - member_types.emplace_back(UnionType::GetMemberName(type, i), std::move(child_type)); - } - result = LogicalType::UNION(std::move(member_types)); - break; - } - default: - return type; - } - - // Set the alias and extension info back - result.SetAlias(type.GetAlias()); - auto ext_info = type.HasExtensionInfo() ? make_uniq(*type.GetExtensionInfo()) : nullptr; - result.SetExtensionInfo(std::move(ext_info)); - return result; + if (!expr->IsFoldable()) { + throw BinderException(*type_expr, "Type expression is not constant"); } - // User type, bind the user type - auto user_type_name = UserType::GetTypeName(type); - auto user_type_schema = UserType::GetSchema(type); - auto user_type_mods = UserType::GetTypeModifiers(type); - - bind_logical_type_function_t user_bind_modifiers_func = nullptr; - - LogicalType result; - EntryLookupInfo type_lookup(CatalogType::TYPE_ENTRY, user_type_name); - if (catalog) { - // The search order is: - // 1) In the explicitly set schema (my_schema.my_type) - // 2) In the same schema as the table - // 3) In the same catalog - // 4) System catalog - - optional_ptr entry = nullptr; - if (!user_type_schema.empty()) { - entry = entry_retriever.GetEntry(*catalog, user_type_schema, type_lookup, OnEntryNotFound::RETURN_NULL); - } - if (!IsValidUserType(entry)) { - entry = entry_retriever.GetEntry(*catalog, schema, type_lookup, OnEntryNotFound::RETURN_NULL); - } - if (!IsValidUserType(entry)) { - entry = entry_retriever.GetEntry(*catalog, INVALID_SCHEMA, type_lookup, OnEntryNotFound::RETURN_NULL); - } - if (!IsValidUserType(entry)) { - entry = entry_retriever.GetEntry(INVALID_CATALOG, INVALID_SCHEMA, type_lookup, - OnEntryNotFound::THROW_EXCEPTION); - } - auto &type_entry = entry->Cast(); - result = type_entry.user_type; - user_bind_modifiers_func = type_entry.bind_function; - } else { - string type_catalog = UserType::GetCatalog(type); - string type_schema = UserType::GetSchema(type); - - BindSchemaOrCatalog(context, type_catalog, type_schema); - auto entry = entry_retriever.GetEntry(type_catalog, type_schema, type_lookup); - auto &type_entry = entry->Cast(); - result = type_entry.user_type; - user_bind_modifiers_func = type_entry.bind_function; + if (expr->return_type != LogicalTypeId::TYPE) { + throw BinderException(*type_expr, "Expected a type returning expression, but got expression of type '%s'", + expr->return_type.ToString()); } - // Now we bind the inner user type - BindLogicalType(result, catalog, schema); - - // Apply the type modifiers (if any) - if (user_bind_modifiers_func) { - // If an explicit bind_modifiers function was provided, use that to construct the type - - BindLogicalTypeInput input {context, result, user_type_mods}; - result = user_bind_modifiers_func(input); - } else { - if (!user_type_mods.empty()) { - throw BinderException("Type '%s' does not take any type modifiers", user_type_name); - } + // Shortcut for constant expressions + if (expr->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) { + auto &const_expr = expr->Cast(); + return TypeValue::GetType(const_expr.value); } - return result; + + // Else, evaluate the type expression + auto type_value = ExpressionExecutor::EvaluateScalar(context, *expr); + D_ASSERT(type_value.type().id() == LogicalTypeId::TYPE); + return TypeValue::GetType(type_value); } -void Binder::BindLogicalType(LogicalType &type, optional_ptr catalog, const string &schema) { - // check if we need to bind this type at all - if (!TypeVisitor::Contains(type, LogicalTypeId::USER)) { +void Binder::BindLogicalType(LogicalType &type) { + // Check if we need to bind this type at all + if (!TypeVisitor::Contains(type, LogicalTypeId::UNBOUND)) { return; } - type = BindLogicalTypeInternal(type, catalog, schema); + + // Replace all unbound types within the type + // Normally, the unbound type is the root type, but it can also be nested within other types if we e.g. + // alter-table and change a struct field. + type = TypeVisitor::VisitReplace(type, [&](const LogicalType &ty) { + if (ty.id() == LogicalTypeId::UNBOUND) { + auto &type_expr = UnboundType::GetTypeExpression(ty); + return BindLogicalTypeInternal(type_expr); + } + + return ty; + }); } unique_ptr DuckCatalog::BindCreateIndex(Binder &binder, CreateStatement &stmt, @@ -621,26 +566,10 @@ BoundStatement Binder::Bind(CreateStatement &stmt) { } result.plan->AddChild(std::move(query)); - } else if (create_type_info.type.id() == LogicalTypeId::USER) { - SetCatalogLookupCallback(dependency_callback); - // two cases: - // 1: create a type with a non-existent type as source, Binder::BindLogicalType(...) will throw exception. - // 2: create a type alias with a custom type. - // eg. CREATE TYPE a AS INT; CREATE TYPE b AS a; - // We set b to be an alias for the underlying type of a - - EntryLookupInfo type_lookup(CatalogType::TYPE_ENTRY, UserType::GetTypeName(create_type_info.type)); - auto type_entry_p = entry_retriever.GetEntry(schema.catalog.GetName(), schema.name, type_lookup); - D_ASSERT(type_entry_p); - auto &type_entry = type_entry_p->Cast(); - create_type_info.type = type_entry.user_type; } else { SetCatalogLookupCallback(dependency_callback); - // This is done so that if the type contains a USER type, - // we register this dependency - auto preserved_type = create_type_info.type; + // Bind the underlying type BindLogicalType(create_type_info.type); - create_type_info.type = preserved_type; } break; } diff --git a/src/duckdb/src/planner/binder/statement/bind_create_table.cpp b/src/duckdb/src/planner/binder/statement/bind_create_table.cpp index ac8a32f65..4ba4eb686 100644 --- a/src/duckdb/src/planner/binder/statement/bind_create_table.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_create_table.cpp @@ -23,6 +23,7 @@ #include "duckdb/parser/parsed_expression_iterator.hpp" #include "duckdb/storage/data_table.hpp" #include "duckdb/storage/storage_manager.hpp" +#include "duckdb/common/type_visitor.hpp" namespace duckdb { @@ -55,7 +56,7 @@ static void VerifyCompressionType(ClientContext &context, optional_ptr( context, INVALID_CATALOG, INVALID_SCHEMA, logical_type.GetAlias(), OnEntryNotFound::RETURN_NULL); @@ -284,6 +285,7 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) { continue; } D_ASSERT(col.Generated()); + auto expression = col.GeneratedExpression().Copy(); auto bound_expression = expr_binder.Bind(expression); @@ -299,7 +301,12 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) { // Update the type in the binding, for future expansions table_binding->SetColumnType(i.index, col.Type()); + } else if (col.Type().id() == LogicalTypeId::UNBOUND) { + // Bind column type + BindLogicalType(col.TypeMutable()); + table_binding->SetColumnType(i.index, col.Type()); } + bound_indices.insert(i); } } @@ -352,8 +359,8 @@ unique_ptr Binder::BindCreateTableCheckpoint(unique_ptr &gcols, - bool &contains_gcol) { +static void ExpressionContainsGeneratedColumn(const ParsedExpression &root_expr, const unordered_set &gcols, + bool &contains_gcol) { ParsedExpressionIterator::VisitExpression(root_expr, [&](const ColumnRefExpression &column_ref) { auto &name = column_ref.GetColumnName(); @@ -596,6 +603,10 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrSetSearchPath(result->schema.catalog, result->schema.name); + vector> bound_constraints; if (base.query) { // construct the result object @@ -631,23 +642,34 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrschema.catalog, result->schema.name); + type_binder->BindLogicalType(column.TypeMutable()); } + } else { SetCatalogLookupCallback([&dependencies, &schema](CatalogEntry &entry) { if (&schema.ParentCatalog() != &entry.ParentCatalog()) { // Don't register dependencies between catalogs return; } + + if (entry.type == CatalogType::TYPE_ENTRY && entry.internal) { + // Don't register dependencies on internal types + return; + } + dependencies.AddDependency(entry); }); + // Bind all physical column types + for (idx_t i = 0; i < base.columns.PhysicalColumnCount(); i++) { + auto &column = base.columns.GetColumnMutable(PhysicalIndex(i)); + type_binder->BindLogicalType(column.TypeMutable()); + } + auto &config = DBConfig::Get(catalog.GetAttached()); VerifyCompressionType(context, storage_manager, config, *result); CreateColumnDependencyManager(*result); @@ -655,14 +677,6 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrschema.catalog, result->schema.name); - } BindCreateTableConstraints(base, entry_retriever, schema); if (AnyConstraintReferencesGeneratedColumn(base)) { @@ -681,6 +695,16 @@ unique_ptr Binder::BindCreateTableInfo(unique_ptrdependencies.VerifyDependencies(schema.catalog, result->Base().table); +#ifdef DEBUG + // Ensure all types are bound + for (idx_t i = 0; i < base.columns.LogicalColumnCount(); i++) { + auto &column = base.columns.GetColumn(LogicalIndex(i)); + if (TypeVisitor::Contains(column.Type(), LogicalTypeId::UNBOUND)) { + throw InternalException("Unbound type remaining in column \"%s\" during Create Table bind", column.Name()); + } + } +#endif + auto &properties = GetStatementProperties(); properties.output_type = QueryResultOutputType::FORCE_MATERIALIZED; return result; diff --git a/src/duckdb/src/planner/binder/statement/bind_insert.cpp b/src/duckdb/src/planner/binder/statement/bind_insert.cpp index f9c073ad9..0d44ac5ac 100644 --- a/src/duckdb/src/planner/binder/statement/bind_insert.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_insert.cpp @@ -387,9 +387,10 @@ unique_ptr Binder::GenerateMergeInto(InsertStatement &stmt, named_column_map.push_back(col.Logical()); } } else { + // Ensure that the columns are valid. for (auto &col_name : stmt.columns) { - auto &col = table.GetColumn(col_name); - named_column_map.push_back(col.Logical()); + auto col_idx = table.GetColumnIndex(col_name); + named_column_map.push_back(col_idx); } } ExpandDefaultInValuesList(stmt, table, values_list, named_column_map); diff --git a/src/duckdb/src/planner/binder/statement/bind_simple.cpp b/src/duckdb/src/planner/binder/statement/bind_simple.cpp index f21f26b9f..6da3a9ec4 100644 --- a/src/duckdb/src/planner/binder/statement/bind_simple.cpp +++ b/src/duckdb/src/planner/binder/statement/bind_simple.cpp @@ -76,6 +76,28 @@ BoundStatement Binder::BindAlterAddIndex(BoundStatement &result, CatalogEntry &e return std::move(result); } +static void BindAlterTypes(Binder &binder, AlterStatement &stmt) { + if (stmt.info->type == AlterType::ALTER_TABLE) { + auto &table_info = stmt.info->Cast(); + switch (table_info.alter_table_type) { + case AlterTableType::ADD_COLUMN: { + auto &add_info = table_info.Cast(); + binder.BindLogicalType(add_info.new_column.TypeMutable()); + } break; + case AlterTableType::ADD_FIELD: { + auto &add_info = table_info.Cast(); + binder.BindLogicalType(add_info.new_field.TypeMutable()); + } break; + case AlterTableType::ALTER_COLUMN_TYPE: { + auto &alter_column_info = table_info.Cast(); + binder.BindLogicalType(alter_column_info.target_type); + } break; + default: + break; + } + } +} + BoundStatement Binder::Bind(AlterStatement &stmt) { BoundStatement result; result.names = {"Success"}; @@ -97,7 +119,6 @@ BoundStatement Binder::Bind(AlterStatement &stmt) { // Extra step for column comments: They can alter a table or a view, and we resolve that here. auto &info = stmt.info->Cast(); entry = info.TryResolveCatalogEntry(entry_retriever); - } else { // For any other ALTER, we retrieve the catalog entry directly. EntryLookupInfo lookup_info(stmt.info->GetCatalogType(), stmt.info->name); @@ -107,12 +128,22 @@ BoundStatement Binder::Bind(AlterStatement &stmt) { auto &properties = GetStatementProperties(); properties.return_type = StatementReturnType::NOTHING; if (!entry) { + // Bind types in this binder + BindAlterTypes(*this, stmt); + result.plan = make_uniq(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info)); return result; } D_ASSERT(!entry->deleted); auto &catalog = entry->ParentCatalog(); + + // Bind types in the same catalog as the entry + auto type_binder = Binder::CreateBinder(context, *this); + type_binder->SetSearchPath(catalog, stmt.info->schema); + + BindAlterTypes(*type_binder, stmt); + if (catalog.IsSystemCatalog()) { throw BinderException("Can not comment on System Catalog entries"); } diff --git a/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp b/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp index 6ff5d36f6..a7b99e904 100644 --- a/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp +++ b/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp @@ -23,9 +23,7 @@ namespace duckdb { static bool TryLoadExtensionForReplacementScan(ClientContext &context, const string &table_name) { auto lower_name = StringUtil::Lower(table_name); - auto &dbconfig = DBConfig::GetConfig(context); - - if (!dbconfig.options.autoload_known_extensions) { + if (!Settings::Get(context)) { return false; } @@ -113,6 +111,11 @@ vector Binder::GetSearchPath(Catalog &catalog, const string return view_search_path; } +void Binder::SetSearchPath(Catalog &catalog, const string &schema) { + auto search_path = GetSearchPath(catalog, schema); + entry_retriever.SetSearchPath(std::move(search_path)); +} + static vector ExchangeAllNullTypes(const vector &types) { vector result = types; for (auto &type : result) { @@ -205,7 +208,7 @@ BoundStatement Binder::Bind(BaseTableRef &ref) { } } auto &config = DBConfig::GetConfig(context); - if (context.config.use_replacement_scans && config.options.enable_external_access && + if (context.config.use_replacement_scans && Settings::Get(config) && ExtensionHelper::IsFullPath(full_path)) { auto &fs = FileSystem::GetFileSystem(context); if (!fs.IsDisabledForPath(full_path) && fs.FileExists(full_path)) { diff --git a/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp b/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp index 99c131a89..3e1094e52 100644 --- a/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp +++ b/src/duckdb/src/planner/binder/tableref/bind_pivot.cpp @@ -22,6 +22,8 @@ #include "duckdb/planner/operator/logical_aggregate.hpp" #include "duckdb/planner/operator/logical_pivot.hpp" #include "duckdb/main/settings.hpp" +#include "duckdb/execution/expression_executor.hpp" +#include "duckdb/planner/expression_binder/constant_binder.hpp" namespace duckdb { @@ -506,6 +508,37 @@ BoundStatement Binder::BindBoundPivot(PivotRef &ref) { return result_statement; } +static void BindPivotInList(unique_ptr &expr, vector &values, Binder &binder) { + switch (expr->GetExpressionType()) { + case ExpressionType::COLUMN_REF: { + auto &colref = expr->Cast(); + if (colref.IsQualified()) { + throw BinderException(expr->GetQueryLocation(), "PIVOT IN list cannot contain qualified column references"); + } + values.emplace_back(colref.GetColumnName()); + } break; + case ExpressionType::FUNCTION: { + auto &function = expr->Cast(); + if (function.function_name != "row") { + throw BinderException(expr->GetQueryLocation(), "PIVOT IN list must contain columns or lists of columns"); + } + for (auto &child : function.children) { + BindPivotInList(child, values, binder); + } + } break; + default: { + Value val; + ConstantBinder const_binder(binder, binder.context, "PIVOT IN list"); + auto bound_expr = const_binder.Bind(expr); + if (!bound_expr->IsFoldable()) { + throw BinderException(expr->GetQueryLocation(), "PIVOT IN list must contain constant expressions"); + } + auto folded_value = ExpressionExecutor::EvaluateScalar(binder.context, *bound_expr); + values.push_back(folded_value); + } break; + } +} + unique_ptr Binder::BindPivot(PivotRef &ref, vector> all_columns) { // keep track of the columns by which we pivot/aggregate // any columns which are not pivoted/aggregated on are added to the GROUP BY clause @@ -533,6 +566,32 @@ unique_ptr Binder::BindPivot(PivotRef &ref, vector Binder::BindPivot(PivotRef &ref, vector(context); + auto pivot_limit = Settings::Get(context); if (total_pivots >= pivot_limit) { throw BinderException(ref, "Pivot column limit of %llu exceeded. Use SET pivot_limit=X to increase the limit.", pivot_limit); @@ -603,7 +662,7 @@ unique_ptr Binder::BindPivot(PivotRef &ref, vector filtered aggregates are faster when there are FEW pivot values // -> LIST is faster when there are MANY pivot values // we switch dynamically based on the number of pivots to compute - auto pivot_filter_threshold = DBConfig::GetSetting(context); + auto pivot_filter_threshold = Settings::Get(context); if (pivot_values.size() <= pivot_filter_threshold) { // use a set of filtered aggregates pivot_node = @@ -640,6 +699,17 @@ struct UnpivotEntry { void Binder::ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry, vector &unpivot_entries) { + // Try to bind the entry expression as values + try { + auto expr_copy = entry.expr->Copy(); + BindPivotInList(expr_copy, entry.values, child_binder); + // successfully bound as values - clear the expression + entry.expr = nullptr; + } catch (...) { + // ignore binder exceptions here - we fall back to expression mode + entry.values.clear(); + } + if (!entry.expr) { // pivot entry without an expression - generate one UnpivotEntry unpivot_entry; diff --git a/src/duckdb/src/planner/binder/tableref/bind_showref.cpp b/src/duckdb/src/planner/binder/tableref/bind_showref.cpp index d2d91c3af..3b68d6bd8 100644 --- a/src/duckdb/src/planner/binder/tableref/bind_showref.cpp +++ b/src/duckdb/src/planner/binder/tableref/bind_showref.cpp @@ -156,6 +156,16 @@ BoundStatement Binder::BindShowTable(ShowRef &ref) { string sql; if (lname == "\"databases\"") { sql = PragmaShowDatabases(); + } else if (lname == "\"schemas\"") { + sql = "SELECT " + " schema.database_name, " + " schema.schema_name, " + " ((select current_schema() = schema.schema_name) " + " and (select current_database() = schema.database_name)) \"current\" " + "FROM duckdb_schemas() schema " + "JOIN duckdb_databases dbs USING (database_oid) " + "WHERE dbs.internal = false " + "ORDER BY all;"; } else if (lname == "\"tables\"") { sql = PragmaShowTables(); } else if (ref.show_type == ShowType::SHOW_FROM) { diff --git a/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp b/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp index 528478c58..4d2a47629 100644 --- a/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp +++ b/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp @@ -193,7 +193,7 @@ BoundStatement Binder::BindTableFunctionInternal(TableFunction &table_function, vector return_names; auto constexpr ordinality_name = "ordinality"; string ordinality_column_name = ordinality_name; - idx_t ordinality_column_id; + optional_idx ordinality_column_id; if (table_function.bind || table_function.bind_replace || table_function.bind_operator) { TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names, table_function.function_info.get(), this, table_function, ref); diff --git a/src/duckdb/src/planner/collation_binding.cpp b/src/duckdb/src/planner/collation_binding.cpp index dd371bbc4..ea70f0194 100644 --- a/src/duckdb/src/planner/collation_binding.cpp +++ b/src/duckdb/src/planner/collation_binding.cpp @@ -20,7 +20,7 @@ bool PushVarcharCollation(ClientContext &context, unique_ptr &source auto str_collation = StringType::GetCollation(sql_type); string collation; if (str_collation.empty()) { - collation = DBConfig::GetSetting(context); + collation = Settings::Get(context); } else { collation = str_collation; } diff --git a/src/duckdb/src/planner/expression/bound_cast_expression.cpp b/src/duckdb/src/planner/expression/bound_cast_expression.cpp index e2efdfa2e..1de7ee2b1 100644 --- a/src/duckdb/src/planner/expression/bound_cast_expression.cpp +++ b/src/duckdb/src/planner/expression/bound_cast_expression.cpp @@ -6,6 +6,7 @@ #include "duckdb/function/cast_rules.hpp" #include "duckdb/function/cast/cast_function_set.hpp" #include "duckdb/main/config.hpp" +#include "duckdb/planner/expression_binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/expression/bound_function_expression.cpp b/src/duckdb/src/planner/expression/bound_function_expression.cpp index dc6332531..1871951c4 100644 --- a/src/duckdb/src/planner/expression/bound_function_expression.cpp +++ b/src/duckdb/src/planner/expression/bound_function_expression.cpp @@ -31,10 +31,10 @@ bool BoundFunctionExpression::IsFoldable() const { if (function.HasBindLambdaCallback()) { // This is a lambda function D_ASSERT(bind_info); - auto &lambda_bind_data = bind_info->Cast(); - if (lambda_bind_data.lambda_expr) { - auto &expr = *lambda_bind_data.lambda_expr; - if (expr.IsVolatile()) { + auto &lambda_bind_data = bind_info->Cast(); + auto &lambda_expr = lambda_bind_data.GetLambdaExpression(); + if (lambda_expr) { + if (lambda_expr->IsVolatile()) { return false; } } diff --git a/src/duckdb/src/planner/expression_binder.cpp b/src/duckdb/src/planner/expression_binder.cpp index de1019753..c2cc9bff5 100644 --- a/src/duckdb/src/planner/expression_binder.cpp +++ b/src/duckdb/src/planner/expression_binder.cpp @@ -7,6 +7,7 @@ #include "duckdb/planner/expression_iterator.hpp" #include "duckdb/common/operator/cast_operators.hpp" #include "duckdb/main/client_config.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/common/string_util.hpp" namespace duckdb { @@ -47,11 +48,11 @@ void ExpressionBinder::InitializeStackCheck() { StackChecker ExpressionBinder::StackCheck(const ParsedExpression &expr, idx_t extra_stack) { D_ASSERT(stack_depth != DConstants::INVALID_INDEX); - auto &options = ClientConfig::GetConfig(context); - if (stack_depth + extra_stack >= options.max_expression_depth) { + auto max_expression_depth = Settings::Get(context); + if (stack_depth + extra_stack >= max_expression_depth) { throw BinderException("Max expression depth limit of %lld exceeded. Use \"SET max_expression_depth TO x\" to " "increase the maximum expression depth.", - options.max_expression_depth); + max_expression_depth); } return StackChecker(*this, extra_stack); } @@ -79,6 +80,8 @@ BindResult ExpressionBinder::BindExpression(unique_ptr &expr, return BindExpression(expr_ref.Cast(), depth); case ExpressionClass::CONSTANT: return BindExpression(expr_ref.Cast(), depth); + case ExpressionClass::TYPE: + return BindExpression(expr_ref.Cast(), depth); case ExpressionClass::FUNCTION: { auto &function = expr_ref.Cast(); if (IsUnnestFunction(function.function_name)) { diff --git a/src/duckdb/src/planner/expression_binder/having_binder.cpp b/src/duckdb/src/planner/expression_binder/having_binder.cpp index ab0f11af5..c6a7ad3af 100644 --- a/src/duckdb/src/planner/expression_binder/having_binder.cpp +++ b/src/duckdb/src/planner/expression_binder/having_binder.cpp @@ -15,6 +15,10 @@ HavingBinder::HavingBinder(Binder &binder, ClientContext &context, BoundSelectNo target_type = LogicalType(LogicalTypeId::BOOLEAN); } +bool HavingBinder::DoesColumnAliasExist(const ColumnRefExpression &colref) { + return column_alias_binder.DoesColumnAliasExist(colref); +} + BindResult HavingBinder::BindLambdaReference(LambdaRefExpression &expr, idx_t depth) { D_ASSERT(lambda_bindings && expr.lambda_idx < lambda_bindings->size()); auto &lambda_ref = expr.Cast(); diff --git a/src/duckdb/src/planner/expression_binder/order_binder.cpp b/src/duckdb/src/planner/expression_binder/order_binder.cpp index 3923129fb..1ad8582eb 100644 --- a/src/duckdb/src/planner/expression_binder/order_binder.cpp +++ b/src/duckdb/src/planner/expression_binder/order_binder.cpp @@ -61,7 +61,7 @@ optional_idx OrderBinder::TryGetProjectionReference(ParsedExpression &expr) cons // ORDER BY has no effect // this is disabled by default (matching Postgres) - but we can control this with a setting auto order_by_non_integer_literal = - DBConfig::GetSetting(binders[0].get().context); + Settings::Get(binders[0].get().context); if (!order_by_non_integer_literal) { throw BinderException(expr, "%s non-integer literal has no effect.\n* SET " @@ -83,11 +83,28 @@ optional_idx OrderBinder::TryGetProjectionReference(ParsedExpression &expr) cons string alias_name = colref.column_names.back(); // check the alias list auto entry = bind_state.alias_map.find(alias_name); - if (entry == bind_state.alias_map.end()) { - break; + if (entry != bind_state.alias_map.end()) { + // this is an alias - return the index + return entry->second; } - // this is an alias - return the index - return entry->second; + // check the expression list + vector matching_columns; + for (idx_t i = 0; i < bind_state.original_expressions.size(); i++) { + if (bind_state.original_expressions[i]->type != ExpressionType::COLUMN_REF) { + continue; + } + auto &colref = bind_state.original_expressions[i]->Cast(); + if (colref.HasAlias()) { + continue; + } + if (colref.GetColumnName() == alias_name) { + matching_columns.push_back(i); + } + } + if (matching_columns.size() == 1) { + return matching_columns[0]; + } + break; } case ExpressionClass::POSITIONAL_REFERENCE: { auto &posref = expr.Cast(); diff --git a/src/duckdb/src/planner/expression_binder/table_function_binder.cpp b/src/duckdb/src/planner/expression_binder/table_function_binder.cpp index 16b612cd6..f653a129d 100644 --- a/src/duckdb/src/planner/expression_binder/table_function_binder.cpp +++ b/src/duckdb/src/planner/expression_binder/table_function_binder.cpp @@ -51,9 +51,11 @@ BindResult TableFunctionBinder::BindColumnReference(unique_ptr } } - auto value_function = ExpressionBinder::GetSQLValueFunction(column_names.back()); - if (value_function) { - return BindExpression(value_function, depth, root_expression); + if (accept_sql_value_functions) { + auto value_function = ExpressionBinder::GetSQLValueFunction(column_names.back()); + if (value_function) { + return BindExpression(value_function, depth, root_expression); + } } auto result = BindCorrelatedColumns(expr_ptr, ErrorData("error")); diff --git a/src/duckdb/src/planner/operator/logical_delete.cpp b/src/duckdb/src/planner/operator/logical_delete.cpp index d82c3bfd8..de3080f02 100644 --- a/src/duckdb/src/planner/operator/logical_delete.cpp +++ b/src/duckdb/src/planner/operator/logical_delete.cpp @@ -3,6 +3,7 @@ #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" #include "duckdb/main/config.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/operator/logical_extension_operator.cpp b/src/duckdb/src/planner/operator/logical_extension_operator.cpp index 2e0cb6d15..98fea77ed 100644 --- a/src/duckdb/src/planner/operator/logical_extension_operator.cpp +++ b/src/duckdb/src/planner/operator/logical_extension_operator.cpp @@ -1,8 +1,8 @@ #include "duckdb/planner/operator/logical_extension_operator.hpp" #include "duckdb/execution/column_binding_resolver.hpp" -#include "duckdb/main/config.hpp" #include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/planner/operator_extension.hpp" namespace duckdb { @@ -26,9 +26,9 @@ void LogicalExtensionOperator::Serialize(Serializer &serializer) const { } unique_ptr LogicalExtensionOperator::Deserialize(Deserializer &deserializer) { - auto &config = DBConfig::GetConfig(deserializer.Get()); + auto &context = deserializer.Get(); auto extension_name = deserializer.ReadProperty(200, "extension_name"); - for (auto &extension : config.operator_extensions) { + for (auto &extension : OperatorExtension::Iterate(context)) { if (extension->GetName() == extension_name) { return extension->Deserialize(deserializer); } diff --git a/src/duckdb/src/planner/operator/logical_insert.cpp b/src/duckdb/src/planner/operator/logical_insert.cpp index bab6820fe..52c5d25d1 100644 --- a/src/duckdb/src/planner/operator/logical_insert.cpp +++ b/src/duckdb/src/planner/operator/logical_insert.cpp @@ -3,6 +3,7 @@ #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" #include "duckdb/main/config.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/operator/logical_merge_into.cpp b/src/duckdb/src/planner/operator/logical_merge_into.cpp index fa99f69ab..cd74905dd 100644 --- a/src/duckdb/src/planner/operator/logical_merge_into.cpp +++ b/src/duckdb/src/planner/operator/logical_merge_into.cpp @@ -1,6 +1,8 @@ #include "duckdb/planner/operator/logical_merge_into.hpp" + #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" #include "duckdb/parser/parsed_data/create_table_info.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/operator/logical_update.cpp b/src/duckdb/src/planner/operator/logical_update.cpp index 386264478..b2de4d12d 100644 --- a/src/duckdb/src/planner/operator/logical_update.cpp +++ b/src/duckdb/src/planner/operator/logical_update.cpp @@ -1,7 +1,9 @@ #include "duckdb/planner/operator/logical_update.hpp" + #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" -#include "duckdb/parser/parsed_data/create_table_info.hpp" #include "duckdb/main/config.hpp" +#include "duckdb/parser/parsed_data/create_table_info.hpp" +#include "duckdb/planner/binder.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/operator/logical_vacuum.cpp b/src/duckdb/src/planner/operator/logical_vacuum.cpp index ce4a76951..734ae8ea3 100644 --- a/src/duckdb/src/planner/operator/logical_vacuum.cpp +++ b/src/duckdb/src/planner/operator/logical_vacuum.cpp @@ -1,9 +1,11 @@ #include "duckdb/planner/operator/logical_vacuum.hpp" -#include "duckdb/planner/operator/logical_get.hpp" + #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp" -#include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/common/serializer/serializer.hpp" #include "duckdb/parser/parsed_data/vacuum_info.hpp" +#include "duckdb/planner/binder.hpp" +#include "duckdb/planner/operator/logical_get.hpp" namespace duckdb { diff --git a/src/duckdb/src/planner/planner.cpp b/src/duckdb/src/planner/planner.cpp index e6794dcfc..1a40de239 100644 --- a/src/duckdb/src/planner/planner.cpp +++ b/src/duckdb/src/planner/planner.cpp @@ -9,6 +9,7 @@ #include "duckdb/main/database.hpp" #include "duckdb/main/prepared_statement_data.hpp" #include "duckdb/main/query_profiler.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/planner/binder.hpp" #include "duckdb/planner/expression/bound_parameter_expression.hpp" #include "duckdb/transaction/meta_transaction.hpp" @@ -16,6 +17,7 @@ #include "duckdb/main/attached_database.hpp" #include "duckdb/parser/statement/multi_statement.hpp" #include "duckdb/planner/subquery/flatten_dependent_join.hpp" +#include "duckdb/planner/operator_extension.hpp" namespace duckdb { @@ -58,8 +60,7 @@ void Planner::CreatePlan(SQLStatement &statement) { parameters_resolved = false; } else if (error.Type() != ExceptionType::INVALID) { // different exception type - try operator_extensions - auto &config = DBConfig::GetConfig(context); - for (auto &extension_op : config.operator_extensions) { + for (auto &extension_op : OperatorExtension::Iterate(context)) { auto bound_statement = extension_op->Bind(context, *this->binder, extension_op->operator_info.get(), statement); if (bound_statement.plan != nullptr) { @@ -77,7 +78,7 @@ void Planner::CreatePlan(SQLStatement &statement) { } } if (this->plan) { - auto max_tree_depth = ClientConfig::GetConfig(context).max_expression_depth; + auto max_tree_depth = Settings::Get(context); CheckTreeDepth(*plan, max_tree_depth); this->plan = FlattenDependentJoins::DecorrelateIndependent(*this->binder, std::move(this->plan)); diff --git a/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp b/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp index 23dd23ec4..f6c0315c5 100644 --- a/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp +++ b/src/duckdb/src/planner/subquery/flatten_dependent_join.cpp @@ -618,19 +618,20 @@ unique_ptr FlattenDependentJoins::PushDownDependentJoinInternal } // both sides have correlation // turn into an inner join + // correctly use left child's delim_offset so execute left child as the last one auto join = make_uniq(JoinType::INNER); - plan->children[0] = - PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth); - auto left_binding = this->base_binding; plan->children[1] = PushDownDependentJoinInternal(std::move(plan->children[1]), parent_propagate_null_values, lateral_depth); + auto right_binding = this->base_binding; + plan->children[0] = + PushDownDependentJoinInternal(std::move(plan->children[0]), parent_propagate_null_values, lateral_depth); // add the correlated columns to the join conditions for (idx_t i = 0; i < correlated_columns.size(); i++) { JoinCondition cond; cond.left = make_uniq( - correlated_columns[i].type, ColumnBinding(left_binding.table_index, left_binding.column_index + i)); - cond.right = make_uniq( correlated_columns[i].type, ColumnBinding(base_binding.table_index, base_binding.column_index + i)); + cond.right = make_uniq( + correlated_columns[i].type, ColumnBinding(right_binding.table_index, right_binding.column_index + i)); cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM; join->conditions.push_back(std::move(cond)); } diff --git a/src/duckdb/src/storage/buffer/block_handle.cpp b/src/duckdb/src/storage/buffer/block_handle.cpp index 91c98d4b4..7c3c98e7d 100644 --- a/src/duckdb/src/storage/buffer/block_handle.cpp +++ b/src/duckdb/src/storage/buffer/block_handle.cpp @@ -11,26 +11,25 @@ namespace duckdb { BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, MemoryTag tag) - : block_manager(block_manager), readers(0), block_id(block_id_p), tag(tag), buffer_type(FileBufferType::BLOCK), + : buffer_manager(block_manager.GetBufferManager()), block_manager(block_manager), + block_alloc_size(block_manager.GetBlockAllocSize()), block_header_size(block_manager.GetBlockHeaderSize()), + state(BlockState::BLOCK_UNLOADED), readers(0), block_id(block_id_p), tag(tag), buffer_type(FileBufferType::BLOCK), buffer(nullptr), eviction_seq_num(0), destroy_buffer_upon(DestroyBufferUpon::BLOCK), - memory_charge(tag, block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr), + memory_usage(block_alloc_size), memory_charge(tag, buffer_manager.GetBufferPool()), unswizzled(nullptr), eviction_queue_idx(DConstants::INVALID_INDEX) { - eviction_seq_num = 0; - state = BlockState::BLOCK_UNLOADED; - memory_usage = block_manager.GetBlockAllocSize(); } BlockHandle::BlockHandle(BlockManager &block_manager, block_id_t block_id_p, MemoryTag tag, - unique_ptr buffer_p, DestroyBufferUpon destroy_buffer_upon_p, idx_t block_size, + unique_ptr buffer_p, DestroyBufferUpon destroy_buffer_upon_p, idx_t size_p, BufferPoolReservation &&reservation) - : block_manager(block_manager), readers(0), block_id(block_id_p), tag(tag), buffer_type(buffer_p->GetBufferType()), - eviction_seq_num(0), destroy_buffer_upon(destroy_buffer_upon_p), - memory_charge(tag, block_manager.buffer_manager.GetBufferPool()), unswizzled(nullptr), + : buffer_manager(block_manager.GetBufferManager()), block_manager(block_manager), + block_alloc_size(block_manager.GetBlockAllocSize()), block_header_size(block_manager.GetBlockHeaderSize()), + state(BlockState::BLOCK_LOADED), readers(0), block_id(block_id_p), tag(tag), + buffer_type(buffer_p->GetBufferType()), buffer(std::move(buffer_p)), eviction_seq_num(0), + destroy_buffer_upon(destroy_buffer_upon_p), memory_usage(size_p), + memory_charge(tag, buffer_manager.GetBufferPool()), unswizzled(nullptr), eviction_queue_idx(DConstants::INVALID_INDEX) { - buffer = std::move(buffer_p); - state = BlockState::BLOCK_LOADED; - memory_usage = block_size; - memory_charge = std::move(reservation); + memory_charge = std::move(reservation); // Moved to constructor body due to tidy check. } BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions @@ -38,8 +37,7 @@ BlockHandle::~BlockHandle() { // NOLINT: allow internal exceptions unswizzled = nullptr; D_ASSERT(!buffer || buffer->GetBufferType() == buffer_type); if (buffer && buffer_type != FileBufferType::TINY_BUFFER) { - // we kill the latest version in the eviction queue - auto &buffer_manager = block_manager.buffer_manager; + // Kill the latest version in the eviction queue. buffer_manager.GetBufferPool().IncrementDeadNodes(*this); } @@ -150,8 +148,7 @@ BufferHandle BlockHandle::Load(QueryContext context, unique_ptr reus buffer = std::move(block); } else { if (MustWriteToTemporaryFile()) { - buffer = block_manager.buffer_manager.ReadTemporaryBuffer(QueryContext(), tag, *this, - std::move(reusable_buffer)); + buffer = buffer_manager.ReadTemporaryBuffer(QueryContext(), tag, *this, std::move(reusable_buffer)); } else { return BufferHandle(); // Destroyed upon unpin/evict, so there is no temp buffer to read } @@ -173,7 +170,7 @@ unique_ptr BlockHandle::UnloadAndTakeBlock(BlockLock &lock) { if (block_id >= MAXIMUM_BLOCK && MustWriteToTemporaryFile()) { // temporary block that cannot be destroyed upon evict/unpin: write to temporary file - block_manager.buffer_manager.WriteTemporaryBuffer(tag, block_id, *buffer); + buffer_manager.WriteTemporaryBuffer(tag, block_id, *buffer); } memory_charge.Resize(0); state = BlockState::BLOCK_UNLOADED; @@ -194,8 +191,7 @@ bool BlockHandle::CanUnload() const { // there are active readers return false; } - if (block_id >= MAXIMUM_BLOCK && MustWriteToTemporaryFile() && - !block_manager.buffer_manager.HasTemporaryDirectory()) { + if (block_id >= MAXIMUM_BLOCK && MustWriteToTemporaryFile() && !buffer_manager.HasTemporaryDirectory()) { // this block cannot be destroyed upon evict/unpin // in order to unload this block we need to write it to a temporary buffer // however, no temporary directory is specified! diff --git a/src/duckdb/src/storage/buffer/buffer_handle.cpp b/src/duckdb/src/storage/buffer/buffer_handle.cpp index a0a5d20c9..0658bdc66 100644 --- a/src/duckdb/src/storage/buffer/buffer_handle.cpp +++ b/src/duckdb/src/storage/buffer/buffer_handle.cpp @@ -34,7 +34,7 @@ void BufferHandle::Destroy() { if (!handle || !IsValid()) { return; } - handle->block_manager.buffer_manager.Unpin(handle); + handle->GetBufferManager().Unpin(handle); handle.reset(); node = nullptr; } diff --git a/src/duckdb/src/storage/buffer/buffer_pool.cpp b/src/duckdb/src/storage/buffer/buffer_pool.cpp index 9c13d4ccb..7fdb3ea12 100644 --- a/src/duckdb/src/storage/buffer/buffer_pool.cpp +++ b/src/duckdb/src/storage/buffer/buffer_pool.cpp @@ -5,6 +5,7 @@ #include "duckdb/parallel/concurrentqueue.hpp" #include "duckdb/parallel/task_scheduler.hpp" #include "duckdb/storage/block_allocator.hpp" +#include "duckdb/storage/object_cache.hpp" #include "duckdb/storage/temporary_memory_manager.hpp" namespace duckdb { @@ -314,16 +315,50 @@ TemporaryMemoryManager &BufferPool::GetTemporaryMemoryManager() { return *temporary_memory_manager; } +BufferPool::EvictionResult BufferPool::EvictObjectCacheEntries(MemoryTag tag, idx_t extra_memory, idx_t memory_limit) { + TempBufferPoolReservation r(tag, *this, extra_memory); + + if (memory_usage.GetUsedMemory(MemoryUsageCaches::NO_FLUSH) <= memory_limit) { + if (extra_memory > allocator_bulk_deallocation_flush_threshold) { + block_allocator.FlushAll(extra_memory); + } + return {true, std::move(r)}; + } + + bool success = false; + while (!object_cache->IsEmpty()) { + const idx_t freed_mem = object_cache->EvictToReduceMemory(extra_memory); + // Break if all entries cannot be evicted. + if (freed_mem == 0) { + break; + } + + if (memory_usage.GetUsedMemory(MemoryUsageCaches::NO_FLUSH) <= memory_limit) { + success = true; + break; + } + } + if (!success) { + r.Resize(0); + } else if (extra_memory > allocator_bulk_deallocation_flush_threshold) { + block_allocator.FlushAll(extra_memory); + } + + return {success, std::move(r)}; +} + BufferPool::EvictionResult BufferPool::EvictBlocks(MemoryTag tag, idx_t extra_memory, idx_t memory_limit, unique_ptr *buffer) { for (auto &queue : queues) { auto block_result = EvictBlocksInternal(*queue, tag, extra_memory, memory_limit, buffer); - if (block_result.success || RefersToSameObject(*queue, *queues.back())) { - return block_result; // Return upon success or upon last queue + if (block_result.success) { + return block_result; } } - // This can never happen since we always return when i == 1. Exception to silence compiler warning - throw InternalException("Exited BufferPool::EvictBlocksInternal without obtaining BufferPool::EvictionResult"); + + // Evict object cache, which is usually used to cache metadata and configs, when flushing buffer blocks alone is not + // enough to limit overall memory consumption. + return EvictObjectCacheEntries(tag, extra_memory, memory_limit); } BufferPool::EvictionResult BufferPool::EvictBlocksInternal(EvictionQueue &queue, MemoryTag tag, idx_t extra_memory, diff --git a/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp b/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp index 783a98079..f9fbe209a 100644 --- a/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp +++ b/src/duckdb/src/storage/buffer/buffer_pool_reservation.cpp @@ -1,4 +1,5 @@ -#include "duckdb/storage/buffer/block_handle.hpp" +#include "duckdb/storage/buffer/buffer_pool_reservation.hpp" + #include "duckdb/storage/buffer/buffer_pool.hpp" namespace duckdb { diff --git a/src/duckdb/src/storage/caching_file_system.cpp b/src/duckdb/src/storage/caching_file_system.cpp index 1d979377e..2d7a0aa90 100644 --- a/src/duckdb/src/storage/caching_file_system.cpp +++ b/src/duckdb/src/storage/caching_file_system.cpp @@ -49,7 +49,7 @@ bool ShouldExpandToFillGap(const idx_t current_length, const idx_t added_length) } // namespace CachingFileSystem::CachingFileSystem(FileSystem &file_system_p, DatabaseInstance &db_p) - : file_system(file_system_p), external_file_cache(ExternalFileCache::Get(db_p)), db(db_p) { + : file_system(file_system_p), db(db_p), external_file_cache(ExternalFileCache::Get(db)) { } CachingFileSystem::~CachingFileSystem() { diff --git a/src/duckdb/src/storage/checkpoint/table_data_writer.cpp b/src/duckdb/src/storage/checkpoint/table_data_writer.cpp index b6b18ead7..a2299437e 100644 --- a/src/duckdb/src/storage/checkpoint/table_data_writer.cpp +++ b/src/duckdb/src/storage/checkpoint/table_data_writer.cpp @@ -78,7 +78,7 @@ void SingleFileTableDataWriter::FinalizeTable(const TableStatistics &global_stat RowGroupCollection &collection, Serializer &serializer) { MetaBlockPointer pointer; idx_t total_rows; - auto debug_verify_blocks = DBConfig::GetSetting(GetDatabase()); + auto debug_verify_blocks = Settings::Get(GetDatabase()); if (!existing_pointer.IsValid()) { // write the metadata // store the current position in the metadata writer diff --git a/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp b/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp index 48ffb70bc..6e7134ed6 100644 --- a/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp +++ b/src/duckdb/src/storage/checkpoint/write_overflow_strings_to_disk.cpp @@ -48,6 +48,18 @@ string UncompressedStringSegmentState::GetSegmentInfo() const { return "Overflow String Block Ids: " + result; } +void UncompressedStringSegmentState::InsertOverflowBlock(block_id_t block_id, reference block) { + auto write_lock = overflow_blocks_lock.GetExclusiveLock(); + overflow_blocks.insert(make_pair(block_id, block)); +} + +reference UncompressedStringSegmentState::FindOverflowBlock(block_id_t block_id) { + auto read_lock = overflow_blocks_lock.GetSharedLock(); + auto entry = overflow_blocks.find(block_id); + D_ASSERT(entry != overflow_blocks.end()); + return entry->second; +} + void WriteOverflowStringsToDisk::WriteString(UncompressedStringSegmentState &state, string_t string, block_id_t &result_block, int32_t &result_offset) { auto &block_manager = partial_block_manager.GetBlockManager(); diff --git a/src/duckdb/src/storage/checkpoint_manager.cpp b/src/duckdb/src/storage/checkpoint_manager.cpp index c1d7a721e..316c50cf9 100644 --- a/src/duckdb/src/storage/checkpoint_manager.cpp +++ b/src/duckdb/src/storage/checkpoint_manager.cpp @@ -9,13 +9,13 @@ #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp" #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp" #include "duckdb/catalog/duck_catalog.hpp" +#include "duckdb/common/enums/checkpoint_abort.hpp" #include "duckdb/common/serializer/binary_deserializer.hpp" #include "duckdb/common/serializer/binary_serializer.hpp" #include "duckdb/execution/index/art/art.hpp" #include "duckdb/execution/index/unbound_index.hpp" #include "duckdb/main/attached_database.hpp" #include "duckdb/main/client_context.hpp" -#include "duckdb/main/config.hpp" #include "duckdb/main/connection.hpp" #include "duckdb/transaction/duck_transaction_manager.hpp" #include "duckdb/parser/parsed_data/create_schema_info.hpp" @@ -158,7 +158,7 @@ void SingleFileCheckpointWriter::CreateCheckpoint() { ActiveCheckpointWrapper active_checkpoint(transaction_manager); auto has_wal = storage_manager.WALStartCheckpoint(meta_block, options); - auto checkpoint_sleep_ms = DBConfig::GetSetting(db.GetDatabase()); + auto checkpoint_sleep_ms = Settings::Get(db.GetDatabase()); if (checkpoint_sleep_ms > 0) { ThreadUtil::SleepMs(checkpoint_sleep_ms); } @@ -206,7 +206,7 @@ void SingleFileCheckpointWriter::CreateCheckpoint() { metadata_writer->Flush(); table_metadata_writer->Flush(); - auto debug_checkpoint_abort = DBConfig::GetSetting(db.GetDatabase()); + auto debug_checkpoint_abort = Settings::Get(db.GetDatabase()); if (debug_checkpoint_abort == CheckpointAbort::DEBUG_ABORT_BEFORE_HEADER) { throw FatalException("Checkpoint aborted before header write because of PRAGMA checkpoint_abort flag"); } @@ -218,7 +218,7 @@ void SingleFileCheckpointWriter::CreateCheckpoint() { header.vector_size = STANDARD_VECTOR_SIZE; block_manager.WriteHeader(context, header); - auto debug_verify_blocks = DBConfig::GetSetting(db.GetDatabase()); + auto debug_verify_blocks = Settings::Get(db.GetDatabase()); if (debug_verify_blocks) { // extend verify_block_usage_count auto metadata_info = storage_manager.GetMetadataInfo(); diff --git a/src/duckdb/src/storage/compression/bitpacking.cpp b/src/duckdb/src/storage/compression/bitpacking.cpp index a5f3ccc35..6c057f6dd 100644 --- a/src/duckdb/src/storage/compression/bitpacking.cpp +++ b/src/duckdb/src/storage/compression/bitpacking.cpp @@ -9,6 +9,7 @@ #include "duckdb/function/compression/compression.hpp" #include "duckdb/function/compression_function.hpp" #include "duckdb/main/config.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/storage/buffer_manager.hpp" #include "duckdb/storage/compression/bitpacking.hpp" #include "duckdb/storage/table/column_data_checkpointer.hpp" @@ -22,40 +23,6 @@ namespace duckdb { constexpr const idx_t BitpackingPrimitives::BITPACKING_ALGORITHM_GROUP_SIZE; static constexpr const idx_t BITPACKING_METADATA_GROUP_SIZE = STANDARD_VECTOR_SIZE > 512 ? STANDARD_VECTOR_SIZE : 2048; -BitpackingMode BitpackingModeFromString(const string &str) { - auto mode = StringUtil::Lower(str); - if (mode == "auto" || mode == "none") { - return BitpackingMode::AUTO; - } else if (mode == "constant") { - return BitpackingMode::CONSTANT; - } else if (mode == "constant_delta") { - return BitpackingMode::CONSTANT_DELTA; - } else if (mode == "delta_for") { - return BitpackingMode::DELTA_FOR; - } else if (mode == "for") { - return BitpackingMode::FOR; - } else { - return BitpackingMode::INVALID; - } -} - -string BitpackingModeToString(const BitpackingMode &mode) { - switch (mode) { - case BitpackingMode::AUTO: - return "auto"; - case BitpackingMode::CONSTANT: - return "constant"; - case BitpackingMode::CONSTANT_DELTA: - return "constant_delta"; - case BitpackingMode::DELTA_FOR: - return "delta_for"; - case BitpackingMode::FOR: - return "for"; - default: - throw NotImplementedException("Unknown bitpacking mode: " + to_string((uint8_t)mode) + "\n"); - } -} - typedef struct { BitpackingMode mode; uint32_t offset; @@ -338,11 +305,9 @@ struct BitpackingAnalyzeState : public AnalyzeState { template unique_ptr BitpackingInitAnalyze(ColumnData &col_data, PhysicalType type) { - auto &config = DBConfig::GetConfig(col_data.GetDatabase()); - CompressionInfo info(col_data.GetBlockManager()); auto state = make_uniq>(info); - state->state.mode = config.options.force_bitpacking_mode; + state->state.mode = Settings::Get(col_data.GetDatabase()); return std::move(state); } @@ -393,9 +358,7 @@ struct BitpackingCompressionState : public CompressionState { CreateEmptySegment(); state.data_ptr = reinterpret_cast(this); - - auto &config = DBConfig::GetConfig(checkpoint_data.GetDatabase()); - state.mode = config.options.force_bitpacking_mode; + state.mode = Settings::Get(checkpoint_data.GetDatabase()); } ColumnDataCheckpointData &checkpoint_data; @@ -679,7 +642,7 @@ struct BitpackingScanState : public SegmentScanState { //! depending on the bitpacking mode of that group. void LoadNextGroup() { D_ASSERT(bitpacking_metadata_ptr > handle.Ptr() && - (bitpacking_metadata_ptr < handle.Ptr() + current_segment.GetBlockManager().GetBlockSize())); + (bitpacking_metadata_ptr < handle.Ptr() + current_segment.GetBlockSize())); current_group_offset = 0; current_group = DecodeMeta(reinterpret_cast(bitpacking_metadata_ptr)); diff --git a/src/duckdb/src/storage/compression/dict_fsst/decompression.cpp b/src/duckdb/src/storage/compression/dict_fsst/decompression.cpp index f6befffe5..c27efd1e5 100644 --- a/src/duckdb/src/storage/compression/dict_fsst/decompression.cpp +++ b/src/duckdb/src/storage/compression/dict_fsst/decompression.cpp @@ -10,7 +10,7 @@ CompressedStringScanState::~CompressedStringScanState() { } string_t CompressedStringScanState::FetchStringFromDict(Vector &result, uint32_t dict_offset, idx_t dict_idx) { - D_ASSERT(dict_offset <= NumericCast(segment.GetBlockManager().GetBlockSize())); + D_ASSERT(dict_offset <= NumericCast(segment.GetBlockSize())); if (dict_idx == 0) { return string_t(nullptr, 0); @@ -69,7 +69,7 @@ void CompressedStringScanState::Initialize(bool initialize_dictionary) { auto dictionary_indices_dest = AlignValue(string_lengths_dest + string_lengths_space); const auto total_space = segment.GetBlockOffset() + dictionary_indices_dest + dictionary_indices_space; - if (total_space > segment.GetBlockManager().GetBlockSize()) { + if (total_space > segment.GetBlockSize()) { throw IOException( "Failed to scan dictionary string - index was out of range. Database file appears to be corrupted."); } diff --git a/src/duckdb/src/storage/compression/dictionary/decompression.cpp b/src/duckdb/src/storage/compression/dictionary/decompression.cpp index 6e389d026..cf631b6f9 100644 --- a/src/duckdb/src/storage/compression/dictionary/decompression.cpp +++ b/src/duckdb/src/storage/compression/dictionary/decompression.cpp @@ -33,14 +33,14 @@ void CompressedStringScanState::Initialize(ColumnSegment &segment, bool initiali index_buffer_count = Load(data_ptr_cast(&header_ptr->index_buffer_count)); current_width = (bitpacking_width_t)(Load(data_ptr_cast(&header_ptr->bitpacking_width))); if (segment.GetBlockOffset() + index_buffer_offset + sizeof(uint32_t) * index_buffer_count > - segment.GetBlockManager().GetBlockSize()) { + segment.GetBlockSize()) { throw IOException( "Failed to scan dictionary string - index was out of range. Database file appears to be corrupted."); } index_buffer_ptr = reinterpret_cast(baseptr + index_buffer_offset); base_data = data_ptr_cast(baseptr + DictionaryCompression::DICTIONARY_HEADER_SIZE); - block_size = segment.GetBlockManager().GetBlockSize(); + block_size = segment.GetBlockSize(); dict = DictionaryCompression::GetDictionary(segment, *handle); if (!initialize_dictionary) { diff --git a/src/duckdb/src/storage/compression/fsst.cpp b/src/duckdb/src/storage/compression/fsst.cpp index faf9c5f93..4bd713b2e 100644 --- a/src/duckdb/src/storage/compression/fsst.cpp +++ b/src/duckdb/src/storage/compression/fsst.cpp @@ -573,7 +573,7 @@ struct FSSTScanState : public StringScanState { }; unique_ptr FSSTStorage::StringInitScan(const QueryContext &context, ColumnSegment &segment) { - auto block_size = segment.GetBlockManager().GetBlockSize(); + auto block_size = segment.GetBlockSize(); auto string_block_limit = StringUncompressed::GetStringBlockLimit(block_size); auto state = make_uniq(string_block_limit); auto &buffer_manager = BufferManager::GetBufferManager(segment.db); @@ -649,7 +649,7 @@ void FSSTStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &sta bool enable_fsst_vectors; if (ALLOW_FSST_VECTORS) { - enable_fsst_vectors = DBConfig::GetSetting(segment.db); + enable_fsst_vectors = Settings::Get(segment.db); } else { enable_fsst_vectors = false; } @@ -668,7 +668,7 @@ void FSSTStorage::StringScanPartial(ColumnSegment &segment, ColumnScanState &sta if (scan_state.duckdb_fsst_decoder) { D_ASSERT(result_offset == 0 || result.GetVectorType() == VectorType::FSST_VECTOR); result.SetVectorType(VectorType::FSST_VECTOR); - auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockManager().GetBlockSize()); + auto string_block_limit = StringUncompressed::GetStringBlockLimit(segment.GetBlockSize()); FSSTVector::RegisterDecoder(result, scan_state.duckdb_fsst_decoder, string_block_limit); result_data = FSSTVector::GetCompressedData(result); } else { @@ -745,7 +745,7 @@ void FSSTStorage::StringFetchRow(ColumnSegment &segment, ColumnFetchState &state duckdb_fsst_decoder_t decoder; bitpacking_width_t width; - auto block_size = segment.GetBlockManager().GetBlockSize(); + auto block_size = segment.GetBlockSize(); auto have_symbol_table = ParseFSSTSegmentHeader(base_ptr, &decoder, &width, block_size); auto result_data = FlatVector::GetData(result); diff --git a/src/duckdb/src/storage/compression/rle.cpp b/src/duckdb/src/storage/compression/rle.cpp index 1b4699259..fd31d8f04 100644 --- a/src/duckdb/src/storage/compression/rle.cpp +++ b/src/duckdb/src/storage/compression/rle.cpp @@ -264,7 +264,7 @@ struct RLEScanState : public SegmentScanState { entry_pos = 0; position_in_entry = 0; rle_count_offset = UnsafeNumericCast(Load(handle.Ptr() + segment.GetBlockOffset())); - D_ASSERT(rle_count_offset <= segment.GetBlockManager().GetBlockSize()); + D_ASSERT(rle_count_offset <= segment.GetBlockSize()); } inline void SkipInternal(rle_count_t *index_pointer, idx_t skip_count) { diff --git a/src/duckdb/src/storage/compression/string_uncompressed.cpp b/src/duckdb/src/storage/compression/string_uncompressed.cpp index f2c246cce..c5d4f78de 100644 --- a/src/duckdb/src/storage/compression/string_uncompressed.cpp +++ b/src/duckdb/src/storage/compression/string_uncompressed.cpp @@ -68,7 +68,7 @@ void UncompressedStringInitPrefetch(ColumnSegment &segment, PrefetchState &prefe auto segment_state = segment.GetSegmentState(); if (segment_state) { auto &state = segment_state->Cast(); - auto &block_manager = segment.GetBlockManager(); + auto &block_manager = segment.block->GetBlockManager(); for (auto &block_id : state.on_disk_blocks) { auto block_handle = state.GetHandle(block_manager, block_id); prefetch_state.AddBlock(block_handle); @@ -221,7 +221,7 @@ idx_t UncompressedStringStorage::FinalizeAppend(ColumnSegment &segment, SegmentS auto offset_size = DICTIONARY_HEADER_SIZE + segment.count * sizeof(int32_t); auto total_size = offset_size + dict.size; - CompressionInfo info(segment.GetBlockManager()); + CompressionInfo info(segment.block->GetBlockManager()); if (total_size >= info.GetCompactionFlushLimit()) { // the block is full enough, don't bother moving around the dictionary return segment.SegmentSize(); @@ -337,14 +337,14 @@ void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string if (!state.head || state.head->offset + total_length >= state.head->size) { // string does not fit, allocate space for it // create a new string block - auto alloc_size = MaxValue(total_length, segment.GetBlockManager().GetBlockSize()); + auto alloc_size = MaxValue(total_length, segment.GetBlockSize()); auto new_block = make_uniq(); new_block->offset = 0; new_block->size = alloc_size; // allocate an in-memory buffer for it handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, alloc_size, false); block = handle.GetBlockHandle(); - state.overflow_blocks.insert(make_pair(block->BlockId(), reference(*new_block))); + state.InsertOverflowBlock(block->BlockId(), reference(*new_block)); new_block->block = std::move(block); new_block->next = std::move(state.head); state.head = std::move(new_block); @@ -366,17 +366,16 @@ void UncompressedStringStorage::WriteStringMemory(ColumnSegment &segment, string string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, Vector &result, block_id_t block, int32_t offset) { - auto &block_manager = segment.GetBlockManager(); - auto &buffer_manager = block_manager.buffer_manager; + auto &buffer_manager = segment.block->GetBufferManager(); auto &state = segment.GetSegmentState()->Cast(); D_ASSERT(block != INVALID_BLOCK); - D_ASSERT(offset < NumericCast(block_manager.GetBlockSize())); + D_ASSERT(offset < NumericCast(segment.GetBlockSize())); if (block < MAXIMUM_BLOCK) { // read the overflow string from disk // pin the initial handle and read the length - auto block_handle = state.GetHandle(block_manager, block); + auto block_handle = state.GetHandle(segment.block->GetBlockManager(), block); auto handle = buffer_manager.Pin(block_handle); // read header @@ -387,7 +386,7 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V BufferHandle target_handle; string_t overflow_string; data_ptr_t target_ptr; - bool allocate_block = length >= block_manager.GetBlockSize(); + bool allocate_block = length >= segment.GetBlockSize(); if (allocate_block) { // overflow string is bigger than a block - allocate a temporary buffer for it target_handle = buffer_manager.Allocate(MemoryTag::OVERFLOW_STRINGS, length); @@ -400,7 +399,7 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V // now append the string to the single buffer while (remaining > 0) { - idx_t to_write = MinValue(remaining, block_manager.GetBlockSize() - sizeof(block_id_t) - + idx_t to_write = MinValue(remaining, segment.GetBlockSize() - sizeof(block_id_t) - UnsafeNumericCast(offset)); memcpy(target_ptr, handle.Ptr() + offset, to_write); remaining -= to_write; @@ -409,7 +408,7 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V if (remaining > 0) { // read the next block block_id_t next_block = Load(handle.Ptr() + offset); - block_handle = state.GetHandle(block_manager, next_block); + block_handle = state.GetHandle(segment.block->GetBlockManager(), next_block); handle = buffer_manager.Pin(block_handle); offset = 0; } @@ -426,9 +425,8 @@ string_t UncompressedStringStorage::ReadOverflowString(ColumnSegment &segment, V // read the overflow string from memory // first pin the handle, if it is not pinned yet - auto entry = state.overflow_blocks.find(block); - D_ASSERT(entry != state.overflow_blocks.end()); - auto handle = buffer_manager.Pin(entry->second.get().block); + auto string_block = state.FindOverflowBlock(block); + auto handle = buffer_manager.Pin(string_block.get().block); auto final_buffer = handle.Ptr(); StringVector::AddHandle(result, std::move(handle)); return ReadStringWithLength(final_buffer, offset); diff --git a/src/duckdb/src/storage/compression/validity_uncompressed.cpp b/src/duckdb/src/storage/compression/validity_uncompressed.cpp index 49e3c2dc8..acb477a42 100644 --- a/src/duckdb/src/storage/compression/validity_uncompressed.cpp +++ b/src/duckdb/src/storage/compression/validity_uncompressed.cpp @@ -223,6 +223,17 @@ void ValidityUncompressed::UnalignedScan(data_ptr_t input, idx_t input_size, idx auto &result_mask = FlatVector::Validity(result); auto input_data = reinterpret_cast(input); +#ifdef DEBUG + // save boundary entries to verify we don't corrupt surrounding bits later. + idx_t debug_first_entry = result_offset / ValidityMask::BITS_PER_VALUE; + idx_t debug_last_entry = (result_offset + scan_count - 1) / ValidityMask::BITS_PER_VALUE; + auto debug_result_data = (validity_t *)result_mask.GetData(); + validity_t debug_original_first_entry = + debug_result_data ? debug_result_data[debug_first_entry] : ValidityMask::ValidityBuffer::MAX_ENTRY; + validity_t debug_original_last_entry = + debug_result_data ? debug_result_data[debug_last_entry] : ValidityMask::ValidityBuffer::MAX_ENTRY; +#endif + #if STANDARD_VECTOR_SIZE < 128 // fallback for tiny vector sizes // the bitwise ops we use below don't work if the vector size is too small @@ -248,118 +259,163 @@ void ValidityUncompressed::UnalignedScan(data_ptr_t input, idx_t input_size, idx idx_t input_entry = input_start / ValidityMask::BITS_PER_VALUE; idx_t input_idx = input_start - input_entry * ValidityMask::BITS_PER_VALUE; + // Window scanning algorithm -- the goal is to copy a contiguous sequence of bits from input into result, + // and to do this using bit operations on 64 bit fields. + // + // On each loop iteration, we are inspecting a 64 bit field in both the input and result, starting at a certain + // index (in the code, these are denoted by input(result)_entry and input(result)_index, respectively. + // + // For example, on the first loop iteration for the diagram, both entries are entry 0, and the starting indexes are + // the index of window 1 in each entry. + // + // input(result)_window is the window from input(result)_index to the end of either the current bit field, or + // the end of the range of bits we are trying to copy if that is contained within the current entry. + // + // window is minimum(input_window, result_window), which is window 1 on the first iteration, window 2 on the + // second iteration, etc. These are what are shown in the diagram below. + // + // INPUT: + // 0 63| 127| 191 + // +-------------------------------+--------------------------------+--------------------------------+ + // | [ 1 ]|[ 2 ][ 3 ]|[ 4 ][ 5 ]| + // +-------------------------------+--------------------------------+--------------------------------+ + // + // RESULT: + // 0 63| 127| 191 + // +-------------------------------+--------------------------------+--------------------------------+ + // [ 1 ][ 2 ]|[ 3 ][ 4 ]|[ 5 ] | + // +-------------------------------+--------------------------------+--------------------------------+ + // + // Note: in case this ever becomes a bottleneck, it should be possible to make each loop iteration branchless. + // The idea would be to do an odd iteration before the loop, then have two loops depending on the layout of the + // windows that will either shift left then right on each iteration, or the other loop will always shift right + // then left. For example, in the diagram above, we would first apply the first window outside of the loop + // beforehand, then we can see that each loop iteration requires us to shift right, fetch a new result entry, + // shift left, fetch a new input entry. This would have to be generalized to two possible branchless loops, + // depending on the input. + // now start the bit games idx_t pos = 0; while (pos < scan_count) { - // these are the current validity entries we are dealing with - idx_t current_result_idx = result_entry; - idx_t offset; validity_t input_mask = input_data[input_entry]; + idx_t bits_left = scan_count - pos; - // construct the mask to AND together with the result - if (result_idx < input_idx) { - // +======================================+ - // input: |xxxxxxxxx| | - // +======================================+ - // - // +======================================+ - // result: | xxxxxxxxx| | - // +======================================+ - // 1. We shift (>>) 'input' to line up with 'result' - // 2. We set the bits we shifted to 1 + // these are bits left within the current entries (possibly extra than what we need). + idx_t input_bits_left = ValidityMask::BITS_PER_VALUE - input_idx; + idx_t result_bits_left = ValidityMask::BITS_PER_VALUE - result_idx; - // we have to shift the input RIGHT if the result_idx is smaller than the input_idx - auto shift_amount = input_idx - result_idx; - D_ASSERT(shift_amount > 0 && shift_amount <= ValidityMask::BITS_PER_VALUE); + // these are the bits left within the current entries that need to be processed. + idx_t input_window_size = MinValue(bits_left, input_bits_left); + idx_t result_window_size = MinValue(bits_left, result_bits_left); - input_mask = input_mask >> shift_amount; + // the smaller of the two is our next window to copy from input to result. + idx_t window_size = MinValue(input_window_size, result_window_size); - // now the upper "shift_amount" bits are set to 0 - // we need them to be set to 1 - // otherwise the subsequent bitwise & will modify values outside of the range of values we want to alter - input_mask |= ValidityUncompressed::UPPER_MASKS[shift_amount]; + // Now within each loop iteration, we can think of the general case that handles all scenarios as just + // copying the window from the starting index in input to the window in the starting index of result. - if (pos == 0) { - // We also need to set the lower bits, which are to the left of the relevant bits (x), to 1 - // These are the bits that are "behind" this scan window, and should not affect this scan - auto non_relevant_mask = ValidityUncompressed::LOWER_MASKS[result_idx]; - input_mask |= non_relevant_mask; - } - - // after this, we move to the next input_entry - offset = ValidityMask::BITS_PER_VALUE - input_idx; - input_entry++; - input_idx = 0; - result_idx += offset; - } else if (result_idx > input_idx) { - // +======================================+ - // input: | xxxxxxxxx| | - // +======================================+ + // First, line up the windows: + if (result_idx < input_idx) { + // X is arbitrary bits, P is arbitrary protected bits. + // INPUT ENTRY: + // 63 0 + // +--------------------------------------------------------------------------------------------------+ + // |XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX[=============WINDOW=============]XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| + // +--------------------------------------------------------------------------------------------------+ + // ^ + // input_idx // - // +======================================+ - // result: |xxxxxxxxx| | - // +======================================+ - // 1. We set the bits to the left of the relevant bits (x) to 0 - // 1. We shift (<<) 'input' to line up with 'result' - // 2. We set the bits that we zeroed to the right of the relevant bits (x) to 1 - - // we have to shift the input LEFT if the result_idx is bigger than the input_idx - auto shift_amount = result_idx - input_idx; - D_ASSERT(shift_amount > 0 && shift_amount <= ValidityMask::BITS_PER_VALUE); - - // to avoid overflows, we set the upper "shift_amount" values to 0 first - input_mask = (input_mask & ~ValidityUncompressed::UPPER_MASKS[shift_amount]) << shift_amount; - - // now the lower "shift_amount" bits are set to 0 - // we need them to be set to 1 - // otherwise the subsequent bitwise & will modify values outside of the range of values we want to alter - input_mask |= ValidityUncompressed::LOWER_MASKS[shift_amount]; - - // after this, we move to the next result_entry - offset = ValidityMask::BITS_PER_VALUE - result_idx; - result_entry++; - result_idx = 0; - input_idx += offset; - } else { - // if the input_idx is equal to result_idx they are already aligned - // we just move to the next entry for both after this - offset = ValidityMask::BITS_PER_VALUE - result_idx; - input_entry++; - result_entry++; - result_idx = input_idx = 0; - } - // now we need to check if we should include the ENTIRE mask - // OR if we need to mask from the right side - pos += offset; - if (pos > scan_count) { - // +======================================+ - // mask: | |xxxxxxxxxxxxxxxxxxxxxxxxx| - // +======================================+ + // RESULT ENTRY: + // 63 0 + // +--------------------------------------------------------------------------------------------------+ + // |PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP[=============WINDOW=============]PPPPPPPPPPPPPPPPPPPPPP| + // +--------------------------------------------------------------------------------------------------+ + // ^ + // result_idx // - // The bits on the right side of the relevant bits (x) need to stay 1, to be adjusted by later scans - // so we adjust the mask to clear out any 0s that might be present on the right side. + idx_t shift_amount = input_idx - result_idx; + input_mask = input_mask >> shift_amount; + } else { + // current_result_idx >= current_input_idx + idx_t shift_amount = result_idx - input_idx; + input_mask = (input_mask & ~UPPER_MASKS[shift_amount]); - // we need to set any bits that are past the scan_count on the right-side to 1 - // this is required so we don't influence any bits that are not part of the scan - input_mask |= ValidityUncompressed::UPPER_MASKS[pos - scan_count]; + // X is arbitrary bits, P is arbitrary protected bits. + // Note the zeroed out bits in INPUT_ENTRY - these have to be zeroed before shifting left to align with + // result window, to prevent overflow. + // + // INPUT ENTRY: + // 63 0 + // +--------------------------------------------------------------------------------------------------+ + // |000000000000XXXXXXXXXXXXXXXXXXXX[=============WINDOW=============]XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX| + // +--------------------------------------------------------------------------------------------------+ + // ^ + // input_idx + // + // RESULT ENTRY: + // 63 0 + // +--------------------------------------------------------------------------------------------------+ + // |PPPPPPPPPPPPPPPPPPPP[=============WINDOW=============]PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP| + // +--------------------------------------------------------------------------------------------------+ + // ^ + // result_idx + input_mask = input_mask << shift_amount; } - // now finally we can merge the input mask with the result mask + + // Once the windows are aligned, mask the input to prevent overwriting protected bits in the result_mask. + auto protected_upper_bits = UPPER_MASKS[ValidityMask::BITS_PER_VALUE - result_idx - window_size]; + auto protected_lower_bits = LOWER_MASKS[result_idx]; + input_mask |= protected_upper_bits; + input_mask |= protected_lower_bits; + if (input_mask != ValidityMask::ValidityBuffer::MAX_ENTRY) { if (!result_data) { result_mask.Initialize(); result_data = (validity_t *)result_mask.GetData(); } - result_data[current_result_idx] &= input_mask; + result_data[result_entry] &= input_mask; + } + // Now update pos, entries, and indexes for the next iteration. + pos += window_size; + + // Windows can only go until the end of the current entry, so the mod can only wrap to 0 here. + input_idx = (input_idx + window_size) % ValidityMask::BITS_PER_VALUE; + result_idx = (result_idx + window_size) % ValidityMask::BITS_PER_VALUE; + + // Advance entries if the mod was 0. + if (input_idx == 0) { + input_entry++; + } + if (result_idx == 0) { + result_entry++; } } #endif #ifdef DEBUG - // verify that we actually accomplished the bitwise ops equivalent that we wanted to do - ValidityMask input_mask(input_data, input_size); - for (idx_t i = 0; i < scan_count; i++) { - D_ASSERT(result_mask.RowIsValid(result_offset + i) == input_mask.RowIsValid(input_start + i)); - } + // FIXME: Previously, this function had an assumption that all the bits in the result range we are copying + // to were all set to valid. with dict_fsst compression, this is no longer the case, so if we want to have + // a debug verification of the result here, we need to check that all the bits that were initially valid + // in the result range have the same value as the corresponding bit in the input, and if they are invalid + // they remain invalid. + + // verify surrounding bits weren't modified + auto debug_final_result_data = (validity_t *)result_mask.GetData(); + validity_t debug_final_first_entry = + debug_final_result_data ? debug_final_result_data[debug_first_entry] : ValidityMask::ValidityBuffer::MAX_ENTRY; + validity_t debug_final_last_entry = + debug_final_result_data ? debug_final_result_data[debug_last_entry] : ValidityMask::ValidityBuffer::MAX_ENTRY; + + idx_t first_bit_in_first_entry = result_offset % ValidityMask::BITS_PER_VALUE; + idx_t last_bit_in_last_entry = (result_offset + scan_count - 1) % ValidityMask::BITS_PER_VALUE; + + // lower bits of first entry should be unchanged + validity_t lower_mask = LOWER_MASKS[first_bit_in_first_entry]; + D_ASSERT((debug_original_first_entry & lower_mask) == (debug_final_first_entry & lower_mask)); + + // upper bits of last entry should be unchanged + validity_t upper_mask = UPPER_MASKS[ValidityMask::BITS_PER_VALUE - last_bit_in_last_entry - 1]; + D_ASSERT((debug_original_last_entry & upper_mask) == (debug_final_last_entry & upper_mask)); #endif } diff --git a/src/duckdb/src/storage/compression/zstd.cpp b/src/duckdb/src/storage/compression/zstd.cpp index d727cf1ea..5598f7135 100644 --- a/src/duckdb/src/storage/compression/zstd.cpp +++ b/src/duckdb/src/storage/compression/zstd.cpp @@ -3,6 +3,7 @@ #include "duckdb/storage/table/column_data_checkpointer.hpp" #include "duckdb/storage/block_manager.hpp" #include "duckdb/main/config.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/common/constants.hpp" #include "duckdb/common/allocator.hpp" #include "duckdb/common/serializer/deserializer.hpp" @@ -203,7 +204,7 @@ idx_t ZSTDStorage::StringFinalAnalyze(AnalyzeState &state_p) { double penalty; idx_t average_length = state.total_size / state.count; - auto threshold = state.config.options.zstd_min_string_length; + auto threshold = Settings::Get(state.config); if (average_length >= threshold) { penalty = 1.0; } else { @@ -694,7 +695,7 @@ struct ZSTDScanState : public SegmentScanState { public: explicit ZSTDScanState(ColumnSegment &segment) : state(segment.GetSegmentState()->Cast()), - block_manager(segment.GetBlockManager()), buffer_manager(BufferManager::GetBufferManager(segment.db)), + block_manager(segment.block->GetBlockManager()), buffer_manager(BufferManager::GetBufferManager(segment.db)), segment_block_offset(segment.GetBlockOffset()), segment(segment) { decompression_context = duckdb_zstd::ZSTD_createDCtx(); segment_handle = buffer_manager.Pin(segment.block); diff --git a/src/duckdb/src/storage/external_file_cache.cpp b/src/duckdb/src/storage/external_file_cache.cpp index 304116c7f..14a4f12a6 100644 --- a/src/duckdb/src/storage/external_file_cache.cpp +++ b/src/duckdb/src/storage/external_file_cache.cpp @@ -39,7 +39,7 @@ ExternalFileCache::CachedFileRange::GetOverlap(const CachedFileRange &other) con void ExternalFileCache::CachedFileRange::AddCheckSum() { #ifdef DEBUG D_ASSERT(checksum == 0); - auto buffer_handle = block_handle->block_manager.buffer_manager.Pin(block_handle); + auto buffer_handle = block_handle->GetBufferManager().Pin(block_handle); checksum = Checksum(buffer_handle.Ptr(), nr_bytes); #endif } @@ -49,7 +49,7 @@ void ExternalFileCache::CachedFileRange::VerifyCheckSum() { if (checksum == 0) { return; } - auto buffer_handle = block_handle->block_manager.buffer_manager.Pin(block_handle); + auto buffer_handle = block_handle->GetBufferManager().Pin(block_handle); if (!buffer_handle.IsValid()) { return; } diff --git a/src/duckdb/src/storage/external_file_cache_util.cpp b/src/duckdb/src/storage/external_file_cache_util.cpp index 08da502f9..deae15af2 100644 --- a/src/duckdb/src/storage/external_file_cache_util.cpp +++ b/src/duckdb/src/storage/external_file_cache_util.cpp @@ -34,12 +34,11 @@ CacheValidationMode ExternalFileCacheUtil::GetCacheValidationMode(const OpenFile // If client context is available, check client-local settings first, then fall back to database config. if (client_context) { - return DBConfig::GetSetting(*client_context); + return Settings::Get(*client_context); } // No client context, fall back to database config. - auto &config = DBConfig::GetConfig(db); - return config.options.validate_external_file_cache; + return Settings::Get(db); } } // namespace duckdb diff --git a/src/duckdb/src/storage/open_file_storage_extension.cpp b/src/duckdb/src/storage/open_file_storage_extension.cpp index 1daf5b5e6..25dbacbe9 100644 --- a/src/duckdb/src/storage/open_file_storage_extension.cpp +++ b/src/duckdb/src/storage/open_file_storage_extension.cpp @@ -71,8 +71,8 @@ unique_ptr OpenFileStorageTransactionManager(optional_ptr(db); } -unique_ptr OpenFileStorageExtension::Create() { - auto result = make_uniq(); +shared_ptr OpenFileStorageExtension::Create() { + auto result = make_shared_ptr(); result->attach = OpenFileStorageAttach; result->create_transaction_manager = OpenFileStorageTransactionManager; return result; diff --git a/src/duckdb/src/storage/optimistic_data_writer.cpp b/src/duckdb/src/storage/optimistic_data_writer.cpp index 78976ac1c..186c6013d 100644 --- a/src/duckdb/src/storage/optimistic_data_writer.cpp +++ b/src/duckdb/src/storage/optimistic_data_writer.cpp @@ -65,7 +65,7 @@ void OptimisticDataWriter::WriteNewRowGroup(OptimisticWriteCollection &row_group row_groups.complete_row_groups++; auto unflushed_row_groups = row_groups.complete_row_groups - row_groups.last_flushed; - if (unflushed_row_groups >= DBConfig::GetSetting(context)) { + if (unflushed_row_groups >= Settings::Get(context)) { // we have crossed our flush threshold - flush any unwritten row groups to disk vector> to_flush; vector segment_indexes; diff --git a/src/duckdb/src/storage/serialization/serialize_create_info.cpp b/src/duckdb/src/storage/serialization/serialize_create_info.cpp index 4e0d48806..8469f606c 100644 --- a/src/duckdb/src/storage/serialization/serialize_create_info.cpp +++ b/src/duckdb/src/storage/serialization/serialize_create_info.cpp @@ -168,6 +168,9 @@ void CreateTableInfo::Serialize(Serializer &serializer) const { serializer.WriteProperty(201, "columns", columns); serializer.WritePropertyWithDefault>>(202, "constraints", constraints); serializer.WritePropertyWithDefault>(203, "query", query); + serializer.WritePropertyWithDefault>>(204, "partition_keys", partition_keys); + serializer.WritePropertyWithDefault>>(205, "sort_keys", sort_keys); + serializer.WritePropertyWithDefault>>(206, "options", options); } unique_ptr CreateTableInfo::Deserialize(Deserializer &deserializer) { @@ -176,6 +179,9 @@ unique_ptr CreateTableInfo::Deserialize(Deserializer &deserializer) deserializer.ReadProperty(201, "columns", result->columns); deserializer.ReadPropertyWithDefault>>(202, "constraints", result->constraints); deserializer.ReadPropertyWithDefault>(203, "query", result->query); + deserializer.ReadPropertyWithDefault>>(204, "partition_keys", result->partition_keys); + deserializer.ReadPropertyWithDefault>>(205, "sort_keys", result->sort_keys); + deserializer.ReadPropertyWithDefault>>(206, "options", result->options); return std::move(result); } diff --git a/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp b/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp index 4c70c25c1..5e5dfcf0e 100644 --- a/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp +++ b/src/duckdb/src/storage/serialization/serialize_logical_operator.cpp @@ -290,6 +290,7 @@ void LogicalCTERef::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault(201, "cte_index", cte_index); serializer.WritePropertyWithDefault>(202, "chunk_types", chunk_types); serializer.WritePropertyWithDefault>(203, "bound_columns", bound_columns); + /* [Deleted] (CTEMaterialize) "materialized_cte" */ serializer.WritePropertyWithDefault(205, "is_recurring", is_recurring); } @@ -299,6 +300,7 @@ unique_ptr LogicalCTERef::Deserialize(Deserializer &deserialize auto chunk_types = deserializer.ReadPropertyWithDefault>(202, "chunk_types"); auto bound_columns = deserializer.ReadPropertyWithDefault>(203, "bound_columns"); auto result = duckdb::unique_ptr(new LogicalCTERef(table_index, cte_index, std::move(chunk_types), std::move(bound_columns))); + deserializer.ReadDeletedProperty(204, "materialized_cte"); deserializer.ReadPropertyWithDefault(205, "is_recurring", result->is_recurring); return std::move(result); } diff --git a/src/duckdb/src/storage/serialization/serialize_nodes.cpp b/src/duckdb/src/storage/serialization/serialize_nodes.cpp index 55a64a14f..2bb99fa59 100644 --- a/src/duckdb/src/storage/serialization/serialize_nodes.cpp +++ b/src/duckdb/src/storage/serialization/serialize_nodes.cpp @@ -5,8 +5,6 @@ #include "duckdb/common/serializer/serializer.hpp" #include "duckdb/common/serializer/deserializer.hpp" -#include "duckdb/common/types.hpp" -#include "duckdb/common/extra_type_info.hpp" #include "duckdb/parser/common_table_expression_info.hpp" #include "duckdb/parser/query_node.hpp" #include "duckdb/parser/result_modifier.hpp" @@ -220,6 +218,8 @@ void ColumnIndex::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault>(2, "child_indexes", child_indexes); serializer.WritePropertyWithDefault(3, "index_type", index_type, ColumnIndexType::FULL_READ); serializer.WritePropertyWithDefault(4, "type", type, LogicalType::INVALID); + serializer.WritePropertyWithDefault(5, "field", field, ""); + serializer.WritePropertyWithDefault(6, "has_index", has_index, true); } ColumnIndex ColumnIndex::Deserialize(Deserializer &deserializer) { @@ -228,6 +228,8 @@ ColumnIndex ColumnIndex::Deserialize(Deserializer &deserializer) { deserializer.ReadPropertyWithDefault>(2, "child_indexes", result.child_indexes); deserializer.ReadPropertyWithExplicitDefault(3, "index_type", result.index_type, ColumnIndexType::FULL_READ); deserializer.ReadPropertyWithExplicitDefault(4, "type", result.type, LogicalType::INVALID); + deserializer.ReadPropertyWithExplicitDefault(5, "field", result.field, ""); + deserializer.ReadPropertyWithExplicitDefault(6, "has_index", result.has_index, true); return result; } @@ -349,18 +351,6 @@ JoinCondition JoinCondition::Deserialize(Deserializer &deserializer) { return result; } -void LogicalType::Serialize(Serializer &serializer) const { - serializer.WriteProperty(100, "id", id_); - serializer.WritePropertyWithDefault>(101, "type_info", type_info_); -} - -LogicalType LogicalType::Deserialize(Deserializer &deserializer) { - auto id = deserializer.ReadProperty(100, "id"); - auto type_info = deserializer.ReadPropertyWithDefault>(101, "type_info"); - LogicalType result(id, std::move(type_info)); - return result; -} - void MultiFileOptions::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault(100, "filename", filename); serializer.WritePropertyWithDefault(101, "hive_partitioning", hive_partitioning); @@ -425,20 +415,6 @@ PivotColumn PivotColumn::Deserialize(Deserializer &deserializer) { return result; } -void PivotColumnEntry::Serialize(Serializer &serializer) const { - serializer.WritePropertyWithDefault>(100, "values", values); - serializer.WritePropertyWithDefault>(101, "star_expr", expr); - serializer.WritePropertyWithDefault(102, "alias", alias); -} - -PivotColumnEntry PivotColumnEntry::Deserialize(Deserializer &deserializer) { - PivotColumnEntry result; - deserializer.ReadPropertyWithDefault>(100, "values", result.values); - deserializer.ReadPropertyWithDefault>(101, "star_expr", result.expr); - deserializer.ReadPropertyWithDefault(102, "alias", result.alias); - return result; -} - void QualifiedColumnName::Serialize(Serializer &serializer) const { serializer.WritePropertyWithDefault(100, "catalog", catalog); serializer.WritePropertyWithDefault(101, "schema", schema); diff --git a/src/duckdb/src/storage/serialization/serialize_parse_info.cpp b/src/duckdb/src/storage/serialization/serialize_parse_info.cpp index a5616e0e6..e5ffc2c45 100644 --- a/src/duckdb/src/storage/serialization/serialize_parse_info.cpp +++ b/src/duckdb/src/storage/serialization/serialize_parse_info.cpp @@ -164,6 +164,9 @@ unique_ptr AlterTableInfo::Deserialize(Deserializer &deserializer) { case AlterTableType::RENAME_TABLE: result = RenameTableInfo::Deserialize(deserializer); break; + case AlterTableType::RESET_TABLE_OPTIONS: + result = ResetTableOptionsInfo::Deserialize(deserializer); + break; case AlterTableType::SET_DEFAULT: result = SetDefaultInfo::Deserialize(deserializer); break; @@ -176,6 +179,9 @@ unique_ptr AlterTableInfo::Deserialize(Deserializer &deserializer) { case AlterTableType::SET_SORTED_BY: result = SetSortedByInfo::Deserialize(deserializer); break; + case AlterTableType::SET_TABLE_OPTIONS: + result = SetTableOptionsInfo::Deserialize(deserializer); + break; default: throw SerializationException("Unsupported type for deserialization of AlterTableInfo!"); } @@ -550,6 +556,17 @@ unique_ptr RenameViewInfo::Deserialize(Deserializer &deserializer return std::move(result); } +void ResetTableOptionsInfo::Serialize(Serializer &serializer) const { + AlterTableInfo::Serialize(serializer); + serializer.WriteProperty(400, "table_options", table_options); +} + +unique_ptr ResetTableOptionsInfo::Deserialize(Deserializer &deserializer) { + auto result = duckdb::unique_ptr(new ResetTableOptionsInfo()); + deserializer.ReadProperty(400, "table_options", result->table_options); + return std::move(result); +} + void SetColumnCommentInfo::Serialize(Serializer &serializer) const { AlterInfo::Serialize(serializer); serializer.WriteProperty(300, "catalog_entry_type", catalog_entry_type); @@ -624,6 +641,17 @@ unique_ptr SetSortedByInfo::Deserialize(Deserializer &deserializ return std::move(result); } +void SetTableOptionsInfo::Serialize(Serializer &serializer) const { + AlterTableInfo::Serialize(serializer); + serializer.WritePropertyWithDefault>>(400, "table_options", table_options); +} + +unique_ptr SetTableOptionsInfo::Deserialize(Deserializer &deserializer) { + auto result = duckdb::unique_ptr(new SetTableOptionsInfo()); + deserializer.ReadPropertyWithDefault>>(400, "table_options", result->table_options); + return std::move(result); +} + void TransactionInfo::Serialize(Serializer &serializer) const { ParseInfo::Serialize(serializer); serializer.WriteProperty(200, "type", type); diff --git a/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp b/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp index 54dfd646e..dc54bc327 100644 --- a/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp +++ b/src/duckdb/src/storage/serialization/serialize_parsed_expression.cpp @@ -75,6 +75,9 @@ unique_ptr ParsedExpression::Deserialize(Deserializer &deseria case ExpressionClass::SUBQUERY: result = SubqueryExpression::Deserialize(deserializer); break; + case ExpressionClass::TYPE: + result = TypeExpression::Deserialize(deserializer); + break; case ExpressionClass::WINDOW: result = WindowExpression::Deserialize(deserializer); break; @@ -331,6 +334,23 @@ unique_ptr SubqueryExpression::Deserialize(Deserializer &deser return std::move(result); } +void TypeExpression::Serialize(Serializer &serializer) const { + ParsedExpression::Serialize(serializer); + serializer.WritePropertyWithDefault(200, "catalog", catalog); + serializer.WritePropertyWithDefault(201, "schema", schema); + serializer.WritePropertyWithDefault(202, "type_name", type_name); + serializer.WritePropertyWithDefault>>(203, "children", children); +} + +unique_ptr TypeExpression::Deserialize(Deserializer &deserializer) { + auto result = duckdb::unique_ptr(new TypeExpression()); + deserializer.ReadPropertyWithDefault(200, "catalog", result->catalog); + deserializer.ReadPropertyWithDefault(201, "schema", result->schema); + deserializer.ReadPropertyWithDefault(202, "type_name", result->type_name); + deserializer.ReadPropertyWithDefault>>(203, "children", result->children); + return std::move(result); +} + void WindowExpression::Serialize(Serializer &serializer) const { ParsedExpression::Serialize(serializer); serializer.WritePropertyWithDefault(200, "function_name", function_name); diff --git a/src/duckdb/src/storage/serialization/serialize_types.cpp b/src/duckdb/src/storage/serialization/serialize_types.cpp index 8e77ef866..b7dec4ab3 100644 --- a/src/duckdb/src/storage/serialization/serialize_types.cpp +++ b/src/duckdb/src/storage/serialization/serialize_types.cpp @@ -62,8 +62,8 @@ shared_ptr ExtraTypeInfo::Deserialize(Deserializer &deserializer) case ExtraTypeInfoType::TEMPLATE_TYPE_INFO: result = TemplateTypeInfo::Deserialize(deserializer); break; - case ExtraTypeInfoType::USER_TYPE_INFO: - result = UserTypeInfo::Deserialize(deserializer); + case ExtraTypeInfoType::UNBOUND_TYPE_INFO: + result = UnboundTypeInfo::Deserialize(deserializer); break; default: throw SerializationException("Unsupported type for deserialization of ExtraTypeInfo!"); @@ -217,21 +217,4 @@ shared_ptr TemplateTypeInfo::Deserialize(Deserializer &deserializ return std::move(result); } -void UserTypeInfo::Serialize(Serializer &serializer) const { - ExtraTypeInfo::Serialize(serializer); - serializer.WritePropertyWithDefault(200, "user_type_name", user_type_name); - serializer.WritePropertyWithDefault(201, "catalog", catalog, string()); - serializer.WritePropertyWithDefault(202, "schema", schema, string()); - serializer.WritePropertyWithDefault>(203, "user_type_modifiers", user_type_modifiers); -} - -shared_ptr UserTypeInfo::Deserialize(Deserializer &deserializer) { - auto result = duckdb::shared_ptr(new UserTypeInfo()); - deserializer.ReadPropertyWithDefault(200, "user_type_name", result->user_type_name); - deserializer.ReadPropertyWithExplicitDefault(201, "catalog", result->catalog, string()); - deserializer.ReadPropertyWithExplicitDefault(202, "schema", result->schema, string()); - deserializer.ReadPropertyWithDefault>(203, "user_type_modifiers", result->user_type_modifiers); - return std::move(result); -} - } // namespace duckdb diff --git a/src/duckdb/src/storage/single_file_block_manager.cpp b/src/duckdb/src/storage/single_file_block_manager.cpp index aeba13f51..0244c7d22 100644 --- a/src/duckdb/src/storage/single_file_block_manager.cpp +++ b/src/duckdb/src/storage/single_file_block_manager.cpp @@ -8,6 +8,8 @@ #include "duckdb/common/encryption_state.hpp" #include "duckdb/common/exception.hpp" #include "duckdb/common/serializer/memory_stream.hpp" +#include "duckdb/common/enums/checkpoint_abort.hpp" +#include "duckdb/common/enums/storage_block_prefetch.hpp" #include "duckdb/main/attached_database.hpp" #include "duckdb/main/config.hpp" #include "duckdb/main/database.hpp" @@ -26,6 +28,7 @@ namespace duckdb { const char MainHeader::MAGIC_BYTES[] = "DUCK"; const char MainHeader::CANARY[] = "DUCKKEY"; +static constexpr idx_t ENCRYPTION_METADATA_LEN = 8; void SerializeVersionNumber(WriteStream &ser, const string &version_str) { data_t version[MainHeader::MAX_VERSION_SIZE]; @@ -53,6 +56,30 @@ void SerializeEncryptionMetadata(WriteStream &ser, data_ptr_t metadata_p, const ser.WriteData(metadata, MainHeader::ENCRYPTION_METADATA_LEN); } +void SerializeIV(WriteStream &ser, data_ptr_t metadata_p, const bool encrypted) { + // Zero-initialize. + data_t iv[MainHeader::AES_IV_LEN]; + memset(iv, 0, MainHeader::AES_IV_LEN); + + // Write metadata, if encrypted. + if (encrypted) { + memcpy(iv, metadata_p, MainHeader::AES_IV_LEN); + } + ser.WriteData(iv, MainHeader::AES_IV_LEN); +} + +void SerializeTag(WriteStream &ser, data_ptr_t metadata_p, const bool encrypted) { + // Zero-initialize. + data_t tag[MainHeader::AES_TAG_LEN]; + memset(tag, 0, MainHeader::AES_TAG_LEN); + + // Write metadata, if encrypted. + if (encrypted) { + memcpy(tag, metadata_p, MainHeader::AES_TAG_LEN); + } + ser.WriteData(tag, MainHeader::AES_TAG_LEN); +} + void DeserializeVersionNumber(ReadStream &stream, data_t *dest) { memset(dest, 0, MainHeader::MAX_VERSION_SIZE); stream.ReadData(dest, MainHeader::MAX_VERSION_SIZE); @@ -72,16 +99,34 @@ void GenerateDBIdentifier(uint8_t *db_identifier) { void EncryptCanary(MainHeader &main_header, const shared_ptr &encryption_state, const_data_ptr_t derived_key) { uint8_t canary_buffer[MainHeader::CANARY_BYTE_SIZE]; + memset(canary_buffer, 0, MainHeader::CANARY_BYTE_SIZE); - // we zero-out the iv and the (not yet) encrypted canary uint8_t iv[MainHeader::AES_IV_LEN]; - memset(iv, 0, MainHeader::AES_IV_LEN); - memset(canary_buffer, 0, MainHeader::CANARY_BYTE_SIZE); - encryption_state->InitializeEncryption(iv, MainHeader::AES_IV_LEN, derived_key, - MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); - encryption_state->Process(reinterpret_cast(MainHeader::CANARY), MainHeader::CANARY_BYTE_SIZE, - canary_buffer, MainHeader::CANARY_BYTE_SIZE); + switch (main_header.GetEncryptionVersion()) { + case 0: + memset(iv, 0, MainHeader::AES_IV_LEN); + encryption_state->InitializeEncryption(iv, MainHeader::AES_IV_LEN, derived_key, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + encryption_state->Process(reinterpret_cast(MainHeader::CANARY), MainHeader::CANARY_BYTE_SIZE, + canary_buffer, MainHeader::CANARY_BYTE_SIZE); + break; + + case 1: + uint8_t tag[MainHeader::AES_TAG_LEN]; + encryption_state->GenerateRandomData(iv, MainHeader::AES_IV_LEN); + main_header.SetCanaryIV(iv); + encryption_state->InitializeEncryption(iv, MainHeader::AES_IV_LEN, derived_key, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + encryption_state->Process(reinterpret_cast(MainHeader::CANARY), MainHeader::CANARY_BYTE_SIZE, + canary_buffer, MainHeader::CANARY_BYTE_SIZE); + encryption_state->Finalize(canary_buffer, MainHeader::CANARY_BYTE_SIZE, tag, MainHeader::AES_TAG_LEN); + main_header.SetCanaryTag(tag); + break; + + default: + throw InvalidInputException("No valid encryption version found!"); + } main_header.SetEncryptedCanary(canary_buffer); } @@ -96,11 +141,36 @@ bool DecryptCanary(MainHeader &main_header, const shared_ptr &e data_t decrypted_canary[MainHeader::CANARY_BYTE_SIZE]; memset(decrypted_canary, 0, MainHeader::CANARY_BYTE_SIZE); - //! Decrypt the canary - encryption_state->InitializeDecryption(iv, MainHeader::AES_IV_LEN, derived_key, - MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); - encryption_state->Process(main_header.GetEncryptedCanary(), MainHeader::CANARY_BYTE_SIZE, decrypted_canary, - MainHeader::CANARY_BYTE_SIZE); + switch (main_header.GetEncryptionVersion()) { + case 0: + // zero-out the IV + memset(iv, 0, MainHeader::AES_IV_LEN); + //! Decrypt the canary + encryption_state->InitializeDecryption(iv, MainHeader::AES_IV_LEN, derived_key, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + encryption_state->Process(main_header.GetEncryptedCanary(), MainHeader::CANARY_BYTE_SIZE, decrypted_canary, + MainHeader::CANARY_BYTE_SIZE); + break; + case 1: + uint8_t tag[MainHeader::AES_TAG_LEN]; + // get the IV and the Tag + memcpy(iv, main_header.GetIV(), MainHeader::AES_IV_LEN); + memcpy(tag, main_header.GetTag(), MainHeader::AES_TAG_LEN); + + //! Decrypt the canary + encryption_state->InitializeDecryption(iv, MainHeader::AES_IV_LEN, derived_key, + MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + encryption_state->Process(main_header.GetEncryptedCanary(), MainHeader::CANARY_BYTE_SIZE, decrypted_canary, + MainHeader::CANARY_BYTE_SIZE); + try { + encryption_state->Finalize(decrypted_canary, MainHeader::CANARY_BYTE_SIZE, tag, MainHeader::AES_TAG_LEN); + } catch (const std::exception &e) { + throw InvalidInputException("Wrong encryption key used to open the database file"); + } + break; + default: + throw InvalidInputException("No valid encryption version found!"); + } //! compare if the decrypted canary is correct if (memcmp(decrypted_canary, MainHeader::CANARY, MainHeader::CANARY_BYTE_SIZE) != 0) { @@ -125,6 +195,8 @@ void MainHeader::Write(WriteStream &ser) { SerializeEncryptionMetadata(ser, encryption_metadata, encryption_enabled); SerializeDBIdentifier(ser, db_identifier); SerializeEncryptionMetadata(ser, encrypted_canary, encryption_enabled); + SerializeIV(ser, canary_iv, encryption_enabled); + SerializeTag(ser, canary_tag, encryption_enabled); } void MainHeader::CheckMagicBytes(QueryContext context, FileHandle &handle) { @@ -175,7 +247,6 @@ MainHeader MainHeader::Read(ReadStream &source) { for (idx_t i = 0; i < FLAG_COUNT; i++) { header.flags[i] = source.Read(); } - DeserializeVersionNumber(source, header.library_git_desc); DeserializeVersionNumber(source, header.library_git_hash); @@ -183,6 +254,8 @@ MainHeader MainHeader::Read(ReadStream &source) { DeserializeEncryptionData(source, header.encryption_metadata, MainHeader::ENCRYPTION_METADATA_LEN); DeserializeEncryptionData(source, header.db_identifier, MainHeader::DB_IDENTIFIER_LEN); DeserializeEncryptionData(source, header.encrypted_canary, MainHeader::CANARY_BYTE_SIZE); + DeserializeEncryptionData(source, header.canary_iv, MainHeader::AES_IV_LEN); + DeserializeEncryptionData(source, header.canary_tag, MainHeader::AES_TAG_LEN); return header; } @@ -301,8 +374,15 @@ MainHeader ConstructMainHeader(idx_t version_number) { void SingleFileBlockManager::StoreEncryptedCanary(AttachedDatabase &db, MainHeader &main_header, const string &key_id) { const_data_ptr_t key = EncryptionEngine::GetKeyFromCache(db.GetDatabase(), key_id); // Encrypt canary with the derived key - auto encryption_state = db.GetDatabase().GetEncryptionUtil()->CreateEncryptionState( - main_header.GetEncryptionCipher(), MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + shared_ptr encryption_state; + if (main_header.GetEncryptionVersion() > 0) { + // From Encryption Version 1+, always encrypt canary with GCM + encryption_state = db.GetDatabase().GetEncryptionUtil()->CreateEncryptionState( + EncryptionTypes::GCM, MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + } else { + encryption_state = db.GetDatabase().GetEncryptionUtil()->CreateEncryptionState( + main_header.GetEncryptionCipher(), MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + } EncryptCanary(main_header, encryption_state, key); } @@ -310,26 +390,26 @@ void SingleFileBlockManager::StoreDBIdentifier(MainHeader &main_header, data_ptr main_header.SetDBIdentifier(db_identifier); } +template +void SingleFileBlockManager::WriteEncryptionData(MemoryStream &stream, const T &val) { + stream.WriteData(reinterpret_cast(&val), sizeof(val)); +} + void SingleFileBlockManager::StoreEncryptionMetadata(MainHeader &main_header) const { // The first byte is the key derivation function (kdf). // The second byte is for the usage of AAD. // The third byte is for the cipher. // The subsequent byte is empty. // The last 4 bytes are the key length. + auto metadata_stream = make_uniq(ENCRYPTION_METADATA_LEN); - uint8_t metadata[MainHeader::ENCRYPTION_METADATA_LEN]; - memset(metadata, 0, MainHeader::ENCRYPTION_METADATA_LEN); - data_ptr_t offset = metadata; - - Store(options.encryption_options.kdf, offset); - offset++; - Store(options.encryption_options.additional_authenticated_data, offset); - offset++; - Store(db.GetStorageManager().GetCipher(), offset); - offset += 2; - Store(options.encryption_options.key_length, offset); + WriteEncryptionData(*metadata_stream, options.encryption_options.kdf); + WriteEncryptionData(*metadata_stream, options.encryption_options.additional_authenticated_data); + WriteEncryptionData(*metadata_stream, db.GetStorageManager().GetCipher()); + WriteEncryptionData(*metadata_stream, options.encryption_options.encryption_version); + WriteEncryptionData(*metadata_stream, options.encryption_options.key_length); - main_header.SetEncryptionMetadata(metadata); + main_header.SetEncryptionMetadata(metadata_stream->GetData()); } void SingleFileBlockManager::CheckAndAddEncryptionKey(MainHeader &main_header, string &user_key) { @@ -343,10 +423,18 @@ void SingleFileBlockManager::CheckAndAddEncryptionKey(MainHeader &main_header, s data_t derived_key[MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH]; EncryptionKeyManager::DeriveKey(user_key, db_identifier, derived_key); - auto encryption_state = db.GetDatabase().GetEncryptionUtil()->CreateEncryptionState( - main_header.GetEncryptionCipher(), MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + shared_ptr encryption_state; + if (main_header.GetEncryptionVersion() > 0) { + // From Encryption Version 1+, always encrypt canary with GCM + encryption_state = db.GetDatabase().GetEncryptionUtil()->CreateEncryptionState( + EncryptionTypes::GCM, MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + } else { + encryption_state = db.GetDatabase().GetEncryptionUtil()->CreateEncryptionState( + main_header.GetEncryptionCipher(), MainHeader::DEFAULT_ENCRYPTION_KEY_LENGTH); + } + if (!DecryptCanary(main_header, encryption_state, derived_key)) { - throw IOException("Wrong encryption key used to open the database file"); + throw InvalidInputException("Wrong encryption key used to open the database file"); } options.encryption_options.derived_key_id = EncryptionEngine::AddKeyToCache(db.GetDatabase(), derived_key); @@ -409,6 +497,12 @@ void SingleFileBlockManager::CreateNewDatabase(QueryContext context) { // Set the encrypted DB bit to 1. main_header.SetEncrypted(); + if (options.encryption_options.encryption_version == EncryptionTypes::NONE) { + throw InvalidConfigurationException("No Encryption type set"); + } + + main_header.SetEncryptionVersion(options.encryption_options.encryption_version); + // The derived key is wiped in AddKeyToCache. options.encryption_options.derived_key_id = EncryptionEngine::AddKeyToCache(db.GetDatabase(), derived_key); auto &catalog = db.GetCatalog().Cast(); @@ -490,6 +584,9 @@ void SingleFileBlockManager::LoadExistingDatabase(QueryContext context) { MainHeader main_header = DeserializeMainHeader(header_buffer.buffer - delta); memcpy(options.db_identifier, main_header.GetDBIdentifier(), MainHeader::DB_IDENTIFIER_LEN); + // encryption version can be overridden by the real encryption version + options.encryption_options.encryption_version = main_header.GetEncryptionVersion(); + if (!main_header.IsEncrypted() && options.encryption_options.encryption_enabled) { throw CatalogException("A key is explicitly specified, but database \"%s\" is not encrypted", path); // database is not encrypted, but is tried to be opened with a key @@ -961,7 +1058,7 @@ bool SingleFileBlockManager::IsRemote() { } bool SingleFileBlockManager::Prefetch() { - switch (DBConfig::GetSetting(db.GetDatabase())) { + switch (Settings::Get(db.GetDatabase())) { case StorageBlockPrefetch::NEVER: return false; case StorageBlockPrefetch::DEBUG_FORCE_ALWAYS: @@ -1190,7 +1287,7 @@ void SingleFileBlockManager::WriteHeader(QueryContext context, DatabaseHeader he header.serialization_compatibility = options.storage_version.GetIndex(); - auto debug_checkpoint_abort = DBConfig::GetSetting(db.GetDatabase()); + auto debug_checkpoint_abort = Settings::Get(db.GetDatabase()); if (debug_checkpoint_abort == CheckpointAbort::DEBUG_ABORT_AFTER_FREE_LIST_WRITE) { throw FatalException("Checkpoint aborted after free list write because of PRAGMA checkpoint_abort flag"); } diff --git a/src/duckdb/src/storage/standard_buffer_manager.cpp b/src/duckdb/src/storage/standard_buffer_manager.cpp index a90ba37f0..c5f839832 100644 --- a/src/duckdb/src/storage/standard_buffer_manager.cpp +++ b/src/duckdb/src/storage/standard_buffer_manager.cpp @@ -2,6 +2,7 @@ #include "duckdb/common/allocator.hpp" #include "duckdb/common/enums/memory_tag.hpp" +#include "duckdb/common/enums/storage_block_prefetch.hpp" #include "duckdb/common/exception.hpp" #include "duckdb/common/set.hpp" #include "duckdb/main/attached_database.hpp" @@ -217,7 +218,7 @@ void StandardBufferManager::ReAllocate(shared_ptr &handle, idx_t bl D_ASSERT(handle_memory_usage == handle->GetBuffer(lock)->AllocSize()); D_ASSERT(handle_memory_usage == handle->GetMemoryCharge(lock).size); - auto req = handle->GetBuffer(lock)->CalculateMemory(block_size, handle->block_manager.GetBlockHeaderSize()); + auto req = handle->GetBuffer(lock)->CalculateMemory(block_size, handle->GetBlockHeaderSize()); int64_t memory_delta = NumericCast(req.alloc_size) - NumericCast(handle_memory_usage); if (memory_delta == 0) { @@ -244,10 +245,9 @@ void StandardBufferManager::ReAllocate(shared_ptr &handle, idx_t bl void StandardBufferManager::BatchRead(vector> &handles, const map &load_map, block_id_t first_block, block_id_t last_block) { - auto &block_manager = handles[0]->block_manager; idx_t block_count = NumericCast(last_block - first_block + 1); if (block_count == 1) { - if (DBConfig::GetSetting(db) != StorageBlockPrefetch::DEBUG_FORCE_ALWAYS) { + if (Settings::Get(db) != StorageBlockPrefetch::DEBUG_FORCE_ALWAYS) { // prefetching with block_count == 1 has no performance impact since we can't batch reads // skip the prefetch in this case // we do it anyway if alternative_verify is on for extra testing @@ -255,12 +255,14 @@ void StandardBufferManager::BatchRead(vector> &handles, } } - // allocate a buffer to hold the data of all of the blocks - auto total_block_size = block_count * block_manager.GetBlockAllocSize(); + // Allocate a buffer to hold the data of all blocks. + auto block_alloc_size = handles[0]->GetBlockAllocSize(); + auto total_block_size = block_count * block_alloc_size; auto batch_memory = RegisterMemory(MemoryTag::BASE_TABLE, total_block_size, 0, true); auto intermediate_buffer = Pin(batch_memory); // perform a batch read of the blocks into the buffer + auto &block_manager = handles[0]->GetBlockManager(); block_manager.ReadBlocks(intermediate_buffer.GetFileBuffer(), first_block, block_count); // the blocks are read - now we need to assign them to the individual blocks @@ -287,8 +289,7 @@ void StandardBufferManager::BatchRead(vector> &handles, reservation.Resize(0); continue; } - auto block_ptr = - intermediate_buffer.GetFileBuffer().InternalBuffer() + block_idx * block_manager.GetBlockAllocSize(); + auto block_ptr = intermediate_buffer.GetFileBuffer().InternalBuffer() + block_idx * block_alloc_size; buf = handle->LoadFromBuffer(lock, block_ptr, std::move(reusable_buffer), std::move(reservation)); } } @@ -494,6 +495,10 @@ void StandardBufferManager::RequireTemporaryDirectory() { } } +bool StandardBufferManager::EncryptTemporaryFiles() { + return Settings::Get(db); +} + void StandardBufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block_id, FileBuffer &buffer) { // WriteTemporaryBuffer assumes that we never write a buffer below DEFAULT_BLOCK_ALLOC_SIZE. RequireTemporaryDirectory(); @@ -510,7 +515,7 @@ void StandardBufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block auto path = GetTemporaryPath(block_id); idx_t header_size = sizeof(idx_t) * 2; - if (db.config.options.temp_file_encryption) { + if (EncryptTemporaryFiles()) { header_size += DEFAULT_ENCRYPTED_BUFFER_HEADER_SIZE; } @@ -527,7 +532,7 @@ void StandardBufferManager::WriteTemporaryBuffer(MemoryTag tag, block_id_t block idx_t offset = sizeof(idx_t) * 2; - if (db.config.options.temp_file_encryption) { + if (EncryptTemporaryFiles()) { uint8_t encryption_metadata[DEFAULT_ENCRYPTED_BUFFER_HEADER_SIZE]; EncryptionEngine::EncryptTemporaryBuffer(db, buffer.InternalBuffer(), buffer.AllocSize(), encryption_metadata); //! Write the nonce (and tag for GCM). @@ -565,7 +570,7 @@ unique_ptr StandardBufferManager::ReadTemporaryBuffer(QueryContext c // Allocate a buffer of the file's size and read the data into that buffer. auto buffer = ConstructManagedBuffer(block_size, block_header_size, std::move(reusable_buffer)); - if (db.config.options.temp_file_encryption) { + if (EncryptTemporaryFiles()) { // encrypted //! Read nonce and tag from file. uint8_t encryption_metadata[DEFAULT_ENCRYPTED_BUFFER_HEADER_SIZE]; @@ -588,6 +593,9 @@ unique_ptr StandardBufferManager::ReadTemporaryBuffer(QueryContext c } void StandardBufferManager::DeleteTemporaryFile(BlockHandle &block) { + if (!block.IsUnloaded()) { + return; + } auto id = block.BlockId(); if (temporary_directory.path.empty()) { // no temporary directory specified: nothing to delete diff --git a/src/duckdb/src/storage/statistics/base_statistics.cpp b/src/duckdb/src/storage/statistics/base_statistics.cpp index 176045148..54c3a7b11 100644 --- a/src/duckdb/src/storage/statistics/base_statistics.cpp +++ b/src/duckdb/src/storage/statistics/base_statistics.cpp @@ -269,6 +269,8 @@ unique_ptr BaseStatistics::PushdownExtract(const StorageIndex &i switch (stats_type) { case StatisticsType::STRUCT_STATS: return StructStats::PushdownExtract(*this, index); + case StatisticsType::VARIANT_STATS: + return VariantStats::PushdownExtract(*this, index); default: throw InternalException("PushdownExtract not supported for StatisticsType::%s", EnumUtil::ToString(stats_type)); } @@ -346,7 +348,7 @@ void BaseStatistics::CombineValidity(const BaseStatistics &left, const BaseStati has_no_null = left.has_no_null || right.has_no_null; } -void BaseStatistics::CopyValidity(BaseStatistics &stats) { +void BaseStatistics::CopyValidity(const BaseStatistics &stats) { has_null = stats.has_null; has_no_null = stats.has_no_null; } diff --git a/src/duckdb/src/storage/statistics/geometry_stats.cpp b/src/duckdb/src/storage/statistics/geometry_stats.cpp index 91ebeaa5f..f2f7fae6b 100644 --- a/src/duckdb/src/storage/statistics/geometry_stats.cpp +++ b/src/duckdb/src/storage/statistics/geometry_stats.cpp @@ -98,6 +98,9 @@ void GeometryStats::Serialize(const BaseStatistics &stats, Serializer &serialize types.WriteProperty(103, "types_xym", data.types.sets[2]); types.WriteProperty(104, "types_xyzm", data.types.sets[3]); }); + + // Write flags + serializer.WritePropertyWithDefault(202, "flags", data.flags.flags); } void GeometryStats::Deserialize(Deserializer &deserializer, BaseStatistics &base) { @@ -122,6 +125,9 @@ void GeometryStats::Deserialize(Deserializer &deserializer, BaseStatistics &base types.ReadProperty(103, "types_xym", data.types.sets[2]); types.ReadProperty(104, "types_xyzm", data.types.sets[3]); }); + + // Read flags + deserializer.ReadPropertyWithDefault(202, "flags", data.flags.flags); } string GeometryStats::ToString(const BaseStatistics &stats) { @@ -129,10 +135,14 @@ string GeometryStats::ToString(const BaseStatistics &stats) { string result; result += "["; - result += StringUtil::Format("Extent: [X: [%f, %f], Y: [%f, %f], Z: [%f, %f], M: [%f, %f]", data.extent.x_min, + result += StringUtil::Format("Extent: [X: [%f, %f], Y: [%f, %f], Z: [%f, %f], M: [%f, %f]]", data.extent.x_min, data.extent.x_max, data.extent.y_min, data.extent.y_max, data.extent.z_min, data.extent.z_max, data.extent.m_min, data.extent.m_max); - result += StringUtil::Format("], Types: [%s]", StringUtil::Join(data.types.ToString(true), ", ")); + result += StringUtil::Format(", Types: [%s]", StringUtil::Join(data.types.ToString(true), ", ")); + result += StringUtil::Format( + ", Flags: [Has Empty Geom: %s, Has No Empty Geom: %s, Has Empty Part: %s, Has No Empty Part: %s]", + data.flags.HasEmptyGeometry() ? "true" : "false", data.flags.HasNonEmptyGeometry() ? "true" : "false", + data.flags.HasEmptyPart() ? "true" : "false", data.flags.HasNonEmptyPart() ? "true" : "false"); result += "]"; return result; @@ -178,6 +188,10 @@ GeometryTypeSet &GeometryStats::GetTypes(BaseStatistics &stats) { return GetDataUnsafe(stats).types; } +GeometryStatsFlags &GeometryStats::GetFlags(BaseStatistics &stats) { + return GetDataUnsafe(stats).flags; +} + const GeometryExtent &GeometryStats::GetExtent(const BaseStatistics &stats) { return GetDataUnsafe(stats).extent; } @@ -186,6 +200,10 @@ const GeometryTypeSet &GeometryStats::GetTypes(const BaseStatistics &stats) { return GetDataUnsafe(stats).types; } +const GeometryStatsFlags &GeometryStats::GetFlags(const BaseStatistics &stats) { + return GetDataUnsafe(stats).flags; +} + // Expression comparison pruning static FilterPropagateResult CheckIntersectionFilter(const GeometryStatsData &data, const Value &constant) { if (constant.IsNull() || constant.type().id() != LogicalTypeId::GEOMETRY) { diff --git a/src/duckdb/src/storage/statistics/variant_stats.cpp b/src/duckdb/src/storage/statistics/variant_stats.cpp index d36f2573f..ca93aa608 100644 --- a/src/duckdb/src/storage/statistics/variant_stats.cpp +++ b/src/duckdb/src/storage/statistics/variant_stats.cpp @@ -105,6 +105,39 @@ static void AssertShreddedStats(const BaseStatistics &stats) { } } +optional_ptr VariantShreddedStats::FindChildStats(const BaseStatistics &stats, + const VariantPathComponent &component) { + AssertShreddedStats(stats); + + auto &typed_value_stats = StructStats::GetChildStats(stats, 1); + auto &typed_value_type = typed_value_stats.GetType(); + switch (component.lookup_mode) { + case VariantChildLookupMode::BY_INDEX: { + if (typed_value_type.id() != LogicalTypeId::LIST) { + return nullptr; + } + auto &child_stats = ListStats::GetChildStats(typed_value_stats); + return child_stats; + } + case VariantChildLookupMode::BY_KEY: { + if (typed_value_type.id() != LogicalTypeId::STRUCT) { + return nullptr; + } + auto &object_fields = StructType::GetChildTypes(typed_value_type); + for (idx_t i = 0; i < object_fields.size(); i++) { + auto &object_field = object_fields[i]; + if (StringUtil::CIEquals(object_field.first, component.key)) { + return StructStats::GetChildStats(typed_value_stats, i); + } + } + return nullptr; + } + default: + throw InternalException("VariantChildLookupMode::%s not implemented for FindShreddedStats", + EnumUtil::ToString(component.lookup_mode)); + } +} + bool VariantShreddedStats::IsFullyShredded(const BaseStatistics &stats) { AssertShreddedStats(stats); @@ -309,6 +342,18 @@ static BaseStatistics WrapTypedValue(BaseStatistics &untyped_value_index, BaseSt return shredded; } +unique_ptr VariantStats::WrapExtractedFieldAsVariant(const BaseStatistics &base_variant, + const BaseStatistics &extracted_field) { + D_ASSERT(base_variant.type.id() == LogicalTypeId::VARIANT); + AssertShreddedStats(extracted_field); + + BaseStatistics copy = BaseStatistics::CreateUnknown(base_variant.GetType()); + copy.Copy(base_variant); + copy.child_stats[1] = BaseStatistics::CreateUnknown(extracted_field.GetType()); + copy.child_stats[1].Copy(extracted_field); + return copy.ToUnique(); +} + bool VariantStats::MergeShredding(BaseStatistics &stats, const BaseStatistics &other, BaseStatistics &new_stats) { //! shredded_type: //! STRUCT(untyped_value_index UINTEGER, typed_value ) @@ -522,4 +567,58 @@ VariantStatsData &VariantStats::GetDataUnsafe(BaseStatistics &stats) { return stats.stats_union.variant_data; } +static bool CanUseShreddedStats(optional_ptr shredded_stats) { + return shredded_stats && VariantShreddedStats::IsFullyShredded(*shredded_stats); +} + +unique_ptr VariantStats::PushdownExtract(const BaseStatistics &stats, const StorageIndex &index) { + if (!VariantStats::IsShredded(stats)) { + //! Not shredded at all, no stats available + return nullptr; + } + + optional_ptr res(VariantStats::GetShreddedStats(stats)); + if (!CanUseShreddedStats(res)) { + //! Not fully shredded, can't say anything meaningful about the stats + return nullptr; + } + + reference index_iter(index); + while (true) { + auto ¤t = index_iter.get(); + D_ASSERT(!current.HasPrimaryIndex()); + auto &field_name = current.GetFieldName(); + VariantPathComponent path(field_name); + res = VariantShreddedStats::FindChildStats(*res, path); + if (!CanUseShreddedStats(res)) { + //! Not fully shredded, can't say anything meaningful about the stats + return nullptr; + } + if (!index_iter.get().HasChildren()) { + break; + } + } + auto &shredded_child_stats = *res; + + auto &typed_value_stats = StructStats::GetChildStats(shredded_child_stats, 1); + auto &last_index = index_iter.get(); + auto &child_type = typed_value_stats.type; + if (!last_index.HasType() || last_index.GetType().id() == LogicalTypeId::VARIANT) { + //! Return the variant stats, not the 'typed_value' (non-variant) stats, since there's no cast pushed down + return WrapExtractedFieldAsVariant(stats, shredded_child_stats); + } + if (!VariantShreddedStats::IsFullyShredded(shredded_child_stats)) { + //! Not all data is shredded, so there are values in the column that are not of the shredded type + return nullptr; + } + + auto &cast_type = last_index.GetType(); + if (child_type != cast_type) { + //! FIXME: support try_cast + return StatisticsPropagator::TryPropagateCast(typed_value_stats, child_type, cast_type); + } + auto result = typed_value_stats.ToUnique(); + return result; +} + } // namespace duckdb diff --git a/src/duckdb/src/storage/storage_manager.cpp b/src/duckdb/src/storage/storage_manager.cpp index 29d42ec7f..c29556bb6 100644 --- a/src/duckdb/src/storage/storage_manager.cpp +++ b/src/duckdb/src/storage/storage_manager.cpp @@ -5,6 +5,7 @@ #include "duckdb/main/attached_database.hpp" #include "duckdb/main/client_context.hpp" #include "duckdb/main/client_data.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/main/database.hpp" #include "duckdb/storage/checkpoint_manager.hpp" #include "duckdb/storage/in_memory_block_manager.hpp" @@ -20,9 +21,66 @@ #include "mbedtls_wrapper.hpp" namespace duckdb { - using SHA256State = duckdb_mbedtls::MbedTlsWrapper::SHA256State; +void StorageOptions::SetEncryptionVersion(string &storage_version_user_provided) { + // storage version < v1.4.0 + if (!storage_version.IsValid() || + storage_version.GetIndex() < SerializationCompatibility::FromString("v1.4.0").serialization_version) { + if (!storage_version_user_provided.empty()) { + throw InvalidInputException("Explicit provided STORAGE_VERSION (\"%s\") and ENCRYPTION_KEY (storage >= " + "v1.4.0) are not compatible", + storage_version_user_provided); + } + } + + auto target_encryption_version = encryption_version; + + if (target_encryption_version == EncryptionTypes::NONE) { + target_encryption_version = EncryptionTypes::V0_1; + } + + switch (target_encryption_version) { + case EncryptionTypes::V0_1: + // storage version not explicitly set + if (!storage_version.IsValid() && storage_version_user_provided.empty()) { + storage_version = SerializationCompatibility::FromString("v1.5.0").serialization_version; + break; + } + // storage version set, but v1.4.0 =< storage < v1.5.0 + if (storage_version.GetIndex() < SerializationCompatibility::FromString("v1.5.0").serialization_version) { + if (!storage_version_user_provided.empty()) { + if (encryption_version == target_encryption_version) { + // encryption version is explicitly given, but not compatible with < v1.5.0 + throw InvalidInputException("Explicit provided STORAGE_VERSION (\"%s\") is not compatible with " + "'debug_encryption_version = v1' (storage >= " + "v1.5.0)", + storage_version_user_provided); + } + } else { + // encryption version needs to be lowered, because storage version < v1.5.0 + target_encryption_version = EncryptionTypes::V0_0; + break; + } + } + + break; + + case EncryptionTypes::V0_0: + // we set this to V0 to V1.5.0 if no explicit storage version provided + if (!storage_version.IsValid() && storage_version_user_provided.empty()) { + storage_version = SerializationCompatibility::FromString("v1.5.0").serialization_version; + break; + } + // if storage version is provided, we do nothing + break; + default: + throw InvalidConfigurationException("Encryption version is not set"); + } + + encryption_version = target_encryption_version; +} + void StorageOptions::Initialize(const unordered_map &options) { string storage_version_user_provided = ""; for (auto &entry : options) { @@ -61,20 +119,14 @@ void StorageOptions::Initialize(const unordered_map &options) { } else { compress_in_memory = CompressInMemory::DO_NOT_COMPRESS; } + } else if (entry.first == "debug_encryption_version") { + encryption_version = EncryptionTypes::StringToVersion(entry.second.ToString()); } else { throw BinderException("Unrecognized option for attach \"%s\"", entry.first); } } - if (encryption && - (!storage_version.IsValid() || - storage_version.GetIndex() < SerializationCompatibility::FromString("v1.4.0").serialization_version)) { - if (!storage_version_user_provided.empty()) { - throw InvalidInputException( - "Explicit provided STORAGE_VERSION (\"%s\") and ENCRYPTION_KEY (storage >= v1.4.0) are not compatible", - storage_version_user_provided); - } - // set storage version to v1.4.0 - storage_version = SerializationCompatibility::FromString("v1.4.0").serialization_version; + if (encryption) { + SetEncryptionVersion(storage_version_user_provided); } } @@ -230,11 +282,11 @@ string StorageManager::GetWALPath(const string &suffix) { } string StorageManager::GetCheckpointWALPath() { - return GetWALPath(".checkpoint.wal"); + return GetWALPath(".wal.checkpoint"); } string StorageManager::GetRecoveryWALPath() { - return GetWALPath(".recovery.wal"); + return GetWALPath(".wal.recovery"); } bool StorageManager::InMemory() const { @@ -323,6 +375,7 @@ void SingleFileStorageManager::LoadDatabase(QueryContext context) { D_ASSERT(storage_options.block_header_size == DEFAULT_ENCRYPTION_BLOCK_HEADER_SIZE); options.encryption_options.encryption_enabled = true; options.encryption_options.user_key = std::move(storage_options.user_key); + options.encryption_options.encryption_version = storage_options.encryption_version; } idx_t row_group_size = DEFAULT_ROW_GROUP_SIZE; @@ -355,7 +408,7 @@ void SingleFileStorageManager::LoadDatabase(QueryContext context) { options.block_alloc_size = storage_options.block_alloc_size; } else { // No explicit option provided: use the default option. - options.block_alloc_size = config.options.default_block_alloc_size; + options.block_alloc_size = Settings::Get(config); } //! set the block header size for the encrypted database files //! set the database to encrypted diff --git a/src/duckdb/src/storage/table/array_column_data.cpp b/src/duckdb/src/storage/table/array_column_data.cpp index ad6618674..4fc2c0d4a 100644 --- a/src/duckdb/src/storage/table/array_column_data.cpp +++ b/src/duckdb/src/storage/table/array_column_data.cpp @@ -268,6 +268,14 @@ void ArrayColumnData::VisitBlockIds(BlockIdVisitor &visitor) const { child_column->VisitBlockIds(visitor); } +const BaseStatistics &ArrayColumnData::GetChildStats(const ColumnData &child) const { + if (!RefersToSameObject(child, *child_column)) { + throw InternalException("ArrayColumnData::GetChildStats provided column data is not a child of this array"); + } + auto &stats = GetStatisticsRef(); + return ArrayStats::GetChildStats(stats); +} + void ArrayColumnData::SetValidityData(shared_ptr validity_p) { if (validity) { throw InternalException("ArrayColumnData::SetValidityData cannot be used to overwrite existing validity"); @@ -333,11 +341,13 @@ unique_ptr ArrayColumnData::CreateCheckpointState(const R } unique_ptr ArrayColumnData::Checkpoint(const RowGroup &row_group, - ColumnCheckpointInfo &checkpoint_info) { + ColumnCheckpointInfo &checkpoint_info, + const BaseStatistics &old_stats) { auto &partial_block_manager = checkpoint_info.GetPartialBlockManager(); auto checkpoint_state = make_uniq(row_group, *this, partial_block_manager); - checkpoint_state->validity_state = validity->Checkpoint(row_group, checkpoint_info); - checkpoint_state->child_state = child_column->Checkpoint(row_group, checkpoint_info); + checkpoint_state->validity_state = validity->Checkpoint(row_group, checkpoint_info, old_stats); + checkpoint_state->child_state = + child_column->Checkpoint(row_group, checkpoint_info, ArrayStats::GetChildStats(old_stats)); return std::move(checkpoint_state); } diff --git a/src/duckdb/src/storage/table/column_data.cpp b/src/duckdb/src/storage/table/column_data.cpp index d3cb69da4..60261cf28 100644 --- a/src/duckdb/src/storage/table/column_data.cpp +++ b/src/duckdb/src/storage/table/column_data.cpp @@ -17,6 +17,7 @@ #include "duckdb/common/serializer/binary_deserializer.hpp" #include "duckdb/common/serializer/serializer.hpp" #include "duckdb/function/variant/variant_shredding.hpp" +#include "duckdb/storage/table/geo_column_data.hpp" namespace duckdb { @@ -416,12 +417,26 @@ FilterPropagateResult ColumnData::CheckZonemap(const StorageIndex &index, TableF lock_guard l(stats_lock); if (index.IsPushdownExtract()) { auto child_stats = stats->statistics.PushdownExtract(index.GetChildIndex(0)); - D_ASSERT(child_stats); + if (!child_stats) { + return FilterPropagateResult::NO_PRUNING_POSSIBLE; + } return filter.CheckStatistics(*child_stats); } return filter.CheckStatistics(stats->statistics); } +const BaseStatistics &ColumnData::GetStatisticsRef() const { + if (stats) { + return stats->statistics; + } + D_ASSERT(HasParent()); + return parent->GetChildStats(*this); +} + +const BaseStatistics &ColumnData::GetChildStats(const ColumnData &child) const { + throw InternalException("GetChildStats not implemented for ColumnData of type %s", type.ToString()); +} + unique_ptr ColumnData::GetStatistics() const { if (!stats) { throw InternalException("ColumnData::GetStatistics called on a column without stats"); @@ -665,6 +680,14 @@ void ColumnData::CheckpointScan(ColumnSegment &segment, ColumnScanState &state, unique_ptr ColumnData::Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info) { + if (!stats) { + throw InternalException("ColumnData::Checkpoint called without stats on a nested column"); + } + return Checkpoint(row_group, checkpoint_info, this->stats->statistics); +} + +unique_ptr +ColumnData::Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &checkpoint_info, const BaseStatistics &stats) { // scan the segments of the column data // set up the checkpoint state auto &partial_block_manager = checkpoint_info.GetPartialBlockManager(); @@ -688,7 +711,7 @@ void ColumnData::InitializeColumn(PersistentColumnData &column_data) { } void ColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) { - D_ASSERT(type.InternalType() == column_data.physical_type); + D_ASSERT(type.InternalType() == column_data.logical_type.InternalType()); // construct the segments based on the data pointers this->count = 0; for (auto &data_pointer : column_data.pointers) { @@ -731,12 +754,11 @@ vector ColumnData::GetDataPointers() { return pointers; } -PersistentColumnData::PersistentColumnData(const LogicalType &logical_type) - : physical_type(logical_type.InternalType()), logical_type_id(logical_type.id()) { +PersistentColumnData::PersistentColumnData(const LogicalType &logical_type_p) : logical_type(logical_type_p) { } -PersistentColumnData::PersistentColumnData(const LogicalType &logical_type, vector pointers_p) - : physical_type(logical_type.InternalType()), logical_type_id(logical_type.id()), pointers(std::move(pointers_p)) { +PersistentColumnData::PersistentColumnData(const LogicalType &logical_type_p, vector pointers_p) + : logical_type(logical_type_p), pointers(std::move(pointers_p)) { D_ASSERT(!pointers.empty()); } @@ -747,35 +769,42 @@ void PersistentColumnData::Serialize(Serializer &serializer) const { if (has_updates) { throw InternalException("Column data with updates cannot be serialized"); } - serializer.WritePropertyWithDefault(100, "data_pointers", pointers); - if (child_columns.empty()) { - // validity column - D_ASSERT(physical_type == PhysicalType::BIT); - return; - } - serializer.WriteProperty(101, "validity", child_columns[0]); - - if (logical_type_id == LogicalTypeId::VARIANT) { - D_ASSERT(physical_type == PhysicalType::STRUCT); - D_ASSERT(child_columns.size() == 2 || child_columns.size() == 3); - auto unshredded_type = VariantShredding::GetUnshreddedType(); - serializer.WriteProperty(102, "unshredded", child_columns[1]); + // Serialize the extra data + serializer.WritePropertyWithDefault(99, "extra_data", extra_data); - if (child_columns.size() == 3) { - D_ASSERT(variant_shredded_type.id() == LogicalTypeId::STRUCT); - serializer.WriteProperty(115, "shredded_type", variant_shredded_type); - serializer.WriteProperty(120, "shredded", child_columns[2]); + // TODO: Dont special-case this + if (logical_type.id() == LogicalTypeId::VARIANT) { + serializer.WritePropertyWithDefault(100, "data_pointers", pointers); + serializer.WriteProperty(101, "validity", child_columns[0]); + serializer.WriteProperty(102, "unshredded", child_columns[1]); + if (child_columns.size() > 2) { + serializer.WriteProperty(103, "shredded", child_columns[2]); } return; } - if (physical_type == PhysicalType::ARRAY || physical_type == PhysicalType::LIST) { + switch (logical_type.InternalType()) { + case PhysicalType::BIT: { + serializer.WritePropertyWithDefault(100, "data_pointers", pointers); + } break; + case PhysicalType::ARRAY: + case PhysicalType::LIST: { D_ASSERT(child_columns.size() == 2); + serializer.WritePropertyWithDefault(100, "data_pointers", pointers); + serializer.WriteProperty(101, "validity", child_columns[0]); serializer.WriteProperty(102, "child_column", child_columns[1]); - } else if (physical_type == PhysicalType::STRUCT) { + } break; + case PhysicalType::STRUCT: { + serializer.WritePropertyWithDefault(100, "data_pointers", pointers); + serializer.WriteProperty(101, "validity", child_columns[0]); serializer.WriteList(102, "sub_columns", child_columns.size() - 1, [&](Serializer::List &list, idx_t i) { list.WriteElement(child_columns[i + 1]); }); + } break; + default: { + serializer.WritePropertyWithDefault(100, "data_pointers", pointers); + serializer.WriteProperty(101, "validity", child_columns[0]); + } break; } } @@ -786,53 +815,123 @@ void PersistentColumnData::DeserializeField(Deserializer &deserializer, field_id deserializer.Unset(); } -PersistentColumnData PersistentColumnData::Deserialize(Deserializer &deserializer) { - auto &type = deserializer.Get(); - auto physical_type = type.InternalType(); - PersistentColumnData result(type); - deserializer.ReadPropertyWithDefault(100, "data_pointers", static_cast &>(result.pointers)); - if (result.physical_type == PhysicalType::BIT) { - // validity: return +static PersistentColumnData GetPersistentColumnDataType(Deserializer &deserializer) { + auto extra_data = + deserializer.ReadPropertyWithExplicitDefault>(99, "extra_data", nullptr); + + if (!extra_data) { + // Get the type from the parent scope + auto &type = deserializer.Get(); + return PersistentColumnData(type); + } + + // Otherwise, the type of this segment may depend on extra data + switch (extra_data->GetType()) { + case ExtraPersistentColumnDataType::VARIANT: { + auto unshredded_type = VariantShredding::GetUnshreddedType(); + PersistentColumnData result(LogicalType::VARIANT()); + result.extra_data = std::move(extra_data); return result; } - result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + case ExtraPersistentColumnDataType::GEOMETRY: { + const auto &geometry_data = extra_data->Cast(); + PersistentColumnData result(Geometry::GetVectorizedType(geometry_data.geom_type, geometry_data.vert_type)); + result.extra_data = std::move(extra_data); + return result; + } + default: + throw InternalException(""); + } +} +PersistentColumnData PersistentColumnData::Deserialize(Deserializer &deserializer) { + auto result = GetPersistentColumnDataType(deserializer); + const auto &type = result.logical_type; + + // TODO: Dont special-case this if (type.id() == LogicalTypeId::VARIANT) { - auto unshredded_type = VariantShredding::GetUnshreddedType(); + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + result.DeserializeField(deserializer, 102, "unshredded", VariantShredding::GetUnshreddedType()); + if (result.extra_data) { + auto &variant_data = result.extra_data->Cast(); + result.DeserializeField(deserializer, 103, "shredded", variant_data.logical_type); + } + return result; + } + + // TODO: This is ugly + if (result.extra_data && result.extra_data->GetType() == ExtraPersistentColumnDataType::GEOMETRY) { + auto &geo_data = result.extra_data->Cast(); + auto actual_type = Geometry::GetVectorizedType(geo_data.geom_type, geo_data.vert_type); + + // We need to set the actual type in scope, as when we deserialize "data_pointers" we use it to detect + // the type of the statistics. + deserializer.Set(actual_type); + + switch (actual_type.InternalType()) { + case PhysicalType::BIT: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + } break; + case PhysicalType::ARRAY: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + result.DeserializeField(deserializer, 102, "child_column", ArrayType::GetChildType(type)); + } break; + case PhysicalType::LIST: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + result.DeserializeField(deserializer, 102, "child_column", ListType::GetChildType(type)); + } break; + case PhysicalType::STRUCT: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + const auto &child_types = StructType::GetChildTypes(type); + deserializer.ReadList(102, "sub_columns", [&](Deserializer::List &list, idx_t i) { + deserializer.Set(child_types[i].second); + result.child_columns.push_back(list.ReadElement()); + deserializer.Unset(); + }); + } break; + default: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + } break; + } - deserializer.Set(unshredded_type); - result.child_columns.push_back(deserializer.ReadProperty(102, "unshredded")); deserializer.Unset(); - auto shredded_type = - deserializer.ReadPropertyWithExplicitDefault(115, "shredded_type", LogicalType()); - if (shredded_type.id() == LogicalTypeId::STRUCT) { - deserializer.Set(shredded_type); - result.child_columns.push_back(deserializer.ReadProperty(120, "shredded")); - deserializer.Unset(); - result.SetVariantShreddedType(shredded_type); - } return result; } - switch (physical_type) { - case PhysicalType::ARRAY: + switch (type.InternalType()) { + case PhysicalType::BIT: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + } break; + case PhysicalType::ARRAY: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); result.DeserializeField(deserializer, 102, "child_column", ArrayType::GetChildType(type)); - break; - case PhysicalType::LIST: + } break; + case PhysicalType::LIST: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); result.DeserializeField(deserializer, 102, "child_column", ListType::GetChildType(type)); - break; + } break; case PhysicalType::STRUCT: { - auto &child_types = StructType::GetChildTypes(type); + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + const auto &child_types = StructType::GetChildTypes(type); deserializer.ReadList(102, "sub_columns", [&](Deserializer::List &list, idx_t i) { deserializer.Set(child_types[i].second); result.child_columns.push_back(list.ReadElement()); deserializer.Unset(); }); - break; - } - default: - break; + } break; + default: { + deserializer.ReadPropertyWithDefault(100, "data_pointers", result.pointers); + result.DeserializeField(deserializer, 101, "validity", LogicalTypeId::VALIDITY); + } break; } return result; } @@ -849,12 +948,6 @@ bool PersistentColumnData::HasUpdates() const { return false; } -void PersistentColumnData::SetVariantShreddedType(const LogicalType &shredded_type) { - D_ASSERT(physical_type == PhysicalType::STRUCT); - D_ASSERT(logical_type_id == LogicalTypeId::VARIANT); - variant_shredded_type = shredded_type; -} - PersistentRowGroupData::PersistentRowGroupData(vector types_p) : types(std::move(types_p)) { } @@ -906,6 +999,42 @@ bool PersistentCollectionData::HasUpdates() const { return false; } +void ExtraPersistentColumnData::Serialize(Serializer &serializer) const { + serializer.WritePropertyWithDefault(100, "type", type, ExtraPersistentColumnDataType::INVALID); + switch (GetType()) { + case ExtraPersistentColumnDataType::VARIANT: { + const auto &variant_data = Cast(); + serializer.WriteProperty(101, "storage_type", variant_data.logical_type); + } break; + case ExtraPersistentColumnDataType::GEOMETRY: { + const auto &geometry_data = Cast(); + serializer.WritePropertyWithDefault(101, "geom_type", geometry_data.geom_type, GeometryType::INVALID); + serializer.WritePropertyWithDefault(102, "vert_type", geometry_data.vert_type, VertexType::XY); + } break; + default: + throw InternalException("Unknown PersistentColumnData type"); + } +} +unique_ptr ExtraPersistentColumnData::Deserialize(Deserializer &deserializer) { + auto type = deserializer.ReadPropertyWithExplicitDefault( + 100, "type", ExtraPersistentColumnDataType::INVALID); + switch (type) { + case ExtraPersistentColumnDataType::VARIANT: { + auto storage_type = + deserializer.ReadPropertyWithExplicitDefault(101, "storage_type", LogicalType()); + return make_uniq(storage_type); + } + case ExtraPersistentColumnDataType::GEOMETRY: { + auto geom_type = + deserializer.ReadPropertyWithExplicitDefault(101, "geom_type", GeometryType::INVALID); + auto vert_type = deserializer.ReadPropertyWithExplicitDefault(102, "vert_type", VertexType::XY); + return make_uniq(geom_type, vert_type); + } + default: + throw InternalException("Unknown PersistentColumnData type"); + } +} + PersistentColumnData ColumnData::Serialize() { auto result = count ? PersistentColumnData(type, GetDataPointers()) : PersistentColumnData(type); result.has_updates = HasUpdates(); @@ -1017,11 +1146,20 @@ void ColumnData::GetColumnSegmentInfo(const QueryContext &context, idx_t row_gro void ColumnData::Verify(RowGroup &parent) { #ifdef DEBUG data.Verify(); - if (type.InternalType() == PhysicalType::STRUCT || type.InternalType() == PhysicalType::ARRAY) { + + bool is_geometry_child_column = false; + if (type.id() == LogicalTypeId::GEOMETRY && this->parent && this->parent->type.id() == LogicalTypeId::GEOMETRY) { + // Geometry child column + is_geometry_child_column = true; + } + + if (type.InternalType() == PhysicalType::STRUCT || type.InternalType() == PhysicalType::ARRAY || + (type.id() == LogicalTypeId::GEOMETRY && !is_geometry_child_column)) { // structs and fixed size lists don't have segments D_ASSERT(!data.GetRootSegment()); return; } + idx_t current_index = 0; idx_t current_start = 0; idx_t total_count = 0; @@ -1039,16 +1177,22 @@ void ColumnData::Verify(RowGroup &parent) { shared_ptr ColumnData::CreateColumn(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, const LogicalType &type, ColumnDataType data_type, optional_ptr parent) { + if (type.id() == LogicalTypeId::GEOMETRY) { + return make_shared_ptr(block_manager, info, column_index, type, data_type, parent); + } if (type.id() == LogicalTypeId::VARIANT) { return make_shared_ptr(block_manager, info, column_index, type, data_type, parent); } if (type.InternalType() == PhysicalType::STRUCT) { return make_shared_ptr(block_manager, info, column_index, type, data_type, parent); - } else if (type.InternalType() == PhysicalType::LIST) { + } + if (type.InternalType() == PhysicalType::LIST) { return make_shared_ptr(block_manager, info, column_index, type, data_type, parent); - } else if (type.InternalType() == PhysicalType::ARRAY) { + } + if (type.InternalType() == PhysicalType::ARRAY) { return make_shared_ptr(block_manager, info, column_index, type, data_type, parent); - } else if (type.id() == LogicalTypeId::VALIDITY) { + } + if (type.id() == LogicalTypeId::VALIDITY) { return make_shared_ptr(block_manager, info, column_index, data_type, parent); } return make_shared_ptr(block_manager, info, column_index, type, data_type, parent); diff --git a/src/duckdb/src/storage/table/column_data_checkpointer.cpp b/src/duckdb/src/storage/table/column_data_checkpointer.cpp index 281457cbf..8ad72f825 100644 --- a/src/duckdb/src/storage/table/column_data_checkpointer.cpp +++ b/src/duckdb/src/storage/table/column_data_checkpointer.cpp @@ -1,5 +1,7 @@ #include "duckdb/storage/table/column_data_checkpointer.hpp" + #include "duckdb/main/config.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/storage/table/update_segment.hpp" #include "duckdb/storage/data_table.hpp" #include "duckdb/parser/column_definition.hpp" @@ -168,9 +170,11 @@ vector ColumnDataCheckpointer::DetectBestCompressionMet if (compression_type != CompressionType::COMPRESSION_AUTO) { forced_methods[i] = ForceCompression(storage_manager, functions, compression_type); } - if (compression_type == CompressionType::COMPRESSION_AUTO && - config.options.force_compression != CompressionType::COMPRESSION_AUTO) { - forced_methods[i] = ForceCompression(storage_manager, functions, config.options.force_compression); + if (compression_type == CompressionType::COMPRESSION_AUTO) { + auto force_compression = Settings::Get(config); + if (force_compression != CompressionType::COMPRESSION_AUTO) { + forced_methods[i] = ForceCompression(storage_manager, functions, force_compression); + } } } diff --git a/src/duckdb/src/storage/table/column_segment.cpp b/src/duckdb/src/storage/table/column_segment.cpp index 8589c5e64..bdd9f9156 100644 --- a/src/duckdb/src/storage/table/column_segment.cpp +++ b/src/duckdb/src/storage/table/column_segment.cpp @@ -70,7 +70,7 @@ ColumnSegment::ColumnSegment(DatabaseInstance &db, shared_ptr block } // For constant segments (CompressionType::COMPRESSION_CONSTANT) the block is a nullptr. - D_ASSERT(!block || segment_size <= GetBlockManager().GetBlockSize()); + D_ASSERT(!block || segment_size <= GetBlockSize()); } ColumnSegment::ColumnSegment(ColumnSegment &other) @@ -79,7 +79,7 @@ ColumnSegment::ColumnSegment(ColumnSegment &other) block(std::move(other.block)), function(other.function), block_id(other.block_id), offset(other.offset), segment_size(other.segment_size), segment_state(std::move(other.segment_state)) { // For constant segments (CompressionType::COMPRESSION_CONSTANT) the block is a nullptr. - D_ASSERT(!block || segment_size <= GetBlockManager().GetBlockSize()); + D_ASSERT(!block || segment_size <= GetBlockSize()); } ColumnSegment::~ColumnSegment() { @@ -165,7 +165,7 @@ idx_t ColumnSegment::SegmentSize() const { void ColumnSegment::Resize(idx_t new_size) { D_ASSERT(new_size > segment_size); D_ASSERT(offset == 0); - D_ASSERT(block && new_size <= GetBlockManager().GetBlockSize()); + D_ASSERT(block && new_size <= GetBlockSize()); auto &buffer_manager = BufferManager::GetBufferManager(db); auto old_handle = buffer_manager.Pin(block); diff --git a/src/duckdb/src/storage/table/geo_column_data.cpp b/src/duckdb/src/storage/table/geo_column_data.cpp new file mode 100644 index 000000000..d1c67a57e --- /dev/null +++ b/src/duckdb/src/storage/table/geo_column_data.cpp @@ -0,0 +1,531 @@ +#include "duckdb/storage/table/geo_column_data.hpp" +#include "duckdb/storage/table/standard_column_data.hpp" + +#include "duckdb/storage/statistics/struct_stats.hpp" +#include "duckdb/common/serializer/serializer.hpp" +#include "duckdb/common/serializer/deserializer.hpp" +#include "duckdb/common/vector_operations/generic_executor.hpp" +#include "duckdb/storage/statistics/list_stats.hpp" +#include "duckdb/storage/table/append_state.hpp" +#include "duckdb/storage/table/scan_state.hpp" +#include "duckdb/storage/table/column_checkpoint_state.hpp" +#include "duckdb/main/settings.hpp" + +namespace duckdb { + +//---------------------------------------------------------------------------------------------------------------------- +// GeoColumnData +//---------------------------------------------------------------------------------------------------------------------- +// TODO: Override ::Filter to push down bounding box filters. + +GeoColumnData::GeoColumnData(BlockManager &block_manager, DataTableInfo &info, idx_t column_index, LogicalType type_p, + ColumnDataType data_type, optional_ptr parent) + : ColumnData(block_manager, info, column_index, std::move(type_p), data_type, parent) { + if (data_type != ColumnDataType::CHECKPOINT_TARGET) { + base_column = make_shared_ptr(block_manager, info, column_index, type, data_type, this); + } +} + +//---------------------------------------------------------------------------------------------------------------------- +// Scan +//---------------------------------------------------------------------------------------------------------------------- + +void GeoColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { + return base_column->InitializePrefetch(prefetch_state, scan_state, rows); +} + +void GeoColumnData::InitializeChildScanStates(ColumnScanState &state) { + // Reset, inner layout might be different + state.child_states.clear(); + + // Initialize using the type of the base column + state.Initialize(state.context, base_column->type, state.scan_options); +} + +void GeoColumnData::InitializeScan(ColumnScanState &state) { + InitializeChildScanStates(state); + return base_column->InitializeScan(state); +} + +void GeoColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) { + InitializeChildScanStates(state); + return base_column->InitializeScanWithOffset(state, row_idx); +} + +idx_t GeoColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, + idx_t target_count) { + auto &layout_type = base_column->GetType(); + + // Not a shredded column, so just emit the binary format immediately + if (layout_type.id() == LogicalTypeId::GEOMETRY) { + return base_column->Scan(transaction, vector_index, state, result, target_count); + } + + // Setup an intermediate chunk to scan the actual data, based on how much we actually scanned + // TODO: Put this in a scan state? + DataChunk scan_chunk; + scan_chunk.Initialize(Allocator::DefaultAllocator(), {layout_type}, target_count); + + const auto scan_count = base_column->Scan(transaction, vector_index, state, scan_chunk.data[0], target_count); + + // Now reassemble + Reassemble(scan_chunk.data[0], result, scan_count, geom_type, vert_type, 0); + return scan_count; +} + +idx_t GeoColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t target_count, idx_t result_offset) { + auto &layout_type = base_column->GetType(); + + // Not a shredded column, so just emit the binary format immediately + if (layout_type.id() == LogicalTypeId::GEOMETRY) { + return base_column->ScanCount(state, result, target_count, result_offset); + } + + // Setup an intermediate chunk to scan the actual data, based on how much we actually scanned + // TODO: Put this in a scan state + DataChunk scan_chunk; + scan_chunk.Initialize(Allocator::DefaultAllocator(), {layout_type}, target_count); + + const auto scan_count = base_column->ScanCount(state, scan_chunk.data[0], target_count, 0); + + // Now reassemble + Reassemble(scan_chunk.data[0], result, scan_count, geom_type, vert_type, result_offset); + return scan_count; +} + +void GeoColumnData::Skip(ColumnScanState &state, idx_t count) { + return base_column->Skip(state, count); +} + +//---------------------------------------------------------------------------------------------------------------------- +// Append +//---------------------------------------------------------------------------------------------------------------------- + +void GeoColumnData::InitializeAppend(ColumnAppendState &state) { + base_column->InitializeAppend(state); +} +void GeoColumnData::Append(BaseStatistics &stats, ColumnAppendState &state, Vector &vector, idx_t add_count) { + base_column->Append(stats, state, vector, add_count); + count += add_count; +} +void GeoColumnData::RevertAppend(row_t new_count) { + base_column->RevertAppend(new_count); + count = UnsafeNumericCast(new_count); +} + +//---------------------------------------------------------------------------------------------------------------------- +// Fetch +//---------------------------------------------------------------------------------------------------------------------- + +idx_t GeoColumnData::Fetch(ColumnScanState &state, row_t row_id, Vector &result) { + auto &layout_type = base_column->GetType(); + + // Not a shredded column, so just emit the binary format immediately + if (layout_type.id() == LogicalTypeId::GEOMETRY) { + return base_column->Fetch(state, row_id, result); + } + + // Otherwise, we need to fetch and reassemble + DataChunk chunk; + chunk.Initialize(Allocator::DefaultAllocator(), {layout_type}, 1); + + const auto fetch_count = base_column->Fetch(state, row_id, chunk.data[0]); + + Reassemble(chunk.data[0], result, fetch_count, geom_type, vert_type, 0); + + return fetch_count; +} + +void GeoColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, const StorageIndex &storage_index, + row_t row_id, Vector &result, idx_t result_idx) { + auto &layout_type = base_column->GetType(); + + // Not a shredded column, so just emit the binary format immediately + if (layout_type.id() == LogicalTypeId::GEOMETRY) { + return base_column->FetchRow(transaction, state, storage_index, row_id, result, result_idx); + } + + // Otherwise, we need to fetch and reassemble + DataChunk chunk; + chunk.Initialize(Allocator::DefaultAllocator(), {layout_type}, 1); + + base_column->FetchRow(transaction, state, storage_index, row_id, chunk.data[0], 0); + + Reassemble(chunk.data[0], result, 1, geom_type, vert_type, result_idx); +} + +//---------------------------------------------------------------------------------------------------------------------- +// Update +//---------------------------------------------------------------------------------------------------------------------- + +void GeoColumnData::Update(TransactionData transaction, DataTable &data_table, idx_t column_index, + Vector &update_vector, row_t *row_ids, idx_t update_count, idx_t row_group_start) { + return base_column->Update(transaction, data_table, column_index, update_vector, row_ids, update_count, + row_group_start); +} +void GeoColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table, + const vector &column_path, Vector &update_vector, row_t *row_ids, + idx_t update_count, idx_t depth, idx_t row_group_start) { + return base_column->UpdateColumn(transaction, data_table, column_path, update_vector, row_ids, update_count, depth, + row_group_start); +} + +unique_ptr GeoColumnData::GetUpdateStatistics() { + return base_column->GetUpdateStatistics(); +} + +//---------------------------------------------------------------------------------------------------------------------- +// Checkpoint +//---------------------------------------------------------------------------------------------------------------------- + +class GeoColumnCheckpointState final : public ColumnCheckpointState { +public: + GeoColumnCheckpointState(const RowGroup &row_group, ColumnData &column_data, + PartialBlockManager &partial_block_manager) + : ColumnCheckpointState(row_group, column_data, partial_block_manager) { + // Make stats + global_stats = GeometryStats::CreateEmpty(column_data.type).ToUnique(); + + // Also pass on the shredding state + const auto &geo_column = column_data.Cast(); + geom_type = geo_column.geom_type; + vert_type = geo_column.vert_type; + } + + // Shared pointer to the new/old inner column. + // This is never actually used here, but needs to stay alive + // for as long as the checkpoint state, hence the shared_ptr. + shared_ptr inner_column; + + // The checkpoint state for the inner column. + unique_ptr inner_column_state; + + GeometryType geom_type = GeometryType::INVALID; + VertexType vert_type = VertexType::XY; + + shared_ptr CreateEmptyColumnData() override { + auto new_column = make_shared_ptr( + original_column.GetBlockManager(), original_column.GetTableInfo(), original_column.column_index, + original_column.type, ColumnDataType::CHECKPOINT_TARGET, nullptr); + return std::move(new_column); + } + + shared_ptr GetFinalResult() override { + if (!result_column) { + result_column = CreateEmptyColumnData(); + } + + auto &column_data = result_column->Cast(); + + auto new_inner = inner_column_state->GetFinalResult(); + new_inner->SetParent(column_data); + column_data.base_column = std::move(new_inner); + + // Pass on the shredding state too + column_data.geom_type = geom_type; + column_data.vert_type = vert_type; + + return ColumnCheckpointState::GetFinalResult(); + } + + unique_ptr GetStatistics() override { + D_ASSERT(global_stats); + return std::move(global_stats); + } + + PersistentColumnData ToPersistentData() override { + auto inner_data = inner_column_state->ToPersistentData(); + + // If this is a shredded column, record it in the persistent data! + if (geom_type != GeometryType::INVALID) { + auto extra_data = make_uniq(); + extra_data->geom_type = geom_type; + extra_data->vert_type = vert_type; + inner_data.extra_data = std::move(extra_data); + } + + return inner_data; + } +}; + +unique_ptr GeoColumnData::CreateCheckpointState(const RowGroup &row_group, + PartialBlockManager &partial_block_manager) { + return make_uniq(row_group, *this, partial_block_manager); +} + +unique_ptr GeoColumnData::Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) { + auto &partial_block_manager = info.GetPartialBlockManager(); + auto checkpoint_state = make_uniq(row_group, *this, partial_block_manager); + + auto &old_column_stats = + base_column->GetType().id() == LogicalTypeId::GEOMETRY ? old_stats : base_column->GetStatisticsRef(); + + // Are there any changes? + if (!HasAnyChanges()) { + // No changes, keep column + checkpoint_state->inner_column = base_column; + checkpoint_state->inner_column_state = + checkpoint_state->inner_column->Checkpoint(row_group, info, old_column_stats); + return std::move(checkpoint_state); + } + + // Do we have enough rows to consider shredding? + auto &table_info = row_group.GetTableInfo(); + auto &db = table_info.GetDB(); + + const auto shredding_threshold = Settings::Get(DBConfig::Get(db)); + const auto current_row_count = count.load(); + + auto should_shred = shredding_threshold >= 0 && current_row_count >= static_cast(shredding_threshold); + if (!should_shred) { + // Keep column + checkpoint_state->inner_column = base_column; + checkpoint_state->inner_column_state = + checkpoint_state->inner_column->Checkpoint(row_group, info, old_column_stats); + checkpoint_state->global_stats = checkpoint_state->inner_column_state->GetStatistics(); + return std::move(checkpoint_state); + } + + // Figure out if this segment can use an alternative type layout + auto new_geom_type = GeometryType::POINT; + auto new_vert_type = VertexType::XY; + + const auto &types = GeometryStats::GetTypes(old_stats); + const auto &flags = GeometryStats::GetFlags(old_stats); + + auto has_mixed_type = !types.TryGetSingleType(new_geom_type, new_vert_type); + auto has_only_geometry_collection = new_geom_type == GeometryType::GEOMETRYCOLLECTION; + auto has_only_invalid = new_geom_type == GeometryType::INVALID; + + // We cant specialize empty geometries, because we cant represent zero-vertex geometries in those layouts + const auto has_empty = flags.HasEmptyGeometry() || flags.HasEmptyPart(); + + if (has_mixed_type || has_only_geometry_collection || has_only_invalid || has_empty) { + // Cant specialize, keep column + checkpoint_state->inner_column = base_column; + checkpoint_state->inner_column_state = + checkpoint_state->inner_column->Checkpoint(row_group, info, old_column_stats); + checkpoint_state->global_stats = checkpoint_state->inner_column_state->GetStatistics(); + return std::move(checkpoint_state); + } + + auto new_type = Geometry::GetVectorizedType(new_geom_type, new_vert_type); + + auto new_column = CreateColumn(block_manager, this->info, base_column->column_index, new_type, GetDataType(), this); + + // Setup scan from the old column + DataChunk scan_chunk; + ColumnScanState scan_state(nullptr); + scan_chunk.Initialize(Allocator::DefaultAllocator(), {base_column->type}, STANDARD_VECTOR_SIZE); + InitializeScan(scan_state); + + // Setup append to the new column + DataChunk append_chunk; + ColumnAppendState append_state; + append_chunk.Initialize(Allocator::DefaultAllocator(), {new_column->type}, STANDARD_VECTOR_SIZE); + new_column->InitializeAppend(append_state); + + idx_t total_count = count.load(); + idx_t vector_index = 0; + + for (idx_t scanned = 0; scanned < total_count; scanned += STANDARD_VECTOR_SIZE) { + scan_chunk.Reset(); + + auto to_scan = MinValue(total_count - scanned, static_cast(STANDARD_VECTOR_SIZE)); + Scan(TransactionData::Committed(), vector_index++, scan_state, scan_chunk.data[0], to_scan); + + // Verify the scan chunk + scan_chunk.Verify(); + + append_chunk.Reset(); + append_chunk.SetCardinality(to_scan); + + // Make the split + Specialize(scan_chunk.data[0], append_chunk.data[0], to_scan, new_geom_type, new_vert_type); + + // Append into the new specialized column + auto dummy_stats = BaseStatistics::CreateEmpty(new_column->GetType()); + new_column->Append(dummy_stats, append_state, append_chunk.data[0], to_scan); + + // Merge the stats into the checkpoint state's global stats + InterpretStats(dummy_stats, *checkpoint_state->global_stats, new_geom_type, new_vert_type); + } + + // Move then new column into our checkpoint state + auto empty_stats = BaseStatistics::CreateEmpty(new_column->GetType()); + checkpoint_state->inner_column = new_column; + checkpoint_state->inner_column_state = checkpoint_state->inner_column->Checkpoint(row_group, info, empty_stats); + + // Also set the shredding state + checkpoint_state->geom_type = new_geom_type; + checkpoint_state->vert_type = new_vert_type; + + return std::move(checkpoint_state); +} + +bool GeoColumnData::IsPersistent() { + return base_column->IsPersistent(); +} + +bool GeoColumnData::HasAnyChanges() const { + return base_column->HasAnyChanges(); +} + +PersistentColumnData GeoColumnData::Serialize() { + // Serialize the inner column + auto inner_data = base_column->Serialize(); + + // If this is a shredded column, record it in the persistent data! + if (geom_type != GeometryType::INVALID) { + auto extra_data = make_uniq(); + extra_data->geom_type = geom_type; + extra_data->vert_type = vert_type; + inner_data.extra_data = std::move(extra_data); + } + + return inner_data; +} + +void GeoColumnData::InitializeColumn(PersistentColumnData &column_data, BaseStatistics &target_stats) { + if (!column_data.extra_data) { + // No shredding, just initialize normally + base_column->InitializeColumn(column_data, target_stats); + count = base_column->count.load(); + return; + } + + auto &geom_data = column_data.extra_data->Cast(); + + // Set the shredding state + vert_type = geom_data.vert_type; + geom_type = geom_data.geom_type; + + // Else, this is a shredded point + const auto layout_type = Geometry::GetVectorizedType(geom_type, vert_type); + base_column = CreateColumn(block_manager, info, base_column->column_index, layout_type, GetDataType(), this); + D_ASSERT(base_column != nullptr); + + auto dummy_stats = BaseStatistics::CreateEmpty(layout_type); + base_column->InitializeColumn(column_data, dummy_stats); + count = base_column->count.load(); + + // Interpret the stats + InterpretStats(dummy_stats, target_stats, geom_type, vert_type); +} + +//---------------------------------------------------------------------------------------------------------------------- +// Misc +//---------------------------------------------------------------------------------------------------------------------- + +idx_t GeoColumnData::GetMaxEntry() { + return base_column->GetMaxEntry(); +} + +void GeoColumnData::GetColumnSegmentInfo(const QueryContext &context, idx_t row_group_index, vector col_path, + vector &result) { + return base_column->GetColumnSegmentInfo(context, row_group_index, col_path, result); +} + +void GeoColumnData::Verify(RowGroup &parent) { + return base_column->Verify(parent); +} + +void GeoColumnData::VisitBlockIds(BlockIdVisitor &visitor) const { + return base_column->VisitBlockIds(visitor); +} + +//---------------------------------------------------------------------------------------------------------------------- +// Specialize +//---------------------------------------------------------------------------------------------------------------------- +void GeoColumnData::Specialize(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + VertexType vert_type) { + Geometry::ToVectorizedFormat(source, target, count, geom_type, vert_type); +} + +void GeoColumnData::Reassemble(Vector &source, Vector &target, idx_t count, GeometryType geom_type, + VertexType vert_type, idx_t result_offset) { + Geometry::FromVectorizedFormat(source, target, count, geom_type, vert_type, result_offset); +} + +static const BaseStatistics *GetVertexStats(BaseStatistics &stats, GeometryType geom_type) { + switch (geom_type) { + case GeometryType::POINT: { + return StructStats::GetChildStats(stats); + } + case GeometryType::LINESTRING: { + const auto &line_stats = ListStats::GetChildStats(stats); + return StructStats::GetChildStats(line_stats); + } + case GeometryType::POLYGON: { + const auto &poly_stats = ListStats::GetChildStats(stats); + const auto &ring_stats = ListStats::GetChildStats(poly_stats); + return StructStats::GetChildStats(ring_stats); + } + case GeometryType::MULTIPOINT: { + const auto &mpoint_stats = ListStats::GetChildStats(stats); + return StructStats::GetChildStats(mpoint_stats); + } + case GeometryType::MULTILINESTRING: { + const auto &mline_stats = ListStats::GetChildStats(stats); + const auto &line_stats = ListStats::GetChildStats(mline_stats); + return StructStats::GetChildStats(line_stats); + } + case GeometryType::MULTIPOLYGON: { + const auto &mpoly_stats = ListStats::GetChildStats(stats); + const auto &poly_stats = ListStats::GetChildStats(mpoly_stats); + const auto &ring_stats = ListStats::GetChildStats(poly_stats); + return StructStats::GetChildStats(ring_stats); + } + default: + throw NotImplementedException("Unsupported geometry type %d for interpreting stats", + static_cast(geom_type)); + } +} + +void GeoColumnData::InterpretStats(BaseStatistics &source, BaseStatistics &target, GeometryType geom_type, + VertexType vert_type) { + // Copy base stats + target.CopyBase(source); + + // Extract vertex stats + const auto vert_stats = GetVertexStats(source, geom_type); + auto &extent = GeometryStats::GetExtent(target); + extent.x_min = NumericStats::GetMin(vert_stats[0]); + extent.x_max = NumericStats::GetMax(vert_stats[0]); + extent.y_min = NumericStats::GetMin(vert_stats[1]); + extent.y_max = NumericStats::GetMax(vert_stats[1]); + + switch (vert_type) { + case VertexType::XYZ: + extent.z_min = NumericStats::GetMin(vert_stats[2]); + extent.z_max = NumericStats::GetMax(vert_stats[2]); + break; + case VertexType::XYM: + extent.m_min = NumericStats::GetMin(vert_stats[2]); + extent.m_max = NumericStats::GetMax(vert_stats[2]); + break; + case VertexType::XYZM: + extent.z_min = NumericStats::GetMin(vert_stats[2]); + extent.z_max = NumericStats::GetMax(vert_stats[2]); + extent.m_min = NumericStats::GetMin(vert_stats[3]); + extent.m_max = NumericStats::GetMax(vert_stats[3]); + break; + default: + // Nothing to do + break; + } + + // Set types + auto &types = GeometryStats::GetTypes(target); + types.Clear(); + types.Add(geom_type, vert_type); + + // Also set non-empty flag + auto &geo_flags = GeometryStats::GetFlags(target); + geo_flags.Clear(); + geo_flags.SetHasNonEmptyGeometry(); + geo_flags.SetHasNonEmptyPart(); +} + +} // namespace duckdb diff --git a/src/duckdb/src/storage/table/list_column_data.cpp b/src/duckdb/src/storage/table/list_column_data.cpp index cbf65a0f4..13b0fa691 100644 --- a/src/duckdb/src/storage/table/list_column_data.cpp +++ b/src/duckdb/src/storage/table/list_column_data.cpp @@ -326,6 +326,14 @@ void ListColumnData::VisitBlockIds(BlockIdVisitor &visitor) const { child_column->VisitBlockIds(visitor); } +const BaseStatistics &ListColumnData::GetChildStats(const ColumnData &child) const { + if (!RefersToSameObject(child, *child_column)) { + throw InternalException("ListColumnData::GetChildStats provided column data is not a child of this list"); + } + auto &stats = GetStatisticsRef(); + return ListStats::GetChildStats(stats); +} + void ListColumnData::SetValidityData(shared_ptr validity_p) { if (validity) { throw InternalException("ListColumnData::SetValidityData cannot be used to overwrite existing validity"); @@ -390,10 +398,11 @@ unique_ptr ListColumnData::CreateCheckpointState(const Ro } unique_ptr ListColumnData::Checkpoint(const RowGroup &row_group, - ColumnCheckpointInfo &checkpoint_info) { - auto base_state = ColumnData::Checkpoint(row_group, checkpoint_info); - auto validity_state = validity->Checkpoint(row_group, checkpoint_info); - auto child_state = child_column->Checkpoint(row_group, checkpoint_info); + ColumnCheckpointInfo &checkpoint_info, + const BaseStatistics &old_stats) { + auto base_state = ColumnData::Checkpoint(row_group, checkpoint_info, old_stats); + auto validity_state = validity->Checkpoint(row_group, checkpoint_info, old_stats); + auto child_state = child_column->Checkpoint(row_group, checkpoint_info, ListStats::GetChildStats(old_stats)); auto &checkpoint_state = base_state->Cast(); checkpoint_state.validity_state = std::move(validity_state); diff --git a/src/duckdb/src/storage/table/row_group.cpp b/src/duckdb/src/storage/table/row_group.cpp index b0650b994..b57a74906 100644 --- a/src/duckdb/src/storage/table/row_group.cpp +++ b/src/duckdb/src/storage/table/row_group.cpp @@ -187,16 +187,18 @@ void RowGroup::InitializeEmpty(const vector &types, ColumnDataType } } -static unique_ptr CreateCast(ClientContext &context, const LogicalType &original_type, - const LogicalType &cast_type) { - auto input = make_uniq(original_type, 0U); - auto cast_expression = BoundCastExpression::AddCastToType(context, std::move(input), cast_type); - auto res = make_uniq(context); - res->target.Initialize(context, {cast_type}); - res->input.Initialize(context, {original_type}); - res->executor.AddExpression(*cast_expression); - res->expression = std::move(cast_expression); - return res; +void ColumnScanState::PushDownCast(const LogicalType &original_type, const LogicalType &cast_type) { + D_ASSERT(context.Valid()); + D_ASSERT(!expression_state); + auto &client_context = *context.GetClientContext(); + + auto input = make_uniq(original_type, 0ULL); + auto cast_expression = BoundCastExpression::AddCastToType(client_context, std::move(input), cast_type); + expression_state = make_uniq(client_context); + expression_state->target.Initialize(client_context, {cast_type}); + expression_state->input.Initialize(client_context, {original_type}); + expression_state->executor.AddExpression(*cast_expression); + expression_state->expression = std::move(cast_expression); } void ColumnScanState::Initialize(const QueryContext &context_p, const LogicalType &type, const StorageIndex &column_id, @@ -217,6 +219,13 @@ void ColumnScanState::Initialize(const QueryContext &context_p, const LogicalTyp // variant - column scan states are created later // this is done because the internal shape of the VARIANT is different per rowgroup scan_child_column.resize(2, true); + if (!storage_index.IsPushdownExtract()) { + return; + } + auto &scan_type = storage_index.GetScanType(); + if (scan_type.id() != LogicalTypeId::VARIANT) { + PushDownCast(type, scan_type); + } return; } @@ -244,7 +253,7 @@ void ColumnScanState::Initialize(const QueryContext &context_p, const LogicalTyp auto child_index = child.GetPrimaryIndex(); auto &child_type = StructType::GetChildTypes(type)[child_index].second; if (!child.HasChildren() && child_type != child.GetType()) { - expression_state = CreateCast(*context.GetClientContext(), child_type, child.GetType()); + PushDownCast(child_type, child.GetType()); } child_states[1].Initialize(context, struct_children[child_index].second, child, options); } else { @@ -1178,7 +1187,7 @@ const vector &RowGroup::GetColumnStartPointers() const { } RowGroupWriteData RowGroup::WriteToDisk(RowGroupWriter &writer) { - if (DBConfig::GetSetting(writer.GetDatabase()) && !column_pointers.empty() && + if (Settings::Get(writer.GetDatabase()) && !column_pointers.empty() && !HasChanges()) { // we have existing metadata and the row group has not been changed // re-use previous metadata diff --git a/src/duckdb/src/storage/table/row_group_collection.cpp b/src/duckdb/src/storage/table/row_group_collection.cpp index 66f6d3fec..9716711d5 100644 --- a/src/duckdb/src/storage/table/row_group_collection.cpp +++ b/src/duckdb/src/storage/table/row_group_collection.cpp @@ -227,7 +227,7 @@ void RowGroupCollection::InitializeScanWithOffset(const QueryContext &context, C } } -bool RowGroupCollection::InitializeScanInRowGroup(const QueryContext &context, CollectionScanState &state, +bool RowGroupCollection::InitializeScanInRowGroup(ClientContext &context, CollectionScanState &state, RowGroupCollection &collection, SegmentNode &row_group, idx_t vector_index, idx_t max_row) { state.max_row = max_row; @@ -1394,7 +1394,7 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl try { // schedule tasks idx_t total_vacuum_tasks = 0; - auto max_vacuum_tasks = DBConfig::GetSetting(writer.GetDatabase()); + auto max_vacuum_tasks = Settings::Get(writer.GetDatabase()); for (idx_t segment_idx = 0; segment_idx < checkpoint_state.SegmentCount(); segment_idx++) { auto vacuum_tasks = ScheduleVacuumTasks(checkpoint_state, vacuum_state, segment_idx, total_vacuum_tasks < max_vacuum_tasks); @@ -1432,7 +1432,7 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl // no errors - finalize the row groups // if the table already exists on disk - check if all row groups have stayed the same - if (DBConfig::GetSetting(writer.GetDatabase()) && metadata_pointer.IsValid()) { + if (Settings::Get(writer.GetDatabase()) && metadata_pointer.IsValid()) { bool table_has_changes = false; for (idx_t segment_idx = 0; segment_idx < checkpoint_state.SegmentCount(); segment_idx++) { if (checkpoint_state.SegmentIsDropped(segment_idx)) { @@ -1511,7 +1511,7 @@ void RowGroupCollection::Checkpoint(TableDataWriter &writer, TableStatistics &gl new_row_group = entry->ReferenceNode(); } RowGroupPointer pointer_copy; - auto debug_verify_blocks = DBConfig::GetSetting(GetAttached().GetDatabase()) && + auto debug_verify_blocks = Settings::Get(GetAttached().GetDatabase()) && dynamic_cast(&checkpoint_state.writer) != nullptr; // check if we should write this row group to the persistent storage diff --git a/src/duckdb/src/storage/table/row_id_column_data.cpp b/src/duckdb/src/storage/table/row_id_column_data.cpp index 235244c19..0c648892b 100644 --- a/src/duckdb/src/storage/table/row_id_column_data.cpp +++ b/src/duckdb/src/storage/table/row_id_column_data.cpp @@ -155,7 +155,8 @@ unique_ptr RowIdColumnData::CreateCheckpointState(const R throw InternalException("RowIdColumnData cannot be checkpointed"); } -unique_ptr RowIdColumnData::Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info) { +unique_ptr RowIdColumnData::Checkpoint(const RowGroup &row_group, ColumnCheckpointInfo &info, + const BaseStatistics &old_stats) { throw InternalException("RowIdColumnData cannot be checkpointed"); } diff --git a/src/duckdb/src/storage/table/standard_column_data.cpp b/src/duckdb/src/storage/table/standard_column_data.cpp index 0f84aa0b8..7969657a9 100644 --- a/src/duckdb/src/storage/table/standard_column_data.cpp +++ b/src/duckdb/src/storage/table/standard_column_data.cpp @@ -124,11 +124,17 @@ void StandardColumnData::InitializeAppend(ColumnAppendState &state) { void StandardColumnData::AppendData(BaseStatistics &stats, ColumnAppendState &state, UnifiedVectorFormat &vdata, idx_t count) { + const lock_guard standard_guard(update_lock); + const lock_guard validity_guard(validity->update_lock); + ColumnData::AppendData(stats, state, vdata, count); validity->AppendData(stats, state.child_appends[0], vdata, count); } void StandardColumnData::RevertAppend(row_t new_count) { + const lock_guard standard_guard(update_lock); + const lock_guard validity_guard(validity->update_lock); + ColumnData::RevertAppend(new_count); validity->RevertAppend(new_count); } @@ -150,16 +156,27 @@ void StandardColumnData::Update(TransactionData transaction, DataTable &data_tab ColumnScanState standard_state(nullptr); ColumnScanState validity_state(nullptr); Vector base_vector(type); + + const unique_lock standard_lock(update_lock); + const unique_lock validity_lock(validity->update_lock); + auto standard_fetch = FetchUpdateData(standard_state, row_ids, base_vector, row_group_start); auto validity_fetch = validity->FetchUpdateData(validity_state, row_ids, base_vector, row_group_start); if (standard_fetch != validity_fetch) { throw InternalException("Unaligned fetch in validity and main column data for update"); } - UpdateInternal(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector, - row_group_start); - validity->UpdateInternal(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector, - row_group_start); + if (!updates) { + updates = make_uniq(*this); + } + if (!validity->updates) { + validity->updates = make_uniq(*validity); + } + + updates->Update(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector, + row_group_start); + validity->updates->Update(transaction, data_table, column_index, update_vector, row_ids, update_count, base_vector, + row_group_start); } void StandardColumnData::UpdateColumn(TransactionData transaction, DataTable &data_table, @@ -260,7 +277,8 @@ StandardColumnData::CreateCheckpointState(const RowGroup &row_group, PartialBloc } unique_ptr StandardColumnData::Checkpoint(const RowGroup &row_group, - ColumnCheckpointInfo &checkpoint_info) { + ColumnCheckpointInfo &checkpoint_info, + const BaseStatistics &stats) { // we need to checkpoint the main column data first // that is because the checkpointing of the main column data ALSO scans the validity data // to prevent reading the validity data immediately after it is checkpointed we first checkpoint the main column diff --git a/src/duckdb/src/storage/table/struct_column_data.cpp b/src/duckdb/src/storage/table/struct_column_data.cpp index 7d134f60c..0ab6ab90e 100644 --- a/src/duckdb/src/storage/table/struct_column_data.cpp +++ b/src/duckdb/src/storage/table/struct_column_data.cpp @@ -48,9 +48,8 @@ idx_t StructColumnData::GetMaxEntry() { return sub_columns[0]->GetMaxEntry(); } -void StructColumnData::IterateFields( - ColumnScanState &state, - const std::function &callback) { +vector StructColumnData::GetStructChildren(ColumnScanState &state) const { + vector res; if (state.storage_index.IsPushdownExtract()) { auto &index_children = state.storage_index.GetChildIndexes(); D_ASSERT(index_children.size() == 1); @@ -58,25 +57,25 @@ void StructColumnData::IterateFields( auto child_index = child_storage_index.GetPrimaryIndex(); auto &field_state = state.child_states[1]; D_ASSERT(state.scan_child_column[0]); - callback(child_index, optional_idx(), field_state, true); + res.emplace_back(*sub_columns[child_index], optional_idx(), field_state, true); } else { for (idx_t i = 0; i < sub_columns.size(); i++) { auto &field_state = state.child_states[1 + i]; - callback(i, i, field_state, state.scan_child_column[i]); + res.emplace_back(*sub_columns[i], i, field_state, state.scan_child_column[i]); } } + return res; } void StructColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { validity->InitializePrefetch(prefetch_state, scan_state.child_states[0], rows); - IterateFields(scan_state, [&](idx_t child_index, optional_idx field_vector_index, ColumnScanState &field_state, - bool should_scan) { - if (!should_scan) { - return; + auto struct_children = GetStructChildren(scan_state); + for (auto &child : struct_children) { + if (!child.should_scan) { + continue; } - auto &field = *sub_columns[child_index]; - field.InitializePrefetch(prefetch_state, field_state, rows); - }); + child.col.InitializePrefetch(prefetch_state, child.state, rows); + } } void StructColumnData::InitializeScan(ColumnScanState &state) { @@ -87,14 +86,13 @@ void StructColumnData::InitializeScan(ColumnScanState &state) { validity->InitializeScan(state.child_states[0]); // initialize the sub-columns - IterateFields( - state, [&](idx_t child_index, optional_idx field_vector_index, ColumnScanState &field_state, bool should_scan) { - if (!should_scan) { - return; - } - auto &field = *sub_columns[child_index]; - field.InitializeScan(field_state); - }); + auto struct_children = GetStructChildren(state); + for (auto &child : struct_children) { + if (!child.should_scan) { + continue; + } + child.col.InitializeScan(child.state); + } } void StructColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_idx) { @@ -106,14 +104,13 @@ void StructColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t ro validity->InitializeScanWithOffset(state.child_states[0], row_idx); // initialize the sub-columns - IterateFields( - state, [&](idx_t child_index, optional_idx field_vector_index, ColumnScanState &field_state, bool should_scan) { - if (!should_scan) { - return; - } - auto &field = *sub_columns[child_index]; - field.InitializeScanWithOffset(field_state, row_idx); - }); + auto struct_children = GetStructChildren(state); + for (auto &child : struct_children) { + if (!child.should_scan) { + continue; + } + child.col.InitializeScanWithOffset(child.state, row_idx); + } } static Vector &GetFieldVectorForScan(Vector &result, optional_idx field_index) { @@ -148,39 +145,38 @@ static void ScanChild(ColumnScanState &state, Vector &result, const std::functio idx_t StructColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, idx_t target_count) { auto scan_count = validity->Scan(transaction, vector_index, state.child_states[0], result, target_count); - IterateFields( - state, [&](idx_t child_index, optional_idx field_vector_index, ColumnScanState &field_state, bool should_scan) { - auto &target_vector = GetFieldVectorForScan(result, field_vector_index); - if (!should_scan) { - // if we are not scanning this vector - set it to NULL - target_vector.SetVectorType(VectorType::CONSTANT_VECTOR); - ConstantVector::SetNull(target_vector, true); - return; - } - auto &field = *sub_columns[child_index]; - ScanChild(state, target_vector, [&](Vector &child_result) { - return field.Scan(transaction, vector_index, field_state, child_result, target_count); - }); - }); + auto struct_children = GetStructChildren(state); + for (auto &child : struct_children) { + auto &target_vector = GetFieldVectorForScan(result, child.vector_index); + if (!child.should_scan) { + // if we are not scanning this vector - set it to NULL + target_vector.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(target_vector, true); + continue; + } + ScanChild(state, target_vector, [&](Vector &child_result) { + return child.col.Scan(transaction, vector_index, child.state, child_result, target_count); + }); + } return scan_count; } idx_t StructColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count, idx_t result_offset) { auto scan_count = validity->ScanCount(state.child_states[0], result, count); - IterateFields( - state, [&](idx_t child_index, optional_idx field_vector_index, ColumnScanState &field_state, bool should_scan) { - auto &target_vector = GetFieldVectorForScan(result, field_vector_index); - if (!should_scan) { - // if we are not scanning this vector - set it to NULL - target_vector.SetVectorType(VectorType::CONSTANT_VECTOR); - ConstantVector::SetNull(target_vector, true); - return; - } - auto &field = *sub_columns[child_index]; - ScanChild(state, target_vector, [&](Vector &child_result) { - return field.ScanCount(field_state, child_result, count, result_offset); - }); - }); + + auto struct_children = GetStructChildren(state); + for (auto &child : struct_children) { + auto &target_vector = GetFieldVectorForScan(result, child.vector_index); + if (!child.should_scan) { + // if we are not scanning this vector - set it to NULL + target_vector.SetVectorType(VectorType::CONSTANT_VECTOR); + ConstantVector::SetNull(target_vector, true); + continue; + } + ScanChild(state, target_vector, [&](Vector &child_result) { + return child.col.ScanCount(child.state, child_result, count, result_offset); + }); + } return scan_count; } @@ -188,14 +184,13 @@ void StructColumnData::Skip(ColumnScanState &state, idx_t count) { validity->Skip(state.child_states[0], count); // skip inside the sub-columns - IterateFields( - state, [&](idx_t child_index, optional_idx field_vector_index, ColumnScanState &field_state, bool should_scan) { - if (!should_scan) { - return; - } - auto &field = *sub_columns[child_index]; - field.Skip(field_state, count); - }); + auto struct_children = GetStructChildren(state); + for (auto &child : struct_children) { + if (!child.should_scan) { + continue; + } + child.col.Skip(child.state, count); + } } void StructColumnData::InitializeAppend(ColumnAppendState &state) { @@ -357,6 +352,29 @@ void StructColumnData::SetChildData(idx_t i, shared_ptr child_column this->sub_columns[i] = std::move(child_column_p); } +const ColumnData &StructColumnData::GetChildColumn(idx_t index) const { + D_ASSERT(index < sub_columns.size()); + return *sub_columns[index]; +} + +const BaseStatistics &StructColumnData::GetChildStats(const ColumnData &child) const { + optional_idx index; + for (idx_t i = 0; i < sub_columns.size(); i++) { + if (RefersToSameObject(child, *sub_columns[i])) { + index = i; + break; + } + } + if (!index.IsValid()) { + throw InternalException("StructColumnData::GetChildStats: Could not find a matching child index for the " + "provided child (of type %s)", + child.type.ToString()); + } + auto idx = index.GetIndex(); + auto &stats = GetStatisticsRef(); + return StructStats::GetChildStats(stats, idx); +} + struct StructColumnCheckpointState : public ColumnCheckpointState { StructColumnCheckpointState(const RowGroup &row_group, ColumnData &column_data, PartialBlockManager &partial_block_manager) @@ -411,12 +429,16 @@ unique_ptr StructColumnData::CreateCheckpointState(const } unique_ptr StructColumnData::Checkpoint(const RowGroup &row_group, - ColumnCheckpointInfo &checkpoint_info) { + ColumnCheckpointInfo &checkpoint_info, + const BaseStatistics &old_stats) { auto &partial_block_manager = checkpoint_info.GetPartialBlockManager(); auto checkpoint_state = make_uniq(row_group, *this, partial_block_manager); - checkpoint_state->validity_state = validity->Checkpoint(row_group, checkpoint_info); - for (auto &sub_column : sub_columns) { - checkpoint_state->child_states.push_back(sub_column->Checkpoint(row_group, checkpoint_info)); + checkpoint_state->validity_state = validity->Checkpoint(row_group, checkpoint_info, old_stats); + + for (idx_t col_idx = 0; col_idx < sub_columns.size(); col_idx++) { + const auto &sub_column = sub_columns[col_idx]; + const auto &old_child_stats = StructStats::GetChildStats(old_stats, col_idx); + checkpoint_state->child_states.push_back(sub_column->Checkpoint(row_group, checkpoint_info, old_child_stats)); } return std::move(checkpoint_state); } diff --git a/src/duckdb/src/storage/table/variant/variant_shredding.cpp b/src/duckdb/src/storage/table/variant/variant_shredding.cpp index e0485626d..585dd89f8 100644 --- a/src/duckdb/src/storage/table/variant/variant_shredding.cpp +++ b/src/duckdb/src/storage/table/variant/variant_shredding.cpp @@ -376,7 +376,7 @@ static LogicalType SetShreddedType(const LogicalType &typed_value) { bool VariantShreddingStats::GetShreddedTypeInternal(const VariantColumnStatsData &column, LogicalType &out_type) const { idx_t max_count = 0; - uint8_t type_index; + uint8_t type_index = 0; if (column.type_counts[0] == column.total_count) { //! All NULL, emit INT32 out_type = SetShreddedType(LogicalTypeId::INTEGER); diff --git a/src/duckdb/src/storage/table/variant_column_data.cpp b/src/duckdb/src/storage/table/variant_column_data.cpp index cf168902a..1befb2685 100644 --- a/src/duckdb/src/storage/table/variant_column_data.cpp +++ b/src/duckdb/src/storage/table/variant_column_data.cpp @@ -1,10 +1,14 @@ #include "duckdb/storage/table/variant_column_data.hpp" +#include "duckdb/storage/table/struct_column_data.hpp" #include "duckdb/common/serializer/deserializer.hpp" #include "duckdb/storage/table/column_checkpoint_state.hpp" #include "duckdb/storage/table/append_state.hpp" #include "duckdb/storage/table/scan_state.hpp" #include "duckdb/storage/statistics/variant_stats.hpp" +#include "duckdb/storage/statistics/struct_stats.hpp" #include "duckdb/function/variant/variant_shredding.hpp" +#include "duckdb/main/settings.hpp" +#include "duckdb/transaction/duck_transaction.hpp" namespace duckdb { @@ -27,6 +31,106 @@ VariantColumnData::VariantColumnData(BlockManager &block_manager, DataTableInfo } } +bool FindShreddedColumnInternal(const StructColumnData &shredded, reference &stats, + reference &path_iter, ColumnIndex &out) { + auto &path = path_iter.get(); + D_ASSERT(!path.HasPrimaryIndex()); + auto &field_name = path.GetFieldName(); + + D_ASSERT(shredded.type.id() == LogicalTypeId::STRUCT); + auto &typed_value = shredded.GetChildColumn(1); + auto &parent_stats = stats.get(); + + stats = StructStats::GetChildStats(parent_stats, 1); + if (typed_value.type.id() != LogicalTypeId::STRUCT) { + //! Not shredded on an OBJECT, but we're looking for a specific OBJECT field + return false; + } + if (!VariantShreddedStats::IsFullyShredded(parent_stats)) { + //! Can't push down to the shredded data, stats are inconsistent + return false; + } + //! shredded.typed_value + out.AddChildIndex(ColumnIndex(1)); + auto &typed_value_index = out.GetChildIndex(0); + + auto &object_children = StructType::GetChildTypes(typed_value.type); + optional_idx opt_index; + for (idx_t i = 0; i < object_children.size(); i++) { + if (StringUtil::CIEquals(field_name, object_children[i].first)) { + opt_index = i; + break; + } + } + if (!opt_index.IsValid()) { + //! OBJECT doesn't contain a field with this name + return false; + } + + auto child_index = opt_index.GetIndex(); + auto &typed_value_struct = typed_value.Cast(); + auto &object_field = typed_value_struct.GetChildColumn(child_index); + stats = StructStats::GetChildStats(stats.get(), child_index); + + //! typed_value. + typed_value_index.AddChildIndex(ColumnIndex(child_index)); + auto &child_column = typed_value_index.GetChildIndex(0); + + if (!path.HasChildren()) { + if (!VariantShreddedStats::IsFullyShredded(stats.get())) { + //! Child isn't fully shredded, can't use it + return false; + } + //! We're done, we've found the field referenced by the path! + //! typed_value_index..typed_value + child_column.AddChildIndex(ColumnIndex(1)); + stats = StructStats::GetChildStats(stats.get(), 1); + return true; + } + path_iter = path.GetChildIndex(0); + + //! Child of object is always a STRUCT(untyped_value_index UINTEGER, typed_value <...>) + D_ASSERT(object_field.type.id() == LogicalTypeId::STRUCT); + auto &struct_field = object_field.Cast(); + + return FindShreddedColumnInternal(struct_field, stats, path_iter, child_column); +} + +bool VariantColumnData::PushdownShreddedFieldExtract(const StorageIndex &variant_extract, + StorageIndex &out_struct_extract) const { + D_ASSERT(IsShredded()); + auto &shredded = *sub_columns[1]; + D_ASSERT(shredded.type.id() == LogicalTypeId::STRUCT); + D_ASSERT(StructType::GetChildCount(shredded.type) == 2); + D_ASSERT(StructType::GetChildTypes(shredded.type)[0].second.id() == LogicalTypeId::UINTEGER); + auto &variant_stats = GetStatisticsRef(); + + if (!VariantStats::IsShredded(variant_stats)) { + //! FIXME: this happens when we Checkpoint but don't restart, the stats of the ColumnData aren't updated by + //! Checkpoint The variant is shredded, but there are no stats / the stats are cluttered (?) + return false; + } + + //! shredded.typed_value + ColumnIndex column_index(0); + auto &struct_column = shredded.Cast(); + + reference shredded_stats(VariantStats::GetShreddedStats(variant_stats)); + reference path_iter(variant_extract); + if (!FindShreddedColumnInternal(struct_column, shredded_stats, path_iter, column_index)) { + return false; + } + if (shredded_stats.get().GetType().IsNested()) { + //! Can't push down an extract if the leaf we're extracting is not a primitive + //! (Since the shredded representation for OBJECT/ARRAY is interleaved with 'untyped_value_index' fields) + return false; + } + + column_index.SetPushdownExtractType(shredded.type, path_iter.get().GetType()); + out_struct_extract = StorageIndex::FromColumnIndex(column_index); + return true; +} + void VariantColumnData::CreateScanStates(ColumnScanState &state) { //! Re-initialize the scan state, since VARIANT can have a different shape for every RowGroup state.child_states.clear(); @@ -37,9 +141,22 @@ void VariantColumnData::CreateScanStates(ColumnScanState &state) { auto unshredded_type = VariantShredding::GetUnshreddedType(); state.child_states.emplace_back(state.parent); state.child_states[1].Initialize(state.context, unshredded_type, state.scan_options); + + const bool is_pushed_down_cast = + state.storage_index.HasType() && state.storage_index.GetScanType().id() != LogicalTypeId::VARIANT; if (IsShredded()) { auto &shredded_column = sub_columns[1]; state.child_states.emplace_back(state.parent); + if (state.storage_index.IsPushdownExtract() && is_pushed_down_cast) { + StorageIndex struct_extract; + if (PushdownShreddedFieldExtract(state.storage_index.GetChildIndex(0), struct_extract)) { + //! Shredded field exists and is fully shredded, + //! add the storage index to create a pushed-down 'struct_extract' to get the leaf + state.child_states[2].Initialize(state.context, shredded_column->type, struct_extract, + state.scan_options); + return; + } + } state.child_states[2].Initialize(state.context, shredded_column->type, state.scan_options); } } @@ -49,6 +166,7 @@ idx_t VariantColumnData::GetMaxEntry() { } void VariantColumnData::InitializePrefetch(PrefetchState &prefetch_state, ColumnScanState &scan_state, idx_t rows) { + //! FIXME: does this also need CreateScanStates ?? validity->InitializePrefetch(prefetch_state, scan_state.child_states[0], rows); for (idx_t i = 0; i < sub_columns.size(); i++) { sub_columns[i]->InitializePrefetch(prefetch_state, scan_state.child_states[i + 1], rows); @@ -81,7 +199,7 @@ void VariantColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t r } } -Vector VariantColumnData::CreateUnshreddingIntermediate(idx_t count) { +Vector VariantColumnData::CreateUnshreddingIntermediate(idx_t count) const { D_ASSERT(IsShredded()); D_ASSERT(sub_columns.size() == 2); @@ -93,26 +211,119 @@ Vector VariantColumnData::CreateUnshreddingIntermediate(idx_t count) { return intermediate; } -idx_t VariantColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, - idx_t target_count) { - if (IsShredded()) { - auto intermediate = CreateUnshreddingIntermediate(target_count); - auto &child_vectors = StructVector::GetEntries(intermediate); - sub_columns[0]->Scan(transaction, vector_index, state.child_states[1], *child_vectors[0], target_count); - sub_columns[1]->Scan(transaction, vector_index, state.child_states[2], *child_vectors[1], target_count); - auto scan_count = validity->Scan(transaction, vector_index, state.child_states[0], intermediate, target_count); +idx_t VariantColumnData::ScanWithCallback( + ColumnScanState &state, Vector &result, idx_t target_count, + const std::function + &callback) const { + if (state.storage_index.IsPushdownExtract()) { + if (IsShredded() && state.child_states[2].storage_index.IsPushdownExtract()) { + //! FIXME: We could also push down the extract if we're returning VARIANT + //! Then we can do the unshredding on the extracted data, rather than falling back to unshredding+extracting + //! This invariant is ensured by CreateScanStates + D_ASSERT(result.GetType().id() != LogicalTypeId::VARIANT); + + //! In the initialize we have verified that the field exists and the data is fully shredded (for this + //! rowgroup) We have created a scan state that performs a 'struct_extract' in the shredded data, to extract + //! the requested field.s + auto res = callback(*sub_columns[1], state.child_states[2], result, target_count); + if (result.GetType().id() == LogicalTypeId::LIST) { + //! Shredded ARRAY Variant looks like: + //! LIST(STRUCT(untyped_value_index UINTEGER, typed_value )) + //! We need to transform this to: + //! LIST() + + auto &list_child = ListVector::GetEntry(result); + D_ASSERT(list_child.GetType().id() == LogicalTypeId::STRUCT); + D_ASSERT(StructType::GetChildCount(list_child.GetType()) == 2); + + auto &typed_value = *StructVector::GetEntries(list_child)[1]; + auto list_res = Vector(LogicalType::LIST(typed_value.GetType())); + ListVector::SetListSize(list_res, ListVector::GetListSize(result)); + list_res.CopyBuffer(result); + ListVector::GetEntry(list_res).Reference(typed_value); + return res; + } + return res; + } + //! Fall back to unshredding + Vector intermediate(LogicalType::VARIANT(), target_count); + idx_t scan_count; + if (IsShredded()) { + auto unshredding_intermediate = CreateUnshreddingIntermediate(target_count); + auto &child_vectors = StructVector::GetEntries(unshredding_intermediate); + + callback(*sub_columns[0], state.child_states[1], *child_vectors[0], target_count); + callback(*sub_columns[1], state.child_states[2], *child_vectors[1], target_count); + scan_count = callback(*validity, state.child_states[0], unshredding_intermediate, target_count); + + VariantColumnData::UnshredVariantData(unshredding_intermediate, intermediate, target_count); + } else { + scan_count = callback(*validity, state.child_states[0], intermediate, target_count); + callback(*sub_columns[0], state.child_states[1], intermediate, target_count); + } + + Vector extract_intermediate(LogicalType::VARIANT(), target_count); + vector components; + reference path_iter(state.storage_index.GetChildIndex(0)); + + while (true) { + auto ¤t = path_iter.get(); + auto &field_name = current.GetFieldName(); + components.emplace_back(field_name); + if (!current.HasChildren()) { + break; + } + path_iter = current.GetChildIndex(0); + } + VariantUtils::VariantExtract(intermediate, components, extract_intermediate, target_count); + + if (state.expression_state) { + auto &expression_state = *state.expression_state; + auto &executor = expression_state.executor; + + auto &input = expression_state.input; + auto &target = expression_state.target; + input.Reset(); + target.Reset(); + input.data[0].Reference(extract_intermediate); + input.SetCardinality(scan_count); + executor.Execute(input, target); + result.Reference(target.data[0]); + } else { + result.Reference(extract_intermediate); + } + return scan_count; + } else { + if (IsShredded()) { + auto intermediate = CreateUnshreddingIntermediate(target_count); + auto &child_vectors = StructVector::GetEntries(intermediate); - VariantColumnData::UnshredVariantData(intermediate, result, target_count); + callback(*sub_columns[0], state.child_states[1], *child_vectors[0], target_count); + callback(*sub_columns[1], state.child_states[2], *child_vectors[1], target_count); + auto scan_count = callback(*validity, state.child_states[0], intermediate, target_count); + + VariantColumnData::UnshredVariantData(intermediate, result, target_count); + return scan_count; + } + auto scan_count = callback(*validity, state.child_states[0], result, target_count); + callback(*sub_columns[0], state.child_states[1], result, target_count); return scan_count; } - auto scan_count = validity->Scan(transaction, vector_index, state.child_states[0], result, target_count); - sub_columns[0]->Scan(transaction, vector_index, state.child_states[1], result, target_count); - return scan_count; +} + +idx_t VariantColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result, + idx_t target_count) { + return ScanWithCallback(state, result, target_count, + [&](ColumnData &col, ColumnScanState &child_state, Vector &target_vector, idx_t count) { + return col.Scan(transaction, vector_index, child_state, target_vector, count); + }); } idx_t VariantColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t count, idx_t result_offset) { - auto scan_count = sub_columns[0]->ScanCount(state.child_states[1], result, count, result_offset); - return scan_count; + return ScanWithCallback(state, result, count, + [&](ColumnData &col, ColumnScanState &child_state, Vector &target_vector, idx_t count) { + return col.ScanCount(child_state, target_vector, count, result_offset); + }); } void VariantColumnData::Skip(ColumnScanState &state, idx_t count) { @@ -242,35 +453,73 @@ unique_ptr VariantColumnData::GetUpdateStatistics() { void VariantColumnData::FetchRow(TransactionData transaction, ColumnFetchState &state, const StorageIndex &storage_index, row_t row_id, Vector &result, idx_t result_idx) { - // insert any child states that are required - for (idx_t i = state.child_states.size(); i < sub_columns.size() + 1; i++) { - auto child_state = make_uniq(); - state.child_states.push_back(std::move(child_state)); + if (storage_index.IsPushdownExtract() && IsShredded()) { + StorageIndex struct_extract; + if (PushdownShreddedFieldExtract(storage_index.GetChildIndex(0), struct_extract)) { + //! Shredded field exists and is fully shredded, + //! add the storage index to create a pushed-down 'struct_extract' to get the leaf + sub_columns[1]->FetchRow(transaction, state, struct_extract, row_id, result, result_idx); + return; + } } - + Vector variant_vec(LogicalType::VARIANT(), result_idx + 1); + validity->FetchRow(transaction, state, storage_index, row_id, variant_vec, result_idx); if (IsShredded()) { auto intermediate = CreateUnshreddingIntermediate(result_idx + 1); auto &child_vectors = StructVector::GetEntries(intermediate); // fetch the validity state - validity->FetchRow(transaction, *state.child_states[0], storage_index, row_id, result, result_idx); // fetch the sub-column states + StorageIndex empty(0); for (idx_t i = 0; i < sub_columns.size(); i++) { - sub_columns[i]->FetchRow(transaction, *state.child_states[i + 1], storage_index, row_id, *child_vectors[i], - result_idx); + sub_columns[i]->FetchRow(transaction, state, empty, row_id, *child_vectors[i], result_idx); } if (result_idx) { intermediate.SetValue(0, intermediate.GetValue(result_idx)); } - //! FIXME: adjust UnshredVariantData so we can write the value in place into 'result' directly. - Vector unshredded(result.GetType(), 1); + //! FIXME: adjust UnshredVariantData so we can write the value in place directly. + Vector unshredded(variant_vec.GetType(), 1); VariantColumnData::UnshredVariantData(intermediate, unshredded, 1); - result.SetValue(result_idx, unshredded.GetValue(0)); + variant_vec.SetValue(0, unshredded.GetValue(0)); + } else { + sub_columns[0]->FetchRow(transaction, state, storage_index, row_id, variant_vec, result_idx); + if (result_idx) { + variant_vec.SetValue(0, variant_vec.GetValue(result_idx)); + } + } + + if (!storage_index.IsPushdownExtract()) { + //! No extract required + D_ASSERT(result.GetType().id() == LogicalTypeId::VARIANT); + result.SetValue(result_idx, variant_vec.GetValue(0)); return; } - validity->FetchRow(transaction, *state.child_states[0], storage_index, row_id, result, result_idx); - sub_columns[0]->FetchRow(transaction, *state.child_states[1], storage_index, row_id, result, result_idx); + Vector extracted_variant(variant_vec.GetType(), 1); + vector components; + reference path_iter(storage_index.GetChildIndex(0)); + + while (true) { + auto ¤t = path_iter.get(); + auto &field_name = current.GetFieldName(); + components.emplace_back(field_name); + if (!current.HasChildren()) { + break; + } + path_iter = current.GetChildIndex(0); + } + VariantUtils::VariantExtract(variant_vec, components, extracted_variant, 1); + + if (result.GetType().id() == LogicalTypeId::VARIANT) { + //! No cast required + result.SetValue(result_idx, extracted_variant.GetValue(0)); + return; + } + + //! Need to perform the cast here as well + auto context = transaction.transaction->context.lock(); + auto fetched_row = extracted_variant.GetValue(0).CastAs(*context, result.GetType()); + result.SetValue(result_idx, fetched_row); } void VariantColumnData::VisitBlockIds(BlockIdVisitor &visitor) const { @@ -345,11 +594,13 @@ struct VariantColumnCheckpointState : public ColumnCheckpointState { PersistentColumnData ToPersistentData() override { PersistentColumnData data(original_column.type); - auto &variant_column_data = GetResultColumn().Cast(); if (child_states.size() == 2) { - D_ASSERT(variant_column_data.sub_columns.size() == 2); - D_ASSERT(variant_column_data.sub_columns[1]->type.id() == LogicalTypeId::STRUCT); - data.SetVariantShreddedType(variant_column_data.sub_columns[1]->type); + //! Use the type of the column data we used to create the Checkpoint + //! This will either be a pointer to shredded_data[1] if we decided to shred + //! Or to the existing shredded column data if we didn't decide to reshred + auto &shredded_state = child_states[1]; + D_ASSERT(shredded_state->original_column.type.id() == LogicalTypeId::STRUCT); + data.extra_data = make_uniq(shredded_state->original_column.type); } data.child_columns.push_back(validity_state->ToPersistentData()); for (auto &child_state : child_states) { @@ -452,27 +703,28 @@ static bool EnableShredding(int64_t minimum_size, idx_t current_size) { } unique_ptr VariantColumnData::Checkpoint(const RowGroup &row_group, - ColumnCheckpointInfo &checkpoint_info) { + ColumnCheckpointInfo &checkpoint_info, + const BaseStatistics &old_stats) { auto &partial_block_manager = checkpoint_info.GetPartialBlockManager(); auto checkpoint_state = make_uniq(row_group, *this, partial_block_manager); - checkpoint_state->validity_state = validity->Checkpoint(row_group, checkpoint_info); + checkpoint_state->validity_state = validity->Checkpoint(row_group, checkpoint_info, old_stats); auto &table_info = row_group.GetTableInfo(); auto &db = table_info.GetDB(); - auto &config_options = DBConfig::Get(db).options; + auto &config = DBConfig::Get(db); bool should_shred = true; if (!HasAnyChanges()) { should_shred = false; } - if (!EnableShredding(config_options.variant_minimum_shredding_size, row_group.count.load())) { + if (!EnableShredding(Settings::Get(config), row_group.count.load())) { should_shred = false; } LogicalType shredded_type; if (should_shred) { - if (config_options.force_variant_shredding.id() != LogicalTypeId::INVALID) { - shredded_type = config_options.force_variant_shredding; + if (config.options.force_variant_shredding.id() != LogicalTypeId::INVALID) { + shredded_type = config.options.force_variant_shredding; } else { shredded_type = GetShreddedType(); } @@ -485,8 +737,11 @@ unique_ptr VariantColumnData::Checkpoint(const RowGroup & } if (!should_shred) { - for (idx_t i = 0; i < sub_columns.size(); i++) { - checkpoint_state->child_states.push_back(sub_columns[i]->Checkpoint(row_group, checkpoint_info)); + checkpoint_state->child_states.push_back( + sub_columns[0]->Checkpoint(row_group, checkpoint_info, VariantStats::GetUnshreddedStats(old_stats))); + if (sub_columns.size() > 1) { + checkpoint_state->child_states.push_back( + sub_columns[1]->Checkpoint(row_group, checkpoint_info, VariantStats::GetShreddedStats(old_stats))); } return std::move(checkpoint_state); } @@ -499,8 +754,10 @@ unique_ptr VariantColumnData::Checkpoint(const RowGroup & auto &shredded = checkpoint_state->shredded_data[1]; //! Now checkpoint the shredded data - checkpoint_state->child_states.push_back(unshredded->Checkpoint(row_group, checkpoint_info)); - checkpoint_state->child_states.push_back(shredded->Checkpoint(row_group, checkpoint_info)); + checkpoint_state->child_states.push_back( + unshredded->Checkpoint(row_group, checkpoint_info, VariantStats::GetUnshreddedStats(column_stats))); + checkpoint_state->child_states.push_back( + shredded->Checkpoint(row_group, checkpoint_info, VariantStats::GetShreddedStats(column_stats))); return std::move(checkpoint_state); } @@ -534,7 +791,8 @@ bool VariantColumnData::HasAnyChanges() const { PersistentColumnData VariantColumnData::Serialize() { PersistentColumnData persistent_data(type); if (IsShredded()) { - persistent_data.SetVariantShreddedType(sub_columns[1]->type); + // Set the extra data to indicate that this is shredded data + persistent_data.extra_data = make_uniq(sub_columns[1]->type); } persistent_data.child_columns.push_back(validity->Serialize()); for (idx_t i = 0; i < sub_columns.size(); i++) { @@ -552,7 +810,10 @@ void VariantColumnData::InitializeColumn(PersistentColumnData &column_data, Base auto &unshredded_stats = VariantStats::GetUnshreddedStats(target_stats); sub_columns[0]->InitializeColumn(column_data.child_columns[1], unshredded_stats); - auto &shredded_type = column_data.variant_shredded_type; + // TODO: + D_ASSERT(column_data.extra_data); + auto &variant_extra_data = column_data.extra_data->Cast(); + auto &shredded_type = variant_extra_data.logical_type; if (!IsShredded()) { VariantStats::SetShreddedStats(target_stats, BaseStatistics::CreateEmpty(shredded_type)); sub_columns.push_back(ColumnData::CreateColumn(block_manager, info, 2, shredded_type, GetDataType(), this)); diff --git a/src/duckdb/src/storage/temporary_file_manager.cpp b/src/duckdb/src/storage/temporary_file_manager.cpp index 057f6db29..d62ab728c 100644 --- a/src/duckdb/src/storage/temporary_file_manager.cpp +++ b/src/duckdb/src/storage/temporary_file_manager.cpp @@ -4,6 +4,7 @@ #include "duckdb/parallel/task_scheduler.hpp" #include "duckdb/storage/buffer/temporary_file_information.hpp" #include "duckdb/main/database.hpp" +#include "duckdb/main/settings.hpp" #include "duckdb/common/encryption_functions.hpp" #include "zstd.h" @@ -639,7 +640,7 @@ void TemporaryFileManager::DecreaseSizeOnDisk(idx_t bytes) { } bool TemporaryFileManager::IsEncrypted() const { - return db.config.options.temp_file_encryption; + return Settings::Get(db); } unique_ptr TemporaryFileManager::ReadTemporaryBuffer(QueryContext context, block_id_t id, diff --git a/src/duckdb/src/storage/wal_replay.cpp b/src/duckdb/src/storage/wal_replay.cpp index b972882b4..a1c0523fb 100644 --- a/src/duckdb/src/storage/wal_replay.cpp +++ b/src/duckdb/src/storage/wal_replay.cpp @@ -7,6 +7,7 @@ #include "duckdb/common/serializer/binary_deserializer.hpp" #include "duckdb/common/serializer/buffered_file_reader.hpp" #include "duckdb/common/serializer/memory_stream.hpp" +#include "duckdb/common/enums/checkpoint_abort.hpp" #include "duckdb/execution/index/art/art.hpp" #include "duckdb/execution/index/index_type_set.hpp" #include "duckdb/main/attached_database.hpp" @@ -417,8 +418,7 @@ unique_ptr WriteAheadLog::ReplayInternal(QueryContext context, St checkpoint_reader.FileSize()); } - auto debug_checkpoint_abort = - DBConfig::GetSetting(storage_manager.GetDatabase()); + auto debug_checkpoint_abort = Settings::Get(storage_manager.GetDatabase()); // move over the recovery WAL over the main WAL recovery_handle->Sync(); diff --git a/src/duckdb/src/transaction/duck_transaction_manager.cpp b/src/duckdb/src/transaction/duck_transaction_manager.cpp index 29d2fbde3..b8b005988 100644 --- a/src/duckdb/src/transaction/duck_transaction_manager.cpp +++ b/src/duckdb/src/transaction/duck_transaction_manager.cpp @@ -155,7 +155,7 @@ DuckTransactionManager::CanCheckpoint(DuckTransaction &transaction, unique_ptr(db.GetDatabase())) { + if (Settings::Get(db.GetDatabase())) { return CheckpointDecision("checkpointing on commit disabled through configuration"); } // try to lock the checkpoint lock diff --git a/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp b/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp index bfdc6ca20..d6c1e3271 100644 --- a/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp +++ b/src/duckdb/third_party/libpg_query/include/nodes/parsenodes.hpp @@ -1489,7 +1489,7 @@ typedef enum PGAlterTableType { PG_AT_SetIdentity, /* SET identity column options */ AT_DropIdentity, /* DROP IDENTITY */ PG_AT_SetPartitionedBy, /* SET PARTITIONED BY */ - PG_AT_SetSortedBy /* SET SORTED BY */ + PG_AT_SetSortedBy, /* SET SORTED BY */ } PGAlterTableType; typedef struct PGAlterTableCmd /* one subcommand of an ALTER TABLE */ @@ -1499,7 +1499,8 @@ typedef struct PGAlterTableCmd /* one subcommand of an ALTER TABLE */ char *name; /* column, constraint, or trigger to act on, * or tablespace */ PGNode *def; /* definition of new column, index, * constraint, or parent table */ - PGList *def_list; /* e.g. expression list for partitioned by */ + PGList *def_list; /* e.g. expression list for partitioned by or sorted by */ + PGList *options; /* set table options e.g. SET ('foo'='bar'); RESET ('foo'='bar') */ PGDropBehavior behavior; /* RESTRICT or CASCADE for DROP cases */ bool missing_ok; /* skip error if missing? */ } PGAlterTableCmd; @@ -1616,6 +1617,8 @@ typedef struct PGCreateStmt { PGTypeName *ofTypename; /* OF typename */ PGList *constraints; /* constraints (list of PGConstraint nodes) */ PGList *options; /* options from WITH clause */ + PGList *partition_list; /* e.g. expression list for partitioned by */ + PGList *sort_list; /* e.g. expression list for sort by */ PGOnCommitAction oncommit; /* what do we do at COMMIT? */ char *tablespacename; /* table space to use, or NULL */ PGOnCreateConflict onconflict; /* what to do on create conflict */ diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp index f222526b5..ae88e7f96 100644 --- a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp +++ b/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp @@ -1647,16 +1647,16 @@ union yyalloc /* YYFINAL -- State number of the termination state. */ #define YYFINAL 889 /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 77384 +#define YYLAST 77783 /* YYNTOKENS -- Number of terminals. */ #define YYNTOKENS 538 /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 510 +#define YYNNTS 512 /* YYNRULES -- Number of rules. */ -#define YYNRULES 2257 +#define YYNRULES 2263 /* YYNRULES -- Number of states. */ -#define YYNSTATES 3815 +#define YYNSTATES 3832 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ #define YYUNDEFTOK 2 @@ -1782,309 +1782,310 @@ static const yytype_uint16 yyprhs[] = 972, 975, 978, 981, 985, 989, 993, 995, 999, 1001, 1002, 1004, 1007, 1010, 1017, 1026, 1032, 1040, 1041, 1044, 1047, 1051, 1055, 1058, 1061, 1064, 1066, 1068, 1069, 1072, - 1075, 1076, 1079, 1089, 1102, 1114, 1115, 1118, 1120, 1122, - 1124, 1126, 1128, 1130, 1134, 1135, 1137, 1140, 1142, 1144, - 1147, 1150, 1154, 1156, 1158, 1161, 1164, 1166, 1169, 1173, - 1179, 1183, 1186, 1192, 1194, 1196, 1198, 1199, 1205, 1213, - 1219, 1222, 1226, 1228, 1230, 1233, 1236, 1237, 1241, 1246, - 1251, 1252, 1256, 1259, 1260, 1264, 1266, 1268, 1270, 1272, - 1274, 1276, 1278, 1280, 1282, 1284, 1288, 1292, 1294, 1297, - 1300, 1303, 1306, 1309, 1312, 1313, 1317, 1321, 1325, 1326, - 1328, 1331, 1333, 1336, 1339, 1342, 1345, 1348, 1352, 1355, - 1358, 1360, 1364, 1366, 1368, 1370, 1372, 1376, 1378, 1381, - 1382, 1384, 1387, 1388, 1390, 1394, 1395, 1398, 1399, 1403, - 1407, 1409, 1415, 1419, 1421, 1425, 1427, 1430, 1432, 1437, - 1443, 1449, 1456, 1460, 1468, 1473, 1485, 1487, 1491, 1494, - 1497, 1500, 1501, 1505, 1507, 1509, 1512, 1515, 1518, 1521, - 1523, 1524, 1526, 1529, 1536, 1541, 1548, 1553, 1560, 1569, - 1571, 1573, 1575, 1577, 1580, 1582, 1585, 1587, 1590, 1592, - 1594, 1596, 1598, 1602, 1606, 1610, 1614, 1616, 1619, 1622, - 1624, 1628, 1630, 1632, 1634, 1638, 1640, 1642, 1643, 1645, - 1647, 1649, 1659, 1662, 1663, 1667, 1668, 1670, 1671, 1675, - 1679, 1682, 1684, 1691, 1695, 1699, 1702, 1705, 1707, 1708, - 1714, 1717, 1720, 1721, 1729, 1731, 1733, 1735, 1738, 1744, - 1753, 1761, 1767, 1776, 1784, 1789, 1794, 1796, 1800, 1802, - 1804, 1808, 1810, 1814, 1816, 1818, 1821, 1826, 1830, 1832, - 1836, 1839, 1844, 1849, 1858, 1870, 1880, 1888, 1889, 1893, - 1897, 1899, 1901, 1905, 1906, 1908, 1909, 1911, 1912, 1914, - 1915, 1917, 1921, 1924, 1925, 1928, 1929, 1931, 1932, 1934, - 1936, 1938, 1942, 1946, 1948, 1950, 1954, 1958, 1962, 1966, - 1970, 1974, 1979, 1983, 1986, 1988, 1990, 1992, 1996, 1998, - 2002, 2004, 2006, 2008, 2012, 2016, 2020, 2022, 2025, 2030, - 2035, 2038, 2042, 2048, 2054, 2056, 2058, 2062, 2063, 2075, - 2087, 2098, 2111, 2113, 2116, 2122, 2127, 2132, 2137, 2142, - 2150, 2156, 2161, 2169, 2176, 2186, 2196, 2201, 2203, 2205, - 2207, 2209, 2211, 2213, 2215, 2221, 2223, 2225, 2229, 2231, - 2234, 2237, 2240, 2244, 2246, 2250, 2259, 2265, 2266, 2268, - 2271, 2273, 2277, 2279, 2282, 2283, 2286, 2287, 2291, 2295, - 2300, 2305, 2310, 2315, 2319, 2322, 2324, 2326, 2327, 2329, - 2331, 2332, 2335, 2337, 2343, 2345, 2346, 2349, 2352, 2353, - 2355, 2356, 2360, 2366, 2368, 2372, 2377, 2381, 2383, 2385, - 2386, 2389, 2392, 2393, 2396, 2399, 2401, 2403, 2405, 2406, - 2409, 2414, 2420, 2425, 2428, 2432, 2434, 2436, 2438, 2441, - 2444, 2446, 2449, 2453, 2454, 2456, 2457, 2463, 2465, 2470, - 2477, 2480, 2482, 2483, 2488, 2489, 2491, 2493, 2497, 2502, - 2503, 2505, 2507, 2510, 2513, 2516, 2518, 2520, 2523, 2526, - 2528, 2530, 2532, 2534, 2536, 2538, 2542, 2546, 2547, 2549, - 2553, 2555, 2558, 2560, 2562, 2564, 2566, 2568, 2571, 2576, - 2581, 2587, 2589, 2591, 2594, 2595, 2598, 2599, 2601, 2605, - 2607, 2608, 2610, 2613, 2617, 2620, 2625, 2628, 2632, 2635, - 2636, 2638, 2641, 2642, 2647, 2653, 2655, 2658, 2661, 2662, - 2664, 2668, 2670, 2673, 2676, 2681, 2686, 2690, 2694, 2698, - 2702, 2706, 2710, 2714, 2716, 2721, 2726, 2736, 2746, 2750, - 2751, 2754, 2757, 2758, 2764, 2768, 2770, 2772, 2776, 2782, - 2786, 2788, 2791, 2793, 2797, 2803, 2805, 2808, 2812, 2817, - 2823, 2828, 2834, 2839, 2846, 2852, 2857, 2863, 2869, 2875, - 2878, 2883, 2885, 2887, 2888, 2890, 2895, 2901, 2906, 2907, - 2910, 2913, 2916, 2918, 2920, 2922, 2924, 2925, 2930, 2933, - 2935, 2938, 2941, 2946, 2949, 2956, 2959, 2961, 2965, 2970, - 2971, 2974, 2975, 2978, 2979, 2981, 2985, 2989, 2992, 2993, - 2996, 3001, 3003, 3005, 3007, 3008, 3011, 3015, 3021, 3028, - 3031, 3035, 3038, 3044, 3050, 3056, 3060, 3064, 3068, 3073, - 3074, 3076, 3078, 3080, 3082, 3084, 3087, 3092, 3094, 3096, - 3098, 3100, 3103, 3107, 3108, 3110, 3112, 3114, 3116, 3118, - 3121, 3124, 3127, 3130, 3133, 3135, 3139, 3140, 3142, 3144, - 3146, 3148, 3154, 3157, 3159, 3161, 3163, 3165, 3170, 3172, - 3175, 3178, 3180, 3184, 3188, 3191, 3193, 3194, 3200, 3203, - 3209, 3212, 3214, 3218, 3222, 3223, 3225, 3227, 3229, 3231, - 3233, 3235, 3237, 3239, 3241, 3243, 3245, 3247, 3249, 3251, - 3253, 3255, 3257, 3259, 3261, 3263, 3265, 3267, 3269, 3271, - 3273, 3275, 3277, 3279, 3281, 3283, 3285, 3287, 3289, 3291, - 3293, 3295, 3297, 3299, 3301, 3305, 3309, 3313, 3317, 3321, - 3325, 3329, 3330, 3332, 3336, 3340, 3346, 3349, 3352, 3356, - 3360, 3364, 3368, 3372, 3376, 3380, 3384, 3388, 3392, 3396, - 3400, 3404, 3408, 3412, 3415, 3418, 3422, 3426, 3429, 3432, - 3436, 3440, 3446, 3451, 3458, 3462, 3468, 3473, 3480, 3485, - 3492, 3498, 3506, 3510, 3513, 3518, 3522, 3525, 3530, 3534, - 3538, 3542, 3546, 3551, 3555, 3560, 3564, 3569, 3575, 3582, - 3589, 3597, 3604, 3612, 3619, 3627, 3631, 3636, 3641, 3648, - 3650, 3655, 3660, 3666, 3671, 3678, 3680, 3684, 3687, 3690, - 3694, 3698, 3702, 3706, 3710, 3714, 3718, 3722, 3726, 3730, - 3734, 3738, 3742, 3746, 3750, 3753, 3756, 3762, 3769, 3776, - 3784, 3786, 3789, 3791, 3793, 3795, 3798, 3801, 3806, 3810, - 3812, 3814, 3816, 3818, 3821, 3823, 3825, 3827, 3829, 3831, - 3833, 3835, 3838, 3843, 3846, 3850, 3854, 3859, 3863, 3869, - 3876, 3884, 3894, 3902, 3910, 3916, 3918, 3920, 3922, 3928, - 3935, 3942, 3947, 3952, 3957, 3962, 3969, 3975, 3981, 3987, - 3992, 3999, 4004, 4012, 4022, 4028, 4029, 4035, 4040, 4041, - 4043, 4044, 4047, 4048, 4050, 4054, 4058, 4061, 4064, 4065, - 4072, 4074, 4075, 4079, 4080, 4084, 4088, 4092, 4093, 4095, - 4100, 4103, 4106, 4109, 4112, 4115, 4119, 4122, 4125, 4129, - 4130, 4135, 4139, 4141, 4147, 4151, 4153, 4157, 4159, 4162, - 4166, 4168, 4172, 4174, 4177, 4179, 4180, 4182, 4184, 4186, - 4188, 4190, 4192, 4194, 4196, 4198, 4200, 4202, 4204, 4206, - 4208, 4210, 4212, 4214, 4216, 4218, 4220, 4225, 4227, 4232, - 4234, 4239, 4241, 4244, 4246, 4249, 4251, 4254, 4256, 4260, - 4262, 4266, 4268, 4271, 4273, 4277, 4279, 4282, 4284, 4285, - 4287, 4291, 4293, 4297, 4301, 4303, 4307, 4311, 4312, 4314, - 4316, 4318, 4320, 4322, 4324, 4326, 4328, 4330, 4332, 4334, - 4336, 4338, 4340, 4342, 4347, 4351, 4354, 4358, 4359, 4363, - 4367, 4370, 4373, 4375, 4376, 4379, 4382, 4386, 4389, 4391, - 4393, 4397, 4399, 4401, 4407, 4409, 4412, 4417, 4420, 4421, - 4423, 4424, 4426, 4428, 4431, 4435, 4441, 4449, 4457, 4459, - 4460, 4461, 4464, 4465, 4468, 4472, 4476, 4480, 4486, 4494, - 4502, 4503, 4506, 4508, 4509, 4511, 4512, 4514, 4518, 4520, - 4523, 4527, 4530, 4532, 4536, 4541, 4544, 4546, 4550, 4552, - 4556, 4558, 4561, 4563, 4564, 4568, 4570, 4574, 4576, 4579, - 4584, 4587, 4588, 4592, 4594, 4598, 4600, 4603, 4608, 4611, - 4612, 4614, 4618, 4620, 4624, 4626, 4629, 4631, 4635, 4637, - 4639, 4642, 4644, 4646, 4649, 4651, 4653, 4656, 4664, 4667, - 4673, 4677, 4681, 4683, 4685, 4687, 4689, 4691, 4693, 4695, - 4697, 4699, 4701, 4703, 4705, 4707, 4709, 4712, 4715, 4719, - 4723, 4724, 4726, 4728, 4730, 4736, 4740, 4741, 4743, 4745, - 4747, 4749, 4751, 4753, 4758, 4766, 4773, 4776, 4777, 4779, - 4781, 4783, 4785, 4799, 4816, 4818, 4821, 4822, 4824, 4825, - 4827, 4828, 4831, 4832, 4834, 4835, 4842, 4851, 4858, 4867, - 4874, 4883, 4887, 4890, 4892, 4893, 4900, 4907, 4909, 4911, - 4913, 4915, 4917, 4919, 4922, 4924, 4926, 4928, 4930, 4932, - 4937, 4944, 4948, 4951, 4956, 4960, 4966, 4968, 4969, 4971, - 4973, 4974, 4976, 4978, 4980, 4982, 4984, 4986, 4988, 4990, - 4992, 4994, 4996, 4998, 5000, 5002, 5004, 5006, 5008, 5010, - 5012, 5014, 5016, 5018, 5020, 5022, 5024, 5026, 5028, 5030, - 5032, 5034, 5036, 5038, 5040, 5042, 5044, 5046, 5048, 5050, - 5054, 5056, 5058, 5060, 5062, 5064, 5066, 5069, 5071, 5073, - 5076, 5080, 5084, 5088, 5092, 5094, 5098, 5102, 5105, 5109, - 5113, 5115, 5117, 5119, 5123, 5129, 5131, 5133, 5135, 5137, - 5141, 5144, 5149, 5156, 5163, 5164, 5166, 5168, 5170, 5171, - 5174, 5177, 5182, 5189, 5195, 5200, 5207, 5209, 5211, 5213, - 5215, 5217, 5219, 5220, 5222, 5226, 5228, 5229, 5237, 5241, - 5243, 5246, 5250, 5253, 5254, 5257, 5258, 5261, 5266, 5272, - 5281, 5289, 5292, 5296, 5302, 5304, 5305, 5308, 5309, 5311, - 5312, 5315, 5317, 5321, 5325, 5326, 5329, 5333, 5337, 5341, - 5345, 5347, 5349, 5351, 5354, 5358, 5361, 5364, 5367, 5372, - 5375, 5379, 5384, 5388, 5390, 5392, 5394, 5396, 5398, 5400, - 5401, 5403, 5407, 5410, 5420, 5433, 5445, 5458, 5473, 5477, - 5482, 5487, 5488, 5496, 5507, 5517, 5520, 5524, 5525, 5530, - 5532, 5534, 5536, 5538, 5540, 5542, 5544, 5546, 5548, 5550, - 5552, 5554, 5556, 5558, 5560, 5562, 5564, 5566, 5568, 5570, - 5572, 5574, 5576, 5578, 5580, 5582, 5584, 5586, 5588, 5590, - 5592, 5594, 5596, 5598, 5600, 5602, 5604, 5606, 5608, 5610, - 5612, 5614, 5616, 5618, 5620, 5622, 5624, 5626, 5628, 5630, - 5632, 5634, 5636, 5638, 5640, 5642, 5644, 5646, 5648, 5650, - 5652, 5654, 5656, 5658, 5660, 5662, 5664, 5666, 5668, 5670, - 5672, 5674, 5676, 5678, 5680, 5682, 5684, 5686, 5688, 5690, - 5692, 5694, 5696, 5698, 5700, 5702, 5704, 5706, 5708, 5710, - 5712, 5714, 5716, 5718, 5720, 5722, 5724, 5726, 5728, 5730, - 5732, 5734, 5736, 5738, 5740, 5742, 5744, 5746, 5748, 5750, - 5752, 5754, 5756, 5758, 5760, 5762, 5764, 5766, 5768, 5770, - 5772, 5774, 5776, 5778, 5780, 5782, 5784, 5786, 5788, 5790, - 5792, 5794, 5796, 5798, 5800, 5802, 5804, 5806, 5808, 5810, - 5812, 5814, 5816, 5818, 5820, 5822, 5824, 5826, 5828, 5830, - 5832, 5834, 5836, 5838, 5840, 5842, 5844, 5846, 5848, 5850, - 5852, 5854, 5856, 5858, 5860, 5862, 5864, 5866, 5868, 5870, - 5872, 5874, 5876, 5878, 5880, 5882, 5884, 5886, 5888, 5890, - 5892, 5894, 5896, 5898, 5900, 5902, 5904, 5906, 5908, 5910, - 5912, 5914, 5916, 5918, 5920, 5922, 5924, 5926, 5928, 5930, - 5932, 5934, 5936, 5938, 5940, 5942, 5944, 5946, 5948, 5950, - 5952, 5954, 5956, 5958, 5960, 5962, 5964, 5966, 5968, 5970, - 5972, 5974, 5976, 5978, 5980, 5982, 5984, 5986, 5988, 5990, - 5992, 5994, 5996, 5998, 6000, 6002, 6004, 6006, 6008, 6010, - 6012, 6014, 6016, 6018, 6020, 6022, 6024, 6026, 6028, 6030, - 6032, 6034, 6036, 6038, 6040, 6042, 6044, 6046, 6048, 6050, - 6052, 6054, 6056, 6058, 6060, 6062, 6064, 6066, 6068, 6070, - 6072, 6074, 6076, 6078, 6080, 6082, 6084, 6086, 6088, 6090, - 6092, 6094, 6096, 6098, 6100, 6102, 6104, 6106, 6108, 6110, - 6112, 6114, 6116, 6118, 6120, 6122, 6124, 6126, 6128, 6130, - 6132, 6134, 6136, 6138, 6140, 6142, 6144, 6146, 6148, 6150, - 6152, 6154, 6156, 6158, 6160, 6162, 6164, 6166, 6168, 6170, - 6172, 6174, 6176, 6178, 6180, 6182, 6184, 6186, 6188, 6190, - 6192, 6194, 6196, 6198, 6200, 6202, 6204, 6206, 6208, 6210, - 6212, 6214, 6216, 6218, 6220, 6222, 6224, 6226, 6228, 6230, - 6232, 6234, 6236, 6238, 6240, 6242, 6244, 6246, 6248, 6250, - 6252, 6254, 6256, 6258, 6260, 6262, 6264, 6266, 6268, 6270, - 6272, 6274, 6276, 6278, 6280, 6282, 6284, 6286, 6288, 6290, - 6292, 6294, 6296, 6298, 6300, 6302, 6304, 6306, 6308, 6310, - 6312, 6314, 6316, 6318, 6320, 6322, 6324, 6326, 6328, 6330, - 6332, 6334, 6336, 6338, 6340, 6342, 6344, 6346, 6348, 6350, - 6352, 6354, 6356, 6358, 6360, 6362, 6364, 6366, 6368, 6370, - 6372, 6374, 6376, 6378, 6380, 6382, 6384, 6386, 6388, 6390, - 6392, 6394, 6396, 6398, 6400, 6402, 6404, 6406, 6408, 6410, - 6412, 6414, 6416, 6418, 6420, 6422, 6424, 6426, 6428, 6430, - 6432, 6434, 6436, 6438, 6440, 6442, 6444, 6446, 6448, 6450, - 6452, 6454, 6456, 6458, 6460, 6462, 6464, 6466, 6468, 6470, - 6472, 6474, 6476, 6478, 6480, 6482, 6484, 6486, 6488, 6490, - 6492, 6494, 6496, 6498, 6500, 6502, 6504, 6506, 6508, 6510, - 6512, 6514, 6516, 6518, 6520, 6522, 6524, 6526, 6528, 6530, - 6532, 6534, 6536, 6538, 6540, 6542, 6544, 6546, 6548, 6550, - 6552, 6554, 6556, 6558, 6560, 6562, 6564, 6566, 6568, 6570, - 6572, 6574, 6576, 6578, 6580, 6582, 6584, 6586, 6588, 6590, - 6592, 6594, 6596, 6598, 6600, 6602, 6604, 6606, 6608, 6610, - 6612, 6614, 6616, 6618, 6620, 6622, 6624, 6626, 6628, 6630, - 6632, 6634, 6636, 6638, 6640, 6642, 6644, 6646, 6648, 6650, - 6652, 6654, 6656, 6658, 6660, 6662, 6664, 6666, 6668, 6670, - 6672, 6674, 6676, 6678, 6680, 6682, 6684, 6686, 6688, 6690, - 6692, 6694, 6696, 6698, 6700, 6702, 6704, 6706, 6708, 6710, - 6712, 6714, 6716, 6718, 6720, 6722, 6724, 6726, 6728, 6730, - 6732, 6734, 6736, 6738, 6740, 6742, 6744, 6746, 6748, 6750, - 6752, 6754, 6756, 6758, 6760, 6762, 6764, 6766, 6768, 6770, - 6772, 6774, 6776, 6778, 6780, 6782, 6784, 6786, 6788, 6790, - 6792, 6794, 6796, 6798, 6800, 6802, 6804, 6806 + 1075, 1076, 1079, 1090, 1104, 1117, 1118, 1121, 1123, 1125, + 1127, 1129, 1131, 1133, 1137, 1138, 1140, 1143, 1145, 1147, + 1150, 1153, 1157, 1159, 1161, 1164, 1167, 1169, 1172, 1176, + 1182, 1186, 1189, 1195, 1197, 1199, 1201, 1202, 1208, 1216, + 1222, 1225, 1229, 1231, 1233, 1236, 1239, 1240, 1244, 1249, + 1254, 1255, 1259, 1262, 1263, 1267, 1269, 1271, 1273, 1275, + 1277, 1279, 1281, 1283, 1285, 1287, 1291, 1295, 1297, 1300, + 1303, 1306, 1309, 1310, 1316, 1322, 1325, 1328, 1331, 1332, + 1336, 1340, 1344, 1345, 1347, 1350, 1352, 1355, 1358, 1361, + 1364, 1367, 1371, 1374, 1377, 1379, 1383, 1385, 1387, 1389, + 1391, 1395, 1397, 1400, 1401, 1403, 1406, 1407, 1409, 1413, + 1414, 1417, 1418, 1422, 1426, 1428, 1434, 1438, 1442, 1444, + 1446, 1450, 1452, 1455, 1457, 1462, 1468, 1474, 1481, 1485, + 1493, 1498, 1510, 1512, 1516, 1519, 1522, 1525, 1526, 1530, + 1532, 1534, 1537, 1540, 1543, 1546, 1548, 1549, 1551, 1554, + 1561, 1566, 1573, 1578, 1585, 1594, 1596, 1598, 1600, 1602, + 1605, 1607, 1610, 1612, 1615, 1617, 1619, 1621, 1623, 1627, + 1631, 1635, 1639, 1641, 1644, 1647, 1649, 1653, 1655, 1657, + 1659, 1663, 1665, 1667, 1668, 1670, 1672, 1674, 1684, 1687, + 1688, 1692, 1693, 1695, 1696, 1700, 1704, 1707, 1709, 1716, + 1720, 1724, 1727, 1730, 1732, 1733, 1739, 1742, 1745, 1746, + 1754, 1756, 1758, 1760, 1763, 1769, 1778, 1786, 1792, 1801, + 1809, 1814, 1819, 1821, 1825, 1827, 1829, 1833, 1835, 1839, + 1841, 1843, 1846, 1851, 1855, 1857, 1861, 1864, 1869, 1874, + 1883, 1895, 1905, 1913, 1914, 1918, 1922, 1924, 1926, 1930, + 1931, 1933, 1934, 1936, 1937, 1939, 1940, 1942, 1946, 1949, + 1950, 1953, 1954, 1956, 1957, 1959, 1961, 1963, 1967, 1971, + 1973, 1975, 1979, 1983, 1987, 1991, 1995, 1999, 2004, 2008, + 2011, 2013, 2015, 2017, 2021, 2023, 2027, 2029, 2031, 2033, + 2037, 2041, 2045, 2047, 2050, 2055, 2060, 2063, 2067, 2073, + 2079, 2081, 2083, 2087, 2088, 2100, 2112, 2123, 2136, 2138, + 2141, 2147, 2152, 2157, 2162, 2167, 2175, 2181, 2186, 2194, + 2201, 2211, 2221, 2226, 2228, 2230, 2232, 2234, 2236, 2238, + 2240, 2246, 2248, 2250, 2254, 2256, 2259, 2262, 2265, 2269, + 2271, 2275, 2284, 2290, 2291, 2293, 2296, 2298, 2302, 2304, + 2307, 2308, 2311, 2312, 2316, 2320, 2325, 2330, 2335, 2340, + 2344, 2347, 2349, 2351, 2352, 2354, 2356, 2357, 2360, 2362, + 2368, 2370, 2371, 2374, 2377, 2378, 2380, 2381, 2385, 2391, + 2393, 2397, 2402, 2406, 2408, 2410, 2411, 2414, 2417, 2418, + 2421, 2424, 2426, 2428, 2430, 2431, 2434, 2439, 2445, 2450, + 2453, 2457, 2459, 2461, 2463, 2466, 2469, 2471, 2474, 2478, + 2479, 2481, 2482, 2488, 2490, 2495, 2502, 2505, 2507, 2508, + 2513, 2514, 2516, 2518, 2522, 2527, 2528, 2530, 2532, 2535, + 2538, 2541, 2543, 2545, 2548, 2551, 2553, 2555, 2557, 2559, + 2561, 2563, 2567, 2571, 2572, 2574, 2578, 2580, 2583, 2585, + 2587, 2589, 2591, 2593, 2596, 2601, 2606, 2612, 2614, 2616, + 2619, 2620, 2623, 2624, 2626, 2630, 2632, 2633, 2635, 2638, + 2642, 2645, 2650, 2653, 2657, 2660, 2661, 2663, 2666, 2667, + 2672, 2678, 2680, 2683, 2686, 2687, 2689, 2693, 2695, 2698, + 2701, 2706, 2711, 2715, 2719, 2723, 2727, 2731, 2735, 2739, + 2741, 2746, 2751, 2761, 2771, 2775, 2776, 2779, 2782, 2783, + 2789, 2793, 2795, 2797, 2801, 2807, 2811, 2813, 2816, 2818, + 2822, 2828, 2830, 2833, 2837, 2842, 2848, 2853, 2859, 2864, + 2871, 2877, 2882, 2888, 2894, 2900, 2903, 2908, 2910, 2912, + 2913, 2915, 2920, 2926, 2931, 2932, 2935, 2938, 2941, 2943, + 2945, 2947, 2949, 2950, 2955, 2958, 2960, 2963, 2966, 2971, + 2974, 2981, 2984, 2986, 2990, 2995, 2996, 2999, 3000, 3003, + 3004, 3006, 3010, 3014, 3017, 3018, 3021, 3026, 3028, 3030, + 3032, 3033, 3036, 3040, 3046, 3053, 3056, 3060, 3063, 3069, + 3075, 3081, 3085, 3089, 3093, 3098, 3099, 3101, 3103, 3105, + 3107, 3109, 3112, 3117, 3119, 3121, 3123, 3125, 3128, 3132, + 3133, 3135, 3137, 3139, 3141, 3143, 3146, 3149, 3152, 3155, + 3158, 3160, 3164, 3165, 3167, 3169, 3171, 3173, 3179, 3182, + 3184, 3186, 3188, 3190, 3195, 3197, 3200, 3203, 3205, 3209, + 3213, 3216, 3218, 3219, 3225, 3228, 3234, 3237, 3239, 3243, + 3247, 3248, 3250, 3252, 3254, 3256, 3258, 3260, 3262, 3264, + 3266, 3268, 3270, 3272, 3274, 3276, 3278, 3280, 3282, 3284, + 3286, 3288, 3290, 3292, 3294, 3296, 3298, 3300, 3302, 3304, + 3306, 3308, 3310, 3312, 3314, 3316, 3318, 3320, 3322, 3324, + 3326, 3330, 3334, 3338, 3342, 3346, 3350, 3354, 3355, 3357, + 3361, 3365, 3371, 3374, 3377, 3381, 3385, 3389, 3393, 3397, + 3401, 3405, 3409, 3413, 3417, 3421, 3425, 3429, 3433, 3437, + 3440, 3443, 3447, 3451, 3454, 3457, 3461, 3465, 3471, 3476, + 3483, 3487, 3493, 3498, 3505, 3510, 3517, 3523, 3531, 3535, + 3538, 3543, 3547, 3550, 3555, 3559, 3563, 3567, 3571, 3576, + 3580, 3585, 3589, 3594, 3600, 3607, 3614, 3622, 3629, 3637, + 3644, 3652, 3656, 3661, 3666, 3673, 3675, 3680, 3685, 3691, + 3696, 3703, 3705, 3709, 3712, 3715, 3719, 3723, 3727, 3731, + 3735, 3739, 3743, 3747, 3751, 3755, 3759, 3763, 3767, 3771, + 3775, 3778, 3781, 3787, 3794, 3801, 3809, 3811, 3814, 3816, + 3818, 3820, 3823, 3826, 3831, 3835, 3837, 3839, 3841, 3843, + 3846, 3848, 3850, 3852, 3854, 3856, 3858, 3860, 3863, 3868, + 3871, 3875, 3879, 3884, 3888, 3894, 3901, 3909, 3919, 3927, + 3935, 3941, 3943, 3945, 3947, 3953, 3960, 3967, 3972, 3977, + 3982, 3987, 3994, 4000, 4006, 4012, 4017, 4024, 4029, 4037, + 4047, 4053, 4054, 4060, 4065, 4066, 4068, 4069, 4072, 4073, + 4075, 4079, 4083, 4086, 4089, 4090, 4097, 4099, 4100, 4104, + 4105, 4109, 4113, 4117, 4118, 4120, 4125, 4128, 4131, 4134, + 4137, 4140, 4144, 4147, 4150, 4154, 4155, 4160, 4164, 4166, + 4172, 4176, 4178, 4182, 4184, 4187, 4191, 4193, 4197, 4199, + 4202, 4204, 4205, 4207, 4209, 4211, 4213, 4215, 4217, 4219, + 4221, 4223, 4225, 4227, 4229, 4231, 4233, 4235, 4237, 4239, + 4241, 4243, 4245, 4250, 4252, 4257, 4259, 4264, 4266, 4269, + 4271, 4274, 4276, 4279, 4281, 4285, 4287, 4291, 4293, 4296, + 4298, 4302, 4304, 4307, 4309, 4310, 4312, 4316, 4318, 4322, + 4326, 4328, 4332, 4336, 4337, 4339, 4341, 4343, 4345, 4347, + 4349, 4351, 4353, 4355, 4357, 4359, 4361, 4363, 4365, 4367, + 4372, 4376, 4379, 4383, 4384, 4388, 4392, 4395, 4398, 4400, + 4401, 4404, 4407, 4411, 4414, 4416, 4418, 4422, 4424, 4426, + 4432, 4434, 4437, 4442, 4445, 4446, 4448, 4449, 4451, 4453, + 4456, 4460, 4466, 4474, 4482, 4484, 4485, 4486, 4489, 4490, + 4493, 4497, 4501, 4505, 4511, 4519, 4527, 4528, 4531, 4533, + 4534, 4536, 4537, 4539, 4543, 4545, 4548, 4552, 4555, 4557, + 4561, 4566, 4569, 4571, 4575, 4577, 4581, 4583, 4586, 4588, + 4589, 4593, 4595, 4599, 4601, 4604, 4609, 4612, 4613, 4617, + 4619, 4623, 4625, 4628, 4633, 4636, 4637, 4639, 4643, 4645, + 4649, 4651, 4654, 4656, 4660, 4662, 4664, 4667, 4669, 4671, + 4674, 4676, 4678, 4681, 4689, 4692, 4698, 4702, 4706, 4708, + 4710, 4712, 4714, 4716, 4718, 4720, 4722, 4724, 4726, 4728, + 4730, 4732, 4734, 4737, 4740, 4744, 4748, 4749, 4751, 4753, + 4755, 4761, 4765, 4766, 4768, 4770, 4772, 4774, 4776, 4778, + 4783, 4791, 4798, 4801, 4802, 4804, 4806, 4808, 4810, 4824, + 4841, 4843, 4846, 4847, 4849, 4850, 4852, 4853, 4856, 4857, + 4859, 4860, 4867, 4876, 4883, 4892, 4899, 4908, 4912, 4915, + 4917, 4918, 4925, 4932, 4934, 4936, 4938, 4940, 4942, 4944, + 4947, 4949, 4951, 4953, 4955, 4957, 4962, 4969, 4973, 4976, + 4981, 4985, 4991, 4993, 4994, 4996, 4998, 4999, 5001, 5003, + 5005, 5007, 5009, 5011, 5013, 5015, 5017, 5019, 5021, 5023, + 5025, 5027, 5029, 5031, 5033, 5035, 5037, 5039, 5041, 5043, + 5045, 5047, 5049, 5051, 5053, 5055, 5057, 5059, 5061, 5063, + 5065, 5067, 5069, 5071, 5073, 5075, 5079, 5081, 5083, 5085, + 5087, 5089, 5091, 5094, 5096, 5098, 5101, 5105, 5109, 5113, + 5117, 5119, 5123, 5127, 5130, 5134, 5138, 5140, 5142, 5144, + 5148, 5154, 5156, 5158, 5160, 5162, 5166, 5169, 5174, 5181, + 5188, 5189, 5191, 5193, 5195, 5196, 5199, 5202, 5207, 5214, + 5220, 5225, 5232, 5234, 5236, 5238, 5240, 5242, 5244, 5245, + 5247, 5251, 5253, 5254, 5262, 5266, 5268, 5271, 5275, 5278, + 5279, 5282, 5283, 5286, 5291, 5297, 5306, 5314, 5317, 5321, + 5327, 5329, 5330, 5333, 5334, 5336, 5337, 5340, 5342, 5346, + 5350, 5351, 5354, 5358, 5362, 5366, 5370, 5372, 5374, 5376, + 5379, 5383, 5386, 5389, 5392, 5397, 5400, 5404, 5409, 5413, + 5415, 5417, 5419, 5421, 5423, 5425, 5426, 5428, 5432, 5435, + 5445, 5458, 5470, 5483, 5498, 5502, 5507, 5512, 5513, 5521, + 5532, 5542, 5545, 5549, 5550, 5555, 5557, 5559, 5561, 5563, + 5565, 5567, 5569, 5571, 5573, 5575, 5577, 5579, 5581, 5583, + 5585, 5587, 5589, 5591, 5593, 5595, 5597, 5599, 5601, 5603, + 5605, 5607, 5609, 5611, 5613, 5615, 5617, 5619, 5621, 5623, + 5625, 5627, 5629, 5631, 5633, 5635, 5637, 5639, 5641, 5643, + 5645, 5647, 5649, 5651, 5653, 5655, 5657, 5659, 5661, 5663, + 5665, 5667, 5669, 5671, 5673, 5675, 5677, 5679, 5681, 5683, + 5685, 5687, 5689, 5691, 5693, 5695, 5697, 5699, 5701, 5703, + 5705, 5707, 5709, 5711, 5713, 5715, 5717, 5719, 5721, 5723, + 5725, 5727, 5729, 5731, 5733, 5735, 5737, 5739, 5741, 5743, + 5745, 5747, 5749, 5751, 5753, 5755, 5757, 5759, 5761, 5763, + 5765, 5767, 5769, 5771, 5773, 5775, 5777, 5779, 5781, 5783, + 5785, 5787, 5789, 5791, 5793, 5795, 5797, 5799, 5801, 5803, + 5805, 5807, 5809, 5811, 5813, 5815, 5817, 5819, 5821, 5823, + 5825, 5827, 5829, 5831, 5833, 5835, 5837, 5839, 5841, 5843, + 5845, 5847, 5849, 5851, 5853, 5855, 5857, 5859, 5861, 5863, + 5865, 5867, 5869, 5871, 5873, 5875, 5877, 5879, 5881, 5883, + 5885, 5887, 5889, 5891, 5893, 5895, 5897, 5899, 5901, 5903, + 5905, 5907, 5909, 5911, 5913, 5915, 5917, 5919, 5921, 5923, + 5925, 5927, 5929, 5931, 5933, 5935, 5937, 5939, 5941, 5943, + 5945, 5947, 5949, 5951, 5953, 5955, 5957, 5959, 5961, 5963, + 5965, 5967, 5969, 5971, 5973, 5975, 5977, 5979, 5981, 5983, + 5985, 5987, 5989, 5991, 5993, 5995, 5997, 5999, 6001, 6003, + 6005, 6007, 6009, 6011, 6013, 6015, 6017, 6019, 6021, 6023, + 6025, 6027, 6029, 6031, 6033, 6035, 6037, 6039, 6041, 6043, + 6045, 6047, 6049, 6051, 6053, 6055, 6057, 6059, 6061, 6063, + 6065, 6067, 6069, 6071, 6073, 6075, 6077, 6079, 6081, 6083, + 6085, 6087, 6089, 6091, 6093, 6095, 6097, 6099, 6101, 6103, + 6105, 6107, 6109, 6111, 6113, 6115, 6117, 6119, 6121, 6123, + 6125, 6127, 6129, 6131, 6133, 6135, 6137, 6139, 6141, 6143, + 6145, 6147, 6149, 6151, 6153, 6155, 6157, 6159, 6161, 6163, + 6165, 6167, 6169, 6171, 6173, 6175, 6177, 6179, 6181, 6183, + 6185, 6187, 6189, 6191, 6193, 6195, 6197, 6199, 6201, 6203, + 6205, 6207, 6209, 6211, 6213, 6215, 6217, 6219, 6221, 6223, + 6225, 6227, 6229, 6231, 6233, 6235, 6237, 6239, 6241, 6243, + 6245, 6247, 6249, 6251, 6253, 6255, 6257, 6259, 6261, 6263, + 6265, 6267, 6269, 6271, 6273, 6275, 6277, 6279, 6281, 6283, + 6285, 6287, 6289, 6291, 6293, 6295, 6297, 6299, 6301, 6303, + 6305, 6307, 6309, 6311, 6313, 6315, 6317, 6319, 6321, 6323, + 6325, 6327, 6329, 6331, 6333, 6335, 6337, 6339, 6341, 6343, + 6345, 6347, 6349, 6351, 6353, 6355, 6357, 6359, 6361, 6363, + 6365, 6367, 6369, 6371, 6373, 6375, 6377, 6379, 6381, 6383, + 6385, 6387, 6389, 6391, 6393, 6395, 6397, 6399, 6401, 6403, + 6405, 6407, 6409, 6411, 6413, 6415, 6417, 6419, 6421, 6423, + 6425, 6427, 6429, 6431, 6433, 6435, 6437, 6439, 6441, 6443, + 6445, 6447, 6449, 6451, 6453, 6455, 6457, 6459, 6461, 6463, + 6465, 6467, 6469, 6471, 6473, 6475, 6477, 6479, 6481, 6483, + 6485, 6487, 6489, 6491, 6493, 6495, 6497, 6499, 6501, 6503, + 6505, 6507, 6509, 6511, 6513, 6515, 6517, 6519, 6521, 6523, + 6525, 6527, 6529, 6531, 6533, 6535, 6537, 6539, 6541, 6543, + 6545, 6547, 6549, 6551, 6553, 6555, 6557, 6559, 6561, 6563, + 6565, 6567, 6569, 6571, 6573, 6575, 6577, 6579, 6581, 6583, + 6585, 6587, 6589, 6591, 6593, 6595, 6597, 6599, 6601, 6603, + 6605, 6607, 6609, 6611, 6613, 6615, 6617, 6619, 6621, 6623, + 6625, 6627, 6629, 6631, 6633, 6635, 6637, 6639, 6641, 6643, + 6645, 6647, 6649, 6651, 6653, 6655, 6657, 6659, 6661, 6663, + 6665, 6667, 6669, 6671, 6673, 6675, 6677, 6679, 6681, 6683, + 6685, 6687, 6689, 6691, 6693, 6695, 6697, 6699, 6701, 6703, + 6705, 6707, 6709, 6711, 6713, 6715, 6717, 6719, 6721, 6723, + 6725, 6727, 6729, 6731, 6733, 6735, 6737, 6739, 6741, 6743, + 6745, 6747, 6749, 6751, 6753, 6755, 6757, 6759, 6761, 6763, + 6765, 6767, 6769, 6771, 6773, 6775, 6777, 6779, 6781, 6783, + 6785, 6787, 6789, 6791, 6793, 6795, 6797, 6799, 6801, 6803, + 6805, 6807, 6809, 6811, 6813, 6815, 6817, 6819, 6821, 6823, + 6825, 6827, 6829, 6831 }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ static const yytype_int16 yyrhs[] = { 539, 0, -1, 540, -1, 540, 531, 541, -1, 541, - -1, 615, -1, 980, -1, 608, -1, 542, -1, 1018, - -1, 1019, -1, 1035, -1, 981, -1, 983, -1, 701, - -1, 1038, -1, 689, -1, 970, -1, 596, -1, 594, - -1, 622, -1, 589, -1, 557, -1, 1014, -1, 1020, - -1, 616, -1, 672, -1, 604, -1, 988, -1, 986, - -1, 987, -1, 973, -1, 568, -1, 1005, -1, 678, - -1, 593, -1, 967, -1, 566, -1, 714, -1, 618, - -1, 603, -1, 700, -1, 621, -1, 1009, -1, 1027, - -1, 999, -1, 1030, -1, 1036, -1, -1, 33, 427, - 809, 554, -1, 33, 427, 194, 154, 809, 554, -1, + -1, 615, -1, 982, -1, 608, -1, 542, -1, 1020, + -1, 1021, -1, 1037, -1, 983, -1, 985, -1, 703, + -1, 1040, -1, 691, -1, 972, -1, 596, -1, 594, + -1, 622, -1, 589, -1, 557, -1, 1016, -1, 1022, + -1, 616, -1, 674, -1, 604, -1, 990, -1, 988, + -1, 989, -1, 975, -1, 568, -1, 1007, -1, 680, + -1, 593, -1, 969, -1, 566, -1, 716, -1, 618, + -1, 603, -1, 702, -1, 621, -1, 1011, -1, 1029, + -1, 1001, -1, 1032, -1, 1038, -1, -1, 33, 427, + 811, 554, -1, 33, 427, 194, 154, 811, 554, -1, 33, 205, 558, 554, -1, 33, 205, 194, 154, 558, 554, -1, 33, 390, 558, 554, -1, 33, 390, 194, 154, 558, 554, -1, 33, 480, 558, 554, -1, 33, 480, 194, 154, 558, 554, -1, 545, -1, 543, 545, - -1, 395, 118, 858, -1, 138, 118, -1, 365, -1, - 365, 610, 611, -1, 395, 612, -1, 395, 178, 671, + -1, 395, 118, 860, -1, 138, 118, -1, 365, -1, + 365, 610, 611, -1, 395, 612, -1, 395, 178, 673, -1, 553, -1, 546, 532, 553, -1, 548, -1, 547, 548, -1, 530, 564, -1, 559, -1, 559, 547, -1, - 549, 649, -1, 549, 650, -1, 27, 550, -1, 27, + 549, 651, -1, 549, 652, -1, 27, 550, -1, 27, 194, 280, 154, 550, -1, 27, 83, 550, -1, 27, 83, 194, 280, 154, 550, -1, 395, 316, 60, 528, - 906, 529, -1, 363, 316, 60, -1, 395, 406, 60, - 528, 743, 529, -1, 363, 406, 60, -1, 33, 567, + 908, 529, -1, 363, 316, 60, -1, 395, 406, 60, + 528, 745, 529, -1, 363, 406, 60, -1, 33, 567, 559, 544, -1, 33, 567, 559, 138, 280, 285, -1, 33, 567, 559, 395, 280, 285, -1, 33, 567, 559, 395, 413, 614, -1, 33, 567, 559, 395, 637, -1, 33, 567, 559, 363, 637, -1, 33, 567, 559, 395, - 416, 559, -1, 33, 567, 559, 27, 178, 671, 41, + 416, 559, -1, 33, 567, 559, 27, 178, 673, 41, 193, 625, -1, 33, 567, 559, 543, -1, 33, 567, 559, 138, 193, -1, 33, 567, 559, 138, 193, 194, - 154, -1, 138, 567, 194, 154, 549, 676, -1, 138, - 567, 549, 676, -1, 33, 567, 559, 556, 451, 821, - 818, 552, -1, 33, 567, 559, 555, -1, 27, 639, - -1, 33, 94, 955, 623, -1, 470, 94, 955, -1, - 138, 94, 194, 154, 955, 676, -1, 138, 94, 955, - 676, -1, 395, 248, -1, 395, 460, -1, 395, 637, - -1, 363, 637, -1, 555, -1, 467, 858, -1, -1, - 633, -1, 395, 633, -1, 27, 633, -1, 138, 647, + 154, -1, 138, 567, 194, 154, 549, 678, -1, 138, + 567, 549, 678, -1, 33, 567, 559, 556, 451, 823, + 820, 552, -1, 33, 567, 559, 555, -1, 27, 639, + -1, 33, 94, 957, 623, -1, 470, 94, 957, -1, + 138, 94, 194, 154, 957, 678, -1, 138, 94, 957, + 678, -1, 395, 248, -1, 395, 460, -1, 395, 637, + -1, 363, 637, -1, 555, -1, 467, 860, -1, -1, + 633, -1, 395, 633, -1, 27, 633, -1, 138, 649, -1, 551, -1, 554, 532, 551, -1, 299, 528, 546, - 529, -1, 395, 108, -1, 395, -1, -1, 112, 955, - -1, 112, 332, 955, -1, 112, 31, -1, 112, 332, - 31, -1, 560, -1, 559, 562, -1, 3, -1, 1041, - -1, 1042, -1, 559, -1, 5, -1, 5, -1, 563, + 529, -1, 395, 108, -1, 395, -1, -1, 112, 957, + -1, 112, 332, 957, -1, 112, 31, -1, 112, 332, + 31, -1, 560, -1, 559, 562, -1, 3, -1, 1043, + -1, 1044, -1, 559, -1, 5, -1, 5, -1, 563, -1, 562, 563, -1, 530, 564, -1, 565, -1, 3, - -1, 1045, -1, 1041, -1, 1047, -1, 33, 379, 955, - 359, 440, 955, -1, 33, 427, 809, 359, 440, 955, - -1, 33, 427, 194, 154, 809, 359, 440, 955, -1, - 33, 390, 558, 359, 440, 955, -1, 33, 390, 194, - 154, 558, 359, 440, 955, -1, 33, 480, 558, 359, - 440, 955, -1, 33, 480, 194, 154, 558, 359, 440, - 955, -1, 33, 205, 558, 359, 440, 955, -1, 33, - 205, 194, 154, 558, 359, 440, 955, -1, 33, 427, - 809, 359, 567, 549, 440, 955, -1, 33, 427, 194, - 154, 809, 359, 567, 549, 440, 955, -1, 33, 427, - 809, 359, 94, 955, 440, 955, -1, 33, 427, 194, - 154, 809, 359, 94, 955, 440, 955, -1, 83, -1, + -1, 1047, -1, 1043, -1, 1049, -1, 33, 379, 957, + 359, 440, 957, -1, 33, 427, 811, 359, 440, 957, + -1, 33, 427, 194, 154, 811, 359, 440, 957, -1, + 33, 390, 558, 359, 440, 957, -1, 33, 390, 194, + 154, 558, 359, 440, 957, -1, 33, 480, 558, 359, + 440, 957, -1, 33, 480, 194, 154, 558, 359, 440, + 957, -1, 33, 205, 558, 359, 440, 957, -1, 33, + 205, 194, 154, 558, 359, 440, 957, -1, 33, 427, + 811, 359, 567, 549, 440, 957, -1, 33, 427, 194, + 154, 811, 359, 567, 549, 440, 957, -1, 33, 427, + 811, 359, 94, 957, 440, 957, -1, 33, 427, 194, + 154, 811, 359, 94, 957, 440, 957, -1, 83, -1, -1, 573, 215, 576, 222, 570, 571, 569, 577, 579, - -1, 714, -1, 309, 580, 472, 714, -1, 528, 584, - 529, 714, -1, 528, 584, 529, 309, 580, 472, 714, + -1, 716, -1, 309, 580, 472, 716, -1, 528, 584, + 529, 716, -1, 528, 584, 529, 309, 580, 472, 716, -1, 118, 473, -1, 558, -1, 558, 41, 559, -1, 60, 271, -1, 60, 327, -1, -1, 528, 587, 529, - 815, -1, 295, 94, 955, -1, -1, 726, -1, -1, - 559, 929, -1, 588, 517, 858, -1, 528, 581, 529, - 517, 858, -1, 300, 361, -1, 300, 195, -1, -1, - 295, 92, 572, 134, 464, 395, 586, 815, -1, 295, - 92, 572, 134, 281, -1, -1, 559, 582, 583, 745, - 746, -1, 870, 582, 583, 745, 746, -1, 528, 858, - 529, 582, 583, 745, 746, -1, 367, 935, -1, -1, + 817, -1, 295, 94, 957, -1, -1, 728, -1, -1, + 559, 931, -1, 588, 517, 860, -1, 528, 581, 529, + 517, 860, -1, 300, 361, -1, 300, 195, -1, -1, + 295, 92, 572, 134, 464, 395, 586, 817, -1, 295, + 92, 572, 134, 281, -1, -1, 559, 582, 583, 747, + 748, -1, 872, 582, 583, 747, 748, -1, 528, 860, + 529, 582, 583, 747, 748, -1, 367, 937, -1, -1, 466, -1, 426, -1, 588, -1, 581, 532, 588, -1, - 81, 962, -1, -1, 962, -1, -1, 574, -1, 584, + 81, 964, -1, -1, 964, -1, -1, 574, -1, 584, 532, 574, -1, 575, -1, 585, 532, 575, -1, 585, -1, 585, 532, -1, 578, -1, 587, 532, 578, -1, - 559, 929, -1, 101, 670, 451, 558, 41, 590, -1, - 101, 670, 451, 194, 280, 154, 558, 41, 590, -1, - 101, 300, 361, 670, 451, 558, 41, 590, -1, 145, - 715, -1, 145, 528, 591, 529, -1, 822, -1, 592, + 559, 931, -1, 101, 672, 451, 558, 41, 590, -1, + 101, 672, 451, 194, 280, 154, 558, 41, 590, -1, + 101, 300, 361, 672, 451, 558, 41, 590, -1, 145, + 717, -1, 145, 528, 591, 529, -1, 824, -1, 592, -1, -1, 561, -1, 592, 532, 561, -1, 329, 559, - -1, 329, 559, 517, 1004, -1, 329, 559, 528, 908, - 529, -1, 101, 670, 390, 558, 595, -1, 101, 670, + -1, 329, 559, 517, 1006, -1, 329, 559, 528, 910, + 529, -1, 101, 672, 390, 558, 595, -1, 101, 672, 390, 194, 280, 154, 558, 595, -1, 101, 300, 361, - 670, 390, 558, 595, -1, 609, -1, -1, 101, 598, + 672, 390, 558, 595, -1, 609, -1, -1, 101, 598, 386, 597, 599, 528, 602, 529, -1, 101, 598, 386, 194, 280, 154, 597, 599, 528, 602, 529, -1, 101, 300, 361, 598, 386, 597, 599, 528, 602, 529, -1, -1, 559, -1, -1, 434, -1, 320, -1, -1, 201, - 3, -1, 858, -1, 565, 600, -1, 601, -1, 602, - 532, 601, -1, 573, 464, 159, 659, -1, 153, 955, - 607, -1, 101, 670, 427, 1040, 41, 153, 955, 607, - 1039, -1, 101, 670, 427, 194, 280, 154, 1040, 41, - 153, 955, 607, 1039, -1, 858, -1, 965, 13, 858, + 3, -1, 860, -1, 565, 600, -1, 601, -1, 602, + 532, 601, -1, 573, 464, 159, 661, -1, 153, 957, + 607, -1, 101, 672, 427, 1042, 41, 153, 957, 607, + 1041, -1, 101, 672, 427, 194, 280, 154, 1042, 41, + 153, 957, 607, 1041, -1, 860, -1, 967, 13, 860, -1, 605, -1, 606, 532, 605, -1, 528, 606, 529, -1, -1, 33, 390, 558, 609, -1, 33, 390, 194, 154, 558, 609, -1, 612, -1, 609, 612, -1, 490, -1, 514, -1, -1, 4, -1, 519, 4, -1, 520, - 4, -1, 614, -1, 41, 825, -1, 61, 611, -1, + 4, -1, 614, -1, 41, 827, -1, 61, 611, -1, 107, -1, 278, 107, -1, 204, 613, 611, -1, 255, 611, -1, 266, 611, -1, 278, 255, -1, 278, 266, - -1, 310, 60, 962, -1, 390, 271, 962, -1, 411, + -1, 310, 60, 964, -1, 390, 271, 964, -1, 411, 610, 611, -1, 365, -1, 365, 610, 611, -1, 60, - -1, -1, 958, -1, 519, 958, -1, 520, 958, -1, + -1, -1, 960, -1, 519, 960, -1, 520, 960, -1, 33, 109, 559, 359, 440, 559, -1, 33, 109, 194, 154, 559, 359, 440, 559, -1, 138, 598, 386, 559, 617, -1, 138, 598, 386, 194, 154, 559, 617, -1, @@ -2092,589 +2093,592 @@ static const yytype_int16 yyrhs[] = -1, 411, 619, 620, -1, 87, 619, -1, 144, 619, -1, 372, 619, -1, 493, -1, 442, -1, -1, 347, 296, -1, 347, 495, -1, -1, 465, 558, -1, 101, - 670, 427, 558, 528, 657, 529, 644, 636, -1, 101, - 670, 427, 194, 280, 154, 558, 528, 657, 529, 644, - 636, -1, 101, 300, 361, 670, 427, 558, 528, 657, - 529, 644, 636, -1, -1, 623, 648, -1, 665, -1, - 1047, -1, 900, -1, 611, -1, 561, -1, 279, -1, - 528, 609, 529, -1, -1, 561, -1, 278, 26, -1, - 366, -1, 64, -1, 395, 285, -1, 395, 118, -1, - 94, 955, 629, -1, 629, -1, 643, -1, 81, 962, - -1, 280, 285, -1, 285, -1, 457, 656, -1, 335, - 229, 656, -1, 75, 528, 858, 529, 638, -1, 467, - 89, 955, -1, 118, 859, -1, 353, 558, 659, 668, - 635, -1, 482, -1, 417, -1, 630, -1, -1, 178, - 671, 41, 193, 625, -1, 178, 671, 41, 528, 858, - 529, 631, -1, 41, 528, 858, 529, 631, -1, 647, - 626, -1, 295, 464, 627, -1, 634, -1, 661, -1, - 634, 661, -1, 661, 634, -1, -1, 295, 87, 138, - -1, 295, 87, 123, 375, -1, 295, 87, 334, 375, - -1, -1, 528, 641, 529, -1, 278, 207, -1, -1, - 94, 955, 666, -1, 666, -1, 86, -1, 95, -1, - 119, -1, 193, -1, 206, -1, 413, -1, 416, -1, - 31, -1, 662, -1, 641, 532, 662, -1, 467, 205, - 653, -1, 120, -1, 280, 120, -1, 209, 121, -1, - 209, 197, -1, 490, 637, -1, 490, 293, -1, 492, - 293, -1, -1, 528, 652, 529, -1, 646, 203, 640, - -1, 646, 151, 640, -1, -1, 565, -1, 280, 120, - -1, 120, -1, 209, 197, -1, 209, 121, -1, 280, - 469, -1, 278, 207, -1, 822, 660, -1, 821, 632, - 660, -1, 559, 649, -1, 559, 650, -1, 655, -1, - 652, 532, 655, -1, 559, -1, 651, -1, 669, -1, - 639, -1, 565, 517, 624, -1, 565, -1, 490, 645, - -1, -1, 667, -1, 667, 532, -1, -1, 559, -1, - 528, 663, 529, -1, -1, 660, 628, -1, -1, 295, - 123, 627, -1, 565, 517, 624, -1, 565, -1, 565, - 530, 565, 517, 624, -1, 565, 530, 565, -1, 658, - -1, 663, 532, 658, -1, 663, -1, 663, 532, -1, - 822, -1, 959, 963, 523, 451, -1, 396, 959, 963, - 523, 451, -1, 75, 528, 858, 529, 623, -1, 457, - 528, 664, 529, 656, 623, -1, 457, 642, 623, -1, - 335, 229, 528, 664, 529, 656, 623, -1, 335, 229, - 642, 623, -1, 171, 229, 528, 664, 529, 353, 558, - 659, 668, 635, 623, -1, 654, -1, 667, 532, 654, - -1, 252, 175, -1, 252, 314, -1, 252, 401, -1, - -1, 240, 558, 646, -1, 434, -1, 432, -1, 244, - 434, -1, 244, 432, -1, 180, 434, -1, 180, 432, - -1, 460, -1, -1, 34, -1, 60, 118, -1, 138, - 673, 194, 154, 675, 676, -1, 138, 673, 675, 676, - -1, 138, 674, 194, 154, 952, 676, -1, 138, 674, - 952, 676, -1, 138, 677, 955, 295, 962, 676, -1, - 138, 677, 194, 154, 955, 295, 962, 676, -1, 427, - -1, 390, -1, 176, -1, 249, -1, 249, 427, -1, - 480, -1, 254, 480, -1, 205, -1, 171, 427, -1, - 82, -1, 98, -1, 379, -1, 413, -1, 435, 383, - 313, -1, 435, 383, 130, -1, 435, 383, 433, -1, - 435, 383, 91, -1, 451, -1, 25, 257, -1, 148, - 445, -1, 158, -1, 171, 108, 494, -1, 341, -1, - 393, -1, 962, -1, 675, 532, 962, -1, 64, -1, - 366, -1, -1, 326, -1, 376, -1, 445, -1, 573, - 256, 222, 1015, 467, 792, 808, 688, 579, -1, 37, - 858, -1, -1, 528, 584, 529, -1, -1, 521, -1, - -1, 464, 395, 586, -1, 464, 395, 521, -1, 464, - 571, -1, 123, -1, 215, 680, 473, 528, 906, 529, - -1, 215, 571, 681, -1, 215, 118, 473, -1, 134, - 281, -1, 146, 683, -1, 858, -1, -1, 486, 253, - 679, 436, 682, -1, 60, 407, -1, 60, 431, -1, - -1, 486, 280, 253, 685, 679, 436, 682, -1, 684, - -1, 686, -1, 687, -1, 687, 688, -1, 101, 670, - 696, 558, 693, -1, 101, 670, 696, 194, 280, 154, - 558, 693, -1, 101, 300, 361, 670, 696, 558, 693, - -1, 101, 670, 696, 558, 695, -1, 101, 670, 696, - 194, 280, 154, 558, 695, -1, 101, 300, 361, 670, - 696, 558, 695, -1, 697, 41, 427, 716, -1, 697, - 41, 427, 715, -1, 691, -1, 692, 532, 691, -1, - 690, -1, 692, -1, 697, 41, 858, -1, 694, -1, - 695, 532, 694, -1, 176, -1, 249, -1, 528, 529, - -1, 528, 698, 532, 529, -1, 528, 698, 529, -1, - 699, -1, 698, 532, 699, -1, 965, 821, -1, 965, - 821, 13, 858, -1, 965, 821, 14, 858, -1, 573, - 464, 1015, 395, 586, 788, 1016, 579, -1, 99, 711, - 558, 659, 709, 703, 707, 713, 704, 610, 708, -1, - 99, 528, 714, 529, 440, 707, 713, 610, 708, -1, - 99, 174, 109, 559, 440, 559, 702, -1, -1, 528, - 379, 529, -1, 528, 108, 529, -1, 174, -1, 440, - -1, 705, 125, 561, -1, -1, 467, -1, -1, 41, - -1, -1, 340, -1, -1, 710, -1, 528, 1025, 529, - -1, 490, 293, -1, -1, 710, 712, -1, -1, 56, - -1, -1, 56, -1, 293, -1, 173, -1, 124, 706, - 561, -1, 285, 706, 561, -1, 103, -1, 189, -1, - 345, 706, 561, -1, 147, 706, 561, -1, 170, 345, - 663, -1, 170, 345, 521, -1, 315, 60, 663, -1, - 315, 60, 521, -1, 170, 280, 285, 663, -1, 170, - 285, 663, -1, 142, 561, -1, 561, -1, 414, -1, - 415, -1, 3, 530, 559, -1, 3, -1, 528, 858, - 529, -1, 863, -1, 716, -1, 715, -1, 528, 716, - 529, -1, 528, 715, 529, -1, 528, 1030, 529, -1, - 719, -1, 717, 742, -1, 717, 741, 779, 748, -1, - 717, 741, 747, 780, -1, 726, 717, -1, 726, 717, - 742, -1, 726, 717, 741, 779, 748, -1, 726, 717, - 741, 747, 780, -1, 719, -1, 715, -1, 388, 739, - 934, -1, -1, 388, 739, 934, 733, 788, 815, 768, - 777, 876, 778, 753, -1, 388, 738, 936, 733, 788, - 815, 768, 777, 876, 778, 753, -1, 174, 789, 718, - 733, 815, 768, 777, 876, 778, 753, -1, 174, 789, - 388, 738, 936, 733, 815, 768, 777, 876, 778, 753, - -1, 787, -1, 427, 809, -1, 717, 456, 736, 737, - 717, -1, 717, 456, 736, 717, -1, 717, 220, 736, - 717, -1, 717, 149, 736, 717, -1, 721, 792, 467, - 936, -1, 721, 792, 467, 936, 183, 60, 954, -1, - 721, 792, 183, 60, 954, -1, 721, 792, 295, 725, - -1, 721, 792, 295, 725, 183, 60, 954, -1, 721, - 792, 295, 725, 467, 936, -1, 721, 792, 295, 725, - 467, 936, 183, 60, 954, -1, 722, 792, 295, 936, - 222, 271, 955, 720, 954, -1, 722, 792, 295, 936, - -1, 472, -1, 473, -1, 321, -1, 323, -1, 462, - -1, 322, -1, 859, -1, 859, 201, 528, 716, 529, - -1, 795, -1, 723, -1, 724, 532, 723, -1, 724, - -1, 724, 532, -1, 490, 727, -1, 514, 727, -1, - 490, 351, 727, -1, 728, -1, 727, 532, 728, -1, - 955, 964, 729, 41, 732, 528, 969, 529, -1, 467, - 229, 528, 730, 529, -1, -1, 731, -1, 731, 532, - -1, 926, -1, 731, 532, 926, -1, 254, -1, 280, - 254, -1, -1, 222, 734, -1, -1, 434, 735, 558, - -1, 432, 735, 558, -1, 244, 434, 735, 558, -1, - 244, 432, 735, 558, -1, 180, 434, 735, 558, -1, - 180, 432, 735, 558, -1, 460, 735, 558, -1, 427, - 558, -1, 558, -1, 427, -1, -1, 31, -1, 133, - -1, -1, 60, 271, -1, 133, -1, 133, 295, 528, - 906, 529, -1, 31, -1, -1, 195, 287, -1, 364, - 287, -1, -1, 742, -1, -1, 301, 60, 743, -1, - 301, 60, 31, 745, 746, -1, 744, -1, 743, 532, - 744, -1, 858, 467, 900, 746, -1, 858, 745, 746, - -1, 42, -1, 127, -1, -1, 513, 166, -1, 513, - 234, -1, -1, 749, 750, -1, 750, 749, -1, 749, - -1, 750, -1, 747, -1, -1, 241, 762, -1, 241, - 762, 532, 763, -1, 164, 767, 764, 766, 296, -1, - 164, 767, 766, 296, -1, 292, 763, -1, 292, 764, - 766, -1, 4, -1, 9, -1, 863, -1, 751, 523, - -1, 751, 319, -1, 751, -1, 751, 375, -1, 467, - 377, 755, -1, -1, 559, -1, -1, 754, 528, 752, - 529, 758, -1, 752, -1, 752, 528, 559, 529, -1, - 752, 528, 559, 532, 9, 529, -1, 429, 755, -1, - 756, -1, -1, 360, 528, 9, 529, -1, -1, 439, - -1, 479, -1, 759, 14, 858, -1, 47, 528, 760, - 529, -1, -1, 858, -1, 31, -1, 858, 523, -1, - 4, 319, -1, 9, 319, -1, 858, -1, 860, -1, - 519, 765, -1, 520, 765, -1, 958, -1, 4, -1, - 374, -1, 375, -1, 166, -1, 277, -1, 183, 60, - 770, -1, 183, 60, 31, -1, -1, 771, -1, 769, - 532, 771, -1, 769, -1, 769, 532, -1, 858, -1, - 772, -1, 774, -1, 773, -1, 775, -1, 528, 529, - -1, 373, 528, 906, 529, -1, 104, 528, 906, 529, - -1, 184, 397, 528, 770, 529, -1, 184, -1, 185, - -1, 188, 858, -1, -1, 342, 858, -1, -1, 781, - -1, 169, 347, 296, -1, 779, -1, -1, 782, -1, - 781, 782, -1, 783, 784, 785, -1, 169, 464, -1, - 169, 278, 229, 464, -1, 169, 398, -1, 169, 229, - 398, -1, 290, 951, -1, -1, 284, -1, 402, 247, - -1, -1, 473, 528, 906, 529, -1, 786, 532, 528, - 906, 529, -1, 786, -1, 786, 532, -1, 174, 790, - -1, -1, 792, -1, 789, 532, 792, -1, 789, -1, - 789, 532, -1, 560, 19, -1, 809, 804, 761, 757, - -1, 791, 809, 761, 757, -1, 810, 805, 757, -1, - 791, 810, 757, -1, 787, 803, 757, -1, 235, 810, - 805, -1, 715, 804, 757, -1, 791, 715, 757, -1, - 235, 715, 804, -1, 802, -1, 528, 802, 529, 803, - -1, 791, 528, 802, 529, -1, 792, 321, 528, 936, - 169, 798, 793, 529, 804, -1, 792, 462, 794, 528, - 799, 169, 801, 529, 804, -1, 183, 60, 953, -1, - -1, 202, 287, -1, 150, 287, -1, -1, 859, 201, - 528, 936, 529, -1, 859, 201, 560, -1, 861, -1, - 864, -1, 528, 904, 529, -1, 796, 201, 528, 936, - 529, -1, 796, 201, 560, -1, 797, -1, 798, 797, - -1, 560, -1, 528, 953, 529, -1, 799, 201, 528, - 936, 529, -1, 800, -1, 801, 800, -1, 528, 802, - 529, -1, 792, 102, 227, 792, -1, 792, 806, 227, - 792, 808, -1, 792, 227, 792, 808, -1, 792, 274, - 806, 227, 792, -1, 792, 274, 227, 792, -1, 792, - 43, 806, 227, 792, 808, -1, 792, 43, 227, 792, - 808, -1, 792, 328, 227, 792, -1, 792, 38, 227, - 792, 808, -1, 792, 389, 227, 792, 808, -1, 41, - 560, 528, 953, 529, -1, 41, 560, -1, 559, 528, - 953, 529, -1, 559, -1, 803, -1, -1, 803, -1, - 41, 528, 816, 529, -1, 41, 560, 528, 816, 529, - -1, 559, 528, 816, 529, -1, -1, 175, 807, -1, - 238, 807, -1, 370, 807, -1, 389, -1, 38, -1, - 211, -1, 305, -1, -1, 467, 528, 953, 529, -1, - 295, 858, -1, 558, -1, 558, 521, -1, 296, 558, - -1, 296, 528, 558, 529, -1, 870, 814, -1, 375, - 174, 528, 812, 529, 814, -1, 870, 813, -1, 811, - -1, 812, 532, 811, -1, 41, 528, 816, 529, -1, - -1, 514, 302, -1, -1, 487, 858, -1, -1, 817, - -1, 816, 532, 817, -1, 560, 822, 818, -1, 81, - 962, -1, -1, 559, 822, -1, 819, 532, 559, 822, - -1, 374, -1, 420, -1, 822, -1, -1, 825, 824, - -1, 396, 825, 824, -1, 825, 40, 526, 958, 527, - -1, 396, 825, 40, 526, 958, 527, -1, 825, 40, - -1, 396, 825, 40, -1, 823, 824, -1, 820, 528, - 819, 529, 824, -1, 250, 528, 910, 529, 824, -1, - 456, 528, 819, 529, 824, -1, 3, 530, 3, -1, - 823, 530, 3, -1, 824, 526, 527, -1, 824, 526, - 958, 527, -1, -1, 827, -1, 829, -1, 831, -1, - 835, -1, 841, -1, 842, 857, -1, 842, 528, 958, - 529, -1, 829, -1, 832, -1, 836, -1, 841, -1, - 961, 828, -1, 528, 907, 529, -1, -1, 218, -1, - 219, -1, 403, -1, 55, -1, 348, -1, 167, 830, - -1, 137, 331, -1, 116, 828, -1, 113, 828, -1, - 288, 828, -1, 58, -1, 528, 958, 529, -1, -1, - 833, -1, 834, -1, 833, -1, 834, -1, 57, 840, - 528, 906, 529, -1, 57, 840, -1, 837, -1, 838, - -1, 837, -1, 838, -1, 839, 528, 958, 529, -1, - 839, -1, 73, 840, -1, 72, 840, -1, 474, -1, - 273, 73, 840, -1, 273, 72, 840, -1, 275, 840, - -1, 477, -1, -1, 439, 528, 958, 529, 843, -1, - 439, 843, -1, 438, 528, 958, 529, 843, -1, 438, - 843, -1, 221, -1, 514, 438, 511, -1, 492, 438, - 511, -1, -1, 508, -1, 509, -1, 268, -1, 269, - -1, 110, -1, 111, -1, 191, -1, 192, -1, 264, - -1, 265, -1, 384, -1, 385, -1, 262, -1, 263, - -1, 258, -1, 259, -1, 484, -1, 485, -1, 343, - -1, 344, -1, 114, -1, 115, -1, 70, -1, 69, - -1, 261, -1, 260, -1, 844, -1, 845, -1, 846, + 672, 427, 558, 528, 659, 529, 644, 646, 636, -1, + 101, 672, 427, 194, 280, 154, 558, 528, 659, 529, + 644, 646, 636, -1, 101, 300, 361, 672, 427, 558, + 528, 659, 529, 644, 646, 636, -1, -1, 623, 650, + -1, 667, -1, 1049, -1, 902, -1, 611, -1, 561, + -1, 279, -1, 528, 609, 529, -1, -1, 561, -1, + 278, 26, -1, 366, -1, 64, -1, 395, 285, -1, + 395, 118, -1, 94, 957, 629, -1, 629, -1, 643, + -1, 81, 964, -1, 280, 285, -1, 285, -1, 457, + 658, -1, 335, 229, 658, -1, 75, 528, 860, 529, + 638, -1, 467, 89, 957, -1, 118, 861, -1, 353, + 558, 661, 670, 635, -1, 482, -1, 417, -1, 630, + -1, -1, 178, 673, 41, 193, 625, -1, 178, 673, + 41, 528, 860, 529, 631, -1, 41, 528, 860, 529, + 631, -1, 649, 626, -1, 295, 464, 627, -1, 634, + -1, 663, -1, 634, 663, -1, 663, 634, -1, -1, + 295, 87, 138, -1, 295, 87, 123, 375, -1, 295, + 87, 334, 375, -1, -1, 528, 641, 529, -1, 278, + 207, -1, -1, 94, 957, 668, -1, 668, -1, 86, + -1, 95, -1, 119, -1, 193, -1, 206, -1, 413, + -1, 416, -1, 31, -1, 664, -1, 641, 532, 664, + -1, 467, 205, 655, -1, 120, -1, 280, 120, -1, + 209, 121, -1, 209, 197, -1, 644, 645, -1, -1, + 316, 60, 528, 908, 529, -1, 406, 60, 528, 908, + 529, -1, 490, 637, -1, 490, 293, -1, 492, 293, + -1, -1, 528, 654, 529, -1, 648, 203, 640, -1, + 648, 151, 640, -1, -1, 565, -1, 280, 120, -1, + 120, -1, 209, 197, -1, 209, 121, -1, 280, 469, + -1, 278, 207, -1, 824, 662, -1, 823, 632, 662, + -1, 559, 651, -1, 559, 652, -1, 657, -1, 654, + 532, 657, -1, 559, -1, 653, -1, 671, -1, 639, + -1, 565, 517, 624, -1, 565, -1, 490, 647, -1, + -1, 669, -1, 669, 532, -1, -1, 559, -1, 528, + 665, 529, -1, -1, 662, 628, -1, -1, 295, 123, + 627, -1, 565, 517, 860, -1, 565, -1, 565, 530, + 565, 517, 624, -1, 565, 530, 565, -1, 561, 517, + 860, -1, 561, -1, 660, -1, 665, 532, 660, -1, + 665, -1, 665, 532, -1, 824, -1, 961, 965, 523, + 451, -1, 396, 961, 965, 523, 451, -1, 75, 528, + 860, 529, 623, -1, 457, 528, 666, 529, 658, 623, + -1, 457, 642, 623, -1, 335, 229, 528, 666, 529, + 658, 623, -1, 335, 229, 642, 623, -1, 171, 229, + 528, 666, 529, 353, 558, 661, 670, 635, 623, -1, + 656, -1, 669, 532, 656, -1, 252, 175, -1, 252, + 314, -1, 252, 401, -1, -1, 240, 558, 648, -1, + 434, -1, 432, -1, 244, 434, -1, 244, 432, -1, + 180, 434, -1, 180, 432, -1, 460, -1, -1, 34, + -1, 60, 118, -1, 138, 675, 194, 154, 677, 678, + -1, 138, 675, 677, 678, -1, 138, 676, 194, 154, + 954, 678, -1, 138, 676, 954, 678, -1, 138, 679, + 957, 295, 964, 678, -1, 138, 679, 194, 154, 957, + 295, 964, 678, -1, 427, -1, 390, -1, 176, -1, + 249, -1, 249, 427, -1, 480, -1, 254, 480, -1, + 205, -1, 171, 427, -1, 82, -1, 98, -1, 379, + -1, 413, -1, 435, 383, 313, -1, 435, 383, 130, + -1, 435, 383, 433, -1, 435, 383, 91, -1, 451, + -1, 25, 257, -1, 148, 445, -1, 158, -1, 171, + 108, 494, -1, 341, -1, 393, -1, 964, -1, 677, + 532, 964, -1, 64, -1, 366, -1, -1, 326, -1, + 376, -1, 445, -1, 573, 256, 222, 1017, 467, 794, + 810, 690, 579, -1, 37, 860, -1, -1, 528, 584, + 529, -1, -1, 521, -1, -1, 464, 395, 586, -1, + 464, 395, 521, -1, 464, 571, -1, 123, -1, 215, + 682, 473, 528, 908, 529, -1, 215, 571, 683, -1, + 215, 118, 473, -1, 134, 281, -1, 146, 685, -1, + 860, -1, -1, 486, 253, 681, 436, 684, -1, 60, + 407, -1, 60, 431, -1, -1, 486, 280, 253, 687, + 681, 436, 684, -1, 686, -1, 688, -1, 689, -1, + 689, 690, -1, 101, 672, 698, 558, 695, -1, 101, + 672, 698, 194, 280, 154, 558, 695, -1, 101, 300, + 361, 672, 698, 558, 695, -1, 101, 672, 698, 558, + 697, -1, 101, 672, 698, 194, 280, 154, 558, 697, + -1, 101, 300, 361, 672, 698, 558, 697, -1, 699, + 41, 427, 718, -1, 699, 41, 427, 717, -1, 693, + -1, 694, 532, 693, -1, 692, -1, 694, -1, 699, + 41, 860, -1, 696, -1, 697, 532, 696, -1, 176, + -1, 249, -1, 528, 529, -1, 528, 700, 532, 529, + -1, 528, 700, 529, -1, 701, -1, 700, 532, 701, + -1, 967, 823, -1, 967, 823, 13, 860, -1, 967, + 823, 14, 860, -1, 573, 464, 1017, 395, 586, 790, + 1018, 579, -1, 99, 713, 558, 661, 711, 705, 709, + 715, 706, 610, 710, -1, 99, 528, 716, 529, 440, + 709, 715, 610, 710, -1, 99, 174, 109, 559, 440, + 559, 704, -1, -1, 528, 379, 529, -1, 528, 108, + 529, -1, 174, -1, 440, -1, 707, 125, 561, -1, + -1, 467, -1, -1, 41, -1, -1, 340, -1, -1, + 712, -1, 528, 1027, 529, -1, 490, 293, -1, -1, + 712, 714, -1, -1, 56, -1, -1, 56, -1, 293, + -1, 173, -1, 124, 708, 561, -1, 285, 708, 561, + -1, 103, -1, 189, -1, 345, 708, 561, -1, 147, + 708, 561, -1, 170, 345, 665, -1, 170, 345, 521, + -1, 315, 60, 665, -1, 315, 60, 521, -1, 170, + 280, 285, 665, -1, 170, 285, 665, -1, 142, 561, + -1, 561, -1, 414, -1, 415, -1, 3, 530, 559, + -1, 3, -1, 528, 860, 529, -1, 865, -1, 718, + -1, 717, -1, 528, 718, 529, -1, 528, 717, 529, + -1, 528, 1032, 529, -1, 721, -1, 719, 744, -1, + 719, 743, 781, 750, -1, 719, 743, 749, 782, -1, + 728, 719, -1, 728, 719, 744, -1, 728, 719, 743, + 781, 750, -1, 728, 719, 743, 749, 782, -1, 721, + -1, 717, -1, 388, 741, 936, -1, -1, 388, 741, + 936, 735, 790, 817, 770, 779, 878, 780, 755, -1, + 388, 740, 938, 735, 790, 817, 770, 779, 878, 780, + 755, -1, 174, 791, 720, 735, 817, 770, 779, 878, + 780, 755, -1, 174, 791, 388, 740, 938, 735, 817, + 770, 779, 878, 780, 755, -1, 789, -1, 427, 811, + -1, 719, 456, 738, 739, 719, -1, 719, 456, 738, + 719, -1, 719, 220, 738, 719, -1, 719, 149, 738, + 719, -1, 723, 794, 467, 938, -1, 723, 794, 467, + 938, 183, 60, 956, -1, 723, 794, 183, 60, 956, + -1, 723, 794, 295, 727, -1, 723, 794, 295, 727, + 183, 60, 956, -1, 723, 794, 295, 727, 467, 938, + -1, 723, 794, 295, 727, 467, 938, 183, 60, 956, + -1, 724, 794, 295, 938, 222, 271, 957, 722, 956, + -1, 724, 794, 295, 938, -1, 472, -1, 473, -1, + 321, -1, 323, -1, 462, -1, 322, -1, 861, -1, + 861, 201, 528, 718, 529, -1, 797, -1, 725, -1, + 726, 532, 725, -1, 726, -1, 726, 532, -1, 490, + 729, -1, 514, 729, -1, 490, 351, 729, -1, 730, + -1, 729, 532, 730, -1, 957, 966, 731, 41, 734, + 528, 971, 529, -1, 467, 229, 528, 732, 529, -1, + -1, 733, -1, 733, 532, -1, 928, -1, 733, 532, + 928, -1, 254, -1, 280, 254, -1, -1, 222, 736, + -1, -1, 434, 737, 558, -1, 432, 737, 558, -1, + 244, 434, 737, 558, -1, 244, 432, 737, 558, -1, + 180, 434, 737, 558, -1, 180, 432, 737, 558, -1, + 460, 737, 558, -1, 427, 558, -1, 558, -1, 427, + -1, -1, 31, -1, 133, -1, -1, 60, 271, -1, + 133, -1, 133, 295, 528, 908, 529, -1, 31, -1, + -1, 195, 287, -1, 364, 287, -1, -1, 744, -1, + -1, 301, 60, 745, -1, 301, 60, 31, 747, 748, + -1, 746, -1, 745, 532, 746, -1, 860, 467, 902, + 748, -1, 860, 747, 748, -1, 42, -1, 127, -1, + -1, 513, 166, -1, 513, 234, -1, -1, 751, 752, + -1, 752, 751, -1, 751, -1, 752, -1, 749, -1, + -1, 241, 764, -1, 241, 764, 532, 765, -1, 164, + 769, 766, 768, 296, -1, 164, 769, 768, 296, -1, + 292, 765, -1, 292, 766, 768, -1, 4, -1, 9, + -1, 865, -1, 753, 523, -1, 753, 319, -1, 753, + -1, 753, 375, -1, 467, 377, 757, -1, -1, 559, + -1, -1, 756, 528, 754, 529, 760, -1, 754, -1, + 754, 528, 559, 529, -1, 754, 528, 559, 532, 9, + 529, -1, 429, 757, -1, 758, -1, -1, 360, 528, + 9, 529, -1, -1, 439, -1, 479, -1, 761, 14, + 860, -1, 47, 528, 762, 529, -1, -1, 860, -1, + 31, -1, 860, 523, -1, 4, 319, -1, 9, 319, + -1, 860, -1, 862, -1, 519, 767, -1, 520, 767, + -1, 960, -1, 4, -1, 374, -1, 375, -1, 166, + -1, 277, -1, 183, 60, 772, -1, 183, 60, 31, + -1, -1, 773, -1, 771, 532, 773, -1, 771, -1, + 771, 532, -1, 860, -1, 774, -1, 776, -1, 775, + -1, 777, -1, 528, 529, -1, 373, 528, 908, 529, + -1, 104, 528, 908, 529, -1, 184, 397, 528, 772, + 529, -1, 184, -1, 185, -1, 188, 860, -1, -1, + 342, 860, -1, -1, 783, -1, 169, 347, 296, -1, + 781, -1, -1, 784, -1, 783, 784, -1, 785, 786, + 787, -1, 169, 464, -1, 169, 278, 229, 464, -1, + 169, 398, -1, 169, 229, 398, -1, 290, 953, -1, + -1, 284, -1, 402, 247, -1, -1, 473, 528, 908, + 529, -1, 788, 532, 528, 908, 529, -1, 788, -1, + 788, 532, -1, 174, 792, -1, -1, 794, -1, 791, + 532, 794, -1, 791, -1, 791, 532, -1, 560, 19, + -1, 811, 806, 763, 759, -1, 793, 811, 763, 759, + -1, 812, 807, 759, -1, 793, 812, 759, -1, 789, + 805, 759, -1, 235, 812, 807, -1, 717, 806, 759, + -1, 793, 717, 759, -1, 235, 717, 806, -1, 804, + -1, 528, 804, 529, 805, -1, 793, 528, 804, 529, + -1, 794, 321, 528, 938, 169, 800, 795, 529, 806, + -1, 794, 462, 796, 528, 801, 169, 803, 529, 806, + -1, 183, 60, 955, -1, -1, 202, 287, -1, 150, + 287, -1, -1, 861, 201, 528, 938, 529, -1, 861, + 201, 560, -1, 863, -1, 866, -1, 528, 906, 529, + -1, 798, 201, 528, 938, 529, -1, 798, 201, 560, + -1, 799, -1, 800, 799, -1, 560, -1, 528, 955, + 529, -1, 801, 201, 528, 938, 529, -1, 802, -1, + 803, 802, -1, 528, 804, 529, -1, 794, 102, 227, + 794, -1, 794, 808, 227, 794, 810, -1, 794, 227, + 794, 810, -1, 794, 274, 808, 227, 794, -1, 794, + 274, 227, 794, -1, 794, 43, 808, 227, 794, 810, + -1, 794, 43, 227, 794, 810, -1, 794, 328, 227, + 794, -1, 794, 38, 227, 794, 810, -1, 794, 389, + 227, 794, 810, -1, 41, 560, 528, 955, 529, -1, + 41, 560, -1, 559, 528, 955, 529, -1, 559, -1, + 805, -1, -1, 805, -1, 41, 528, 818, 529, -1, + 41, 560, 528, 818, 529, -1, 559, 528, 818, 529, + -1, -1, 175, 809, -1, 238, 809, -1, 370, 809, + -1, 389, -1, 38, -1, 211, -1, 305, -1, -1, + 467, 528, 955, 529, -1, 295, 860, -1, 558, -1, + 558, 521, -1, 296, 558, -1, 296, 528, 558, 529, + -1, 872, 816, -1, 375, 174, 528, 814, 529, 816, + -1, 872, 815, -1, 813, -1, 814, 532, 813, -1, + 41, 528, 818, 529, -1, -1, 514, 302, -1, -1, + 487, 860, -1, -1, 819, -1, 818, 532, 819, -1, + 560, 824, 820, -1, 81, 964, -1, -1, 559, 824, + -1, 821, 532, 559, 824, -1, 374, -1, 420, -1, + 824, -1, -1, 827, 826, -1, 396, 827, 826, -1, + 827, 40, 526, 960, 527, -1, 396, 827, 40, 526, + 960, 527, -1, 827, 40, -1, 396, 827, 40, -1, + 825, 826, -1, 822, 528, 821, 529, 826, -1, 250, + 528, 912, 529, 826, -1, 456, 528, 821, 529, 826, + -1, 3, 530, 3, -1, 825, 530, 3, -1, 826, + 526, 527, -1, 826, 526, 960, 527, -1, -1, 829, + -1, 831, -1, 833, -1, 837, -1, 843, -1, 844, + 859, -1, 844, 528, 960, 529, -1, 831, -1, 834, + -1, 838, -1, 843, -1, 963, 830, -1, 528, 909, + 529, -1, -1, 218, -1, 219, -1, 403, -1, 55, + -1, 348, -1, 167, 832, -1, 137, 331, -1, 116, + 830, -1, 113, 830, -1, 288, 830, -1, 58, -1, + 528, 960, 529, -1, -1, 835, -1, 836, -1, 835, + -1, 836, -1, 57, 842, 528, 908, 529, -1, 57, + 842, -1, 839, -1, 840, -1, 839, -1, 840, -1, + 841, 528, 960, 529, -1, 841, -1, 73, 842, -1, + 72, 842, -1, 474, -1, 273, 73, 842, -1, 273, + 72, 842, -1, 275, 842, -1, 477, -1, -1, 439, + 528, 960, 529, 845, -1, 439, 845, -1, 438, 528, + 960, 529, 845, -1, 438, 845, -1, 221, -1, 514, + 438, 511, -1, 492, 438, 511, -1, -1, 508, -1, + 509, -1, 268, -1, 269, -1, 110, -1, 111, -1, + 191, -1, 192, -1, 264, -1, 265, -1, 384, -1, + 385, -1, 262, -1, 263, -1, 258, -1, 259, -1, + 484, -1, 485, -1, 343, -1, 344, -1, 114, -1, + 115, -1, 70, -1, 69, -1, 261, -1, 260, -1, + 846, -1, 847, -1, 848, -1, 849, -1, 850, -1, + 851, -1, 852, -1, 853, -1, 854, -1, 855, -1, + 856, -1, 857, -1, 858, -1, 846, 440, 847, -1, + 848, 440, 849, -1, 848, 440, 850, -1, 848, 440, + 851, -1, 849, 440, 850, -1, 849, 440, 851, -1, + 850, 440, 851, -1, -1, 862, -1, 860, 11, 824, + -1, 860, 81, 964, -1, 860, 47, 438, 511, 860, + -1, 519, 860, -1, 520, 860, -1, 860, 519, 860, + -1, 860, 520, 860, -1, 860, 521, 860, -1, 860, + 522, 860, -1, 860, 15, 860, -1, 860, 523, 860, + -1, 860, 524, 860, -1, 860, 16, 860, -1, 860, + 515, 860, -1, 860, 516, 860, -1, 860, 517, 860, + -1, 860, 20, 860, -1, 860, 21, 860, -1, 860, + 22, 860, -1, 860, 901, 860, -1, 901, 860, -1, + 860, 901, -1, 860, 37, 860, -1, 860, 300, 860, + -1, 280, 860, -1, 512, 860, -1, 860, 179, 860, + -1, 860, 240, 860, -1, 860, 240, 860, 147, 860, + -1, 860, 512, 240, 860, -1, 860, 512, 240, 860, + 147, 860, -1, 860, 196, 860, -1, 860, 196, 860, + 147, 860, -1, 860, 512, 196, 860, -1, 860, 512, + 196, 860, 147, 860, -1, 860, 400, 440, 860, -1, + 860, 400, 440, 860, 147, 860, -1, 860, 512, 400, + 440, 860, -1, 860, 512, 400, 440, 860, 147, 860, + -1, 860, 224, 285, -1, 860, 225, -1, 860, 224, + 280, 285, -1, 860, 280, 285, -1, 860, 283, -1, + 231, 954, 19, 860, -1, 860, 17, 860, -1, 860, + 18, 860, -1, 890, 307, 890, -1, 860, 224, 447, + -1, 860, 224, 280, 447, -1, 860, 224, 162, -1, + 860, 224, 280, 162, -1, 860, 224, 458, -1, 860, + 224, 280, 458, -1, 860, 224, 133, 174, 860, -1, + 860, 224, 280, 133, 174, 860, -1, 860, 224, 290, + 528, 912, 529, -1, 860, 224, 280, 290, 528, 912, + 529, -1, 860, 54, 935, 861, 37, 860, -1, 860, + 512, 54, 935, 861, 37, 860, -1, 860, 54, 424, + 861, 37, 860, -1, 860, 512, 54, 424, 861, 37, + 860, -1, 860, 201, 922, -1, 860, 512, 201, 922, + -1, 860, 903, 898, 717, -1, 860, 903, 898, 528, + 860, 529, -1, 118, -1, 84, 528, 860, 529, -1, + 461, 528, 860, 529, -1, 521, 84, 528, 860, 529, + -1, 521, 944, 948, 952, -1, 559, 530, 521, 944, + 948, 952, -1, 862, -1, 861, 11, 824, -1, 519, + 861, -1, 520, 861, -1, 861, 519, 861, -1, 861, + 520, 861, -1, 861, 521, 861, -1, 861, 522, 861, + -1, 861, 15, 861, -1, 861, 523, 861, -1, 861, + 524, 861, -1, 861, 16, 861, -1, 861, 515, 861, + -1, 861, 516, 861, -1, 861, 517, 861, -1, 861, + 20, 861, -1, 861, 21, 861, -1, 861, 22, 861, + -1, 861, 901, 861, -1, 901, 861, -1, 861, 901, + -1, 861, 224, 133, 174, 861, -1, 861, 224, 280, + 133, 174, 861, -1, 861, 224, 290, 528, 912, 529, + -1, 861, 224, 280, 290, 528, 912, 529, -1, 863, + -1, 864, 934, -1, 929, -1, 959, -1, 717, -1, + 717, 562, -1, 154, 717, -1, 778, 528, 908, 529, + -1, 528, 860, 529, -1, 866, -1, 890, -1, 533, + -1, 10, -1, 534, 565, -1, 865, -1, 868, -1, + 869, -1, 871, -1, 923, -1, 867, -1, 874, -1, + 40, 717, -1, 40, 526, 909, 527, -1, 535, 9, + -1, 526, 909, 527, -1, 536, 893, 537, -1, 250, + 536, 897, 537, -1, 958, 528, 529, -1, 958, 528, + 744, 742, 529, -1, 958, 528, 910, 743, 742, 529, + -1, 958, 528, 476, 911, 743, 742, 529, -1, 958, + 528, 910, 532, 476, 911, 743, 742, 529, -1, 958, + 528, 31, 910, 743, 742, 529, -1, 958, 528, 133, + 910, 743, 742, 529, -1, 870, 875, 876, 877, 881, + -1, 873, -1, 870, -1, 873, -1, 82, 169, 528, + 860, 529, -1, 67, 528, 860, 41, 824, 529, -1, + 450, 528, 860, 41, 824, 529, -1, 161, 528, 913, + 529, -1, 308, 528, 915, 529, -1, 327, 528, 917, + 529, -1, 422, 528, 918, 529, -1, 444, 528, 860, + 41, 824, 529, -1, 446, 528, 59, 921, 529, -1, + 446, 528, 236, 921, 529, -1, 446, 528, 441, 921, + 529, -1, 446, 528, 921, 529, -1, 286, 528, 860, + 532, 860, 529, -1, 80, 528, 908, 529, -1, 526, + 860, 169, 954, 201, 860, 527, -1, 526, 860, 169, + 954, 201, 862, 194, 860, 527, -1, 491, 183, 528, + 744, 529, -1, -1, 165, 528, 487, 860, 529, -1, + 165, 528, 860, 529, -1, -1, 157, -1, -1, 489, + 879, -1, -1, 880, -1, 879, 532, 880, -1, 559, + 41, 882, -1, 306, 882, -1, 306, 559, -1, -1, + 528, 883, 884, 743, 885, 529, -1, 559, -1, -1, + 315, 60, 907, -1, -1, 346, 886, 888, -1, 375, + 886, 888, -1, 186, 886, 888, -1, -1, 887, -1, + 54, 887, 37, 887, -1, 453, 330, -1, 453, 168, + -1, 105, 374, -1, 860, 330, -1, 860, 168, -1, + 150, 105, 374, -1, 150, 183, -1, 150, 437, -1, + 150, 278, 303, -1, -1, 374, 528, 908, 529, -1, + 374, 528, 529, -1, 889, -1, 528, 907, 532, 860, + 529, -1, 560, 19, 860, -1, 891, -1, 892, 532, + 891, -1, 892, -1, 892, 532, -1, 860, 19, 860, + -1, 894, -1, 895, 532, 894, -1, 895, -1, 895, + 532, -1, 896, -1, -1, 39, -1, 405, -1, 31, + -1, 8, -1, 900, -1, 519, -1, 520, -1, 521, + -1, 522, -1, 15, -1, 523, -1, 524, -1, 16, + -1, 515, -1, 516, -1, 517, -1, 20, -1, 21, + -1, 22, -1, 8, -1, 297, 528, 904, 529, -1, + 899, -1, 297, 528, 904, 529, -1, 899, -1, 297, + 528, 904, 529, -1, 240, -1, 512, 240, -1, 179, + -1, 512, 179, -1, 196, -1, 512, 196, -1, 899, + -1, 559, 530, 904, -1, 862, -1, 905, 532, 862, + -1, 905, -1, 905, 532, -1, 860, -1, 907, 532, + 860, -1, 907, -1, 907, 532, -1, 908, -1, -1, + 911, -1, 910, 532, 911, -1, 860, -1, 967, 13, + 860, -1, 967, 14, 860, -1, 824, -1, 912, 532, + 824, -1, 914, 174, 860, -1, -1, 3, -1, 846, -1, 847, -1, 848, -1, 849, -1, 850, -1, 851, -1, 852, -1, 853, -1, 854, -1, 855, -1, 856, - -1, 844, 440, 845, -1, 846, 440, 847, -1, 846, - 440, 848, -1, 846, 440, 849, -1, 847, 440, 848, - -1, 847, 440, 849, -1, 848, 440, 849, -1, -1, - 860, -1, 858, 11, 822, -1, 858, 81, 962, -1, - 858, 47, 438, 511, 858, -1, 519, 858, -1, 520, - 858, -1, 858, 519, 858, -1, 858, 520, 858, -1, - 858, 521, 858, -1, 858, 522, 858, -1, 858, 15, - 858, -1, 858, 523, 858, -1, 858, 524, 858, -1, - 858, 16, 858, -1, 858, 515, 858, -1, 858, 516, - 858, -1, 858, 517, 858, -1, 858, 20, 858, -1, - 858, 21, 858, -1, 858, 22, 858, -1, 858, 899, - 858, -1, 899, 858, -1, 858, 899, -1, 858, 37, - 858, -1, 858, 300, 858, -1, 280, 858, -1, 512, - 858, -1, 858, 179, 858, -1, 858, 240, 858, -1, - 858, 240, 858, 147, 858, -1, 858, 512, 240, 858, - -1, 858, 512, 240, 858, 147, 858, -1, 858, 196, - 858, -1, 858, 196, 858, 147, 858, -1, 858, 512, - 196, 858, -1, 858, 512, 196, 858, 147, 858, -1, - 858, 400, 440, 858, -1, 858, 400, 440, 858, 147, - 858, -1, 858, 512, 400, 440, 858, -1, 858, 512, - 400, 440, 858, 147, 858, -1, 858, 224, 285, -1, - 858, 225, -1, 858, 224, 280, 285, -1, 858, 280, - 285, -1, 858, 283, -1, 231, 952, 19, 858, -1, - 858, 17, 858, -1, 858, 18, 858, -1, 888, 307, - 888, -1, 858, 224, 447, -1, 858, 224, 280, 447, - -1, 858, 224, 162, -1, 858, 224, 280, 162, -1, - 858, 224, 458, -1, 858, 224, 280, 458, -1, 858, - 224, 133, 174, 858, -1, 858, 224, 280, 133, 174, - 858, -1, 858, 224, 290, 528, 910, 529, -1, 858, - 224, 280, 290, 528, 910, 529, -1, 858, 54, 933, - 859, 37, 858, -1, 858, 512, 54, 933, 859, 37, - 858, -1, 858, 54, 424, 859, 37, 858, -1, 858, - 512, 54, 424, 859, 37, 858, -1, 858, 201, 920, - -1, 858, 512, 201, 920, -1, 858, 901, 896, 715, - -1, 858, 901, 896, 528, 858, 529, -1, 118, -1, - 84, 528, 858, 529, -1, 461, 528, 858, 529, -1, - 521, 84, 528, 858, 529, -1, 521, 942, 946, 950, - -1, 559, 530, 521, 942, 946, 950, -1, 860, -1, - 859, 11, 822, -1, 519, 859, -1, 520, 859, -1, - 859, 519, 859, -1, 859, 520, 859, -1, 859, 521, - 859, -1, 859, 522, 859, -1, 859, 15, 859, -1, - 859, 523, 859, -1, 859, 524, 859, -1, 859, 16, - 859, -1, 859, 515, 859, -1, 859, 516, 859, -1, - 859, 517, 859, -1, 859, 20, 859, -1, 859, 21, - 859, -1, 859, 22, 859, -1, 859, 899, 859, -1, - 899, 859, -1, 859, 899, -1, 859, 224, 133, 174, - 859, -1, 859, 224, 280, 133, 174, 859, -1, 859, - 224, 290, 528, 910, 529, -1, 859, 224, 280, 290, - 528, 910, 529, -1, 861, -1, 862, 932, -1, 927, - -1, 957, -1, 715, -1, 715, 562, -1, 154, 715, - -1, 776, 528, 906, 529, -1, 528, 858, 529, -1, - 864, -1, 888, -1, 533, -1, 10, -1, 534, 565, - -1, 863, -1, 866, -1, 867, -1, 869, -1, 921, - -1, 865, -1, 872, -1, 40, 715, -1, 40, 526, - 907, 527, -1, 535, 9, -1, 526, 907, 527, -1, - 536, 891, 537, -1, 250, 536, 895, 537, -1, 956, - 528, 529, -1, 956, 528, 742, 740, 529, -1, 956, - 528, 908, 741, 740, 529, -1, 956, 528, 476, 909, - 741, 740, 529, -1, 956, 528, 908, 532, 476, 909, - 741, 740, 529, -1, 956, 528, 31, 908, 741, 740, - 529, -1, 956, 528, 133, 908, 741, 740, 529, -1, - 868, 873, 874, 875, 879, -1, 871, -1, 868, -1, - 871, -1, 82, 169, 528, 858, 529, -1, 67, 528, - 858, 41, 822, 529, -1, 450, 528, 858, 41, 822, - 529, -1, 161, 528, 911, 529, -1, 308, 528, 913, - 529, -1, 327, 528, 915, 529, -1, 422, 528, 916, - 529, -1, 444, 528, 858, 41, 822, 529, -1, 446, - 528, 59, 919, 529, -1, 446, 528, 236, 919, 529, - -1, 446, 528, 441, 919, 529, -1, 446, 528, 919, - 529, -1, 286, 528, 858, 532, 858, 529, -1, 80, - 528, 906, 529, -1, 526, 858, 169, 952, 201, 858, - 527, -1, 526, 858, 169, 952, 201, 860, 194, 858, - 527, -1, 491, 183, 528, 742, 529, -1, -1, 165, - 528, 487, 858, 529, -1, 165, 528, 858, 529, -1, - -1, 157, -1, -1, 489, 877, -1, -1, 878, -1, - 877, 532, 878, -1, 559, 41, 880, -1, 306, 880, - -1, 306, 559, -1, -1, 528, 881, 882, 741, 883, - 529, -1, 559, -1, -1, 315, 60, 905, -1, -1, - 346, 884, 886, -1, 375, 884, 886, -1, 186, 884, - 886, -1, -1, 885, -1, 54, 885, 37, 885, -1, - 453, 330, -1, 453, 168, -1, 105, 374, -1, 858, - 330, -1, 858, 168, -1, 150, 105, 374, -1, 150, - 183, -1, 150, 437, -1, 150, 278, 303, -1, -1, - 374, 528, 906, 529, -1, 374, 528, 529, -1, 887, - -1, 528, 905, 532, 858, 529, -1, 560, 19, 858, - -1, 889, -1, 890, 532, 889, -1, 890, -1, 890, - 532, -1, 858, 19, 858, -1, 892, -1, 893, 532, - 892, -1, 893, -1, 893, 532, -1, 894, -1, -1, - 39, -1, 405, -1, 31, -1, 8, -1, 898, -1, - 519, -1, 520, -1, 521, -1, 522, -1, 15, -1, - 523, -1, 524, -1, 16, -1, 515, -1, 516, -1, - 517, -1, 20, -1, 21, -1, 22, -1, 8, -1, - 297, 528, 902, 529, -1, 897, -1, 297, 528, 902, - 529, -1, 897, -1, 297, 528, 902, 529, -1, 240, - -1, 512, 240, -1, 179, -1, 512, 179, -1, 196, - -1, 512, 196, -1, 897, -1, 559, 530, 902, -1, - 860, -1, 903, 532, 860, -1, 903, -1, 903, 532, - -1, 858, -1, 905, 532, 858, -1, 905, -1, 905, - 532, -1, 906, -1, -1, 909, -1, 908, 532, 909, - -1, 858, -1, 965, 13, 858, -1, 965, 14, 858, - -1, 822, -1, 910, 532, 822, -1, 912, 174, 858, - -1, -1, 3, -1, 844, -1, 845, -1, 846, -1, - 847, -1, 848, -1, 849, -1, 850, -1, 851, -1, - 852, -1, 853, -1, 854, -1, 855, -1, 856, -1, - 561, -1, 858, 914, 917, 918, -1, 858, 914, 917, - -1, 324, 858, -1, 859, 201, 859, -1, -1, 858, - 917, 918, -1, 858, 918, 917, -1, 858, 917, -1, - 858, 918, -1, 905, -1, -1, 174, 858, -1, 169, - 858, -1, 858, 174, 906, -1, 174, 906, -1, 906, - -1, 715, -1, 528, 906, 529, -1, 927, -1, 864, - -1, 66, 925, 922, 924, 144, -1, 923, -1, 922, - 923, -1, 486, 858, 436, 858, -1, 140, 858, -1, - -1, 858, -1, -1, 559, -1, 559, -1, 559, 562, - -1, 526, 858, 527, -1, 526, 928, 19, 928, 527, - -1, 526, 928, 19, 928, 19, 928, 527, -1, 526, - 928, 19, 520, 19, 928, 527, -1, 858, -1, -1, - -1, 929, 563, -1, -1, 528, 529, -1, 528, 908, - 529, -1, 530, 564, 930, -1, 526, 858, 527, -1, - 526, 928, 19, 928, 527, -1, 526, 928, 19, 928, - 19, 928, 527, -1, 526, 928, 19, 520, 19, 928, - 527, -1, -1, 932, 931, -1, 46, -1, -1, 936, - -1, -1, 937, -1, 935, 532, 937, -1, 935, -1, - 935, 532, -1, 858, 41, 966, -1, 858, 3, -1, - 858, -1, 559, 19, 858, -1, 150, 528, 941, 529, - -1, 150, 939, -1, 560, -1, 939, 530, 560, -1, - 939, -1, 940, 532, 939, -1, 940, -1, 940, 532, - -1, 938, -1, -1, 858, 41, 559, -1, 943, -1, - 944, 532, 943, -1, 944, -1, 944, 532, -1, 361, - 528, 945, 529, -1, 361, 943, -1, -1, 939, 41, - 559, -1, 947, -1, 948, 532, 947, -1, 948, -1, - 948, 532, -1, 359, 528, 949, 529, -1, 359, 947, - -1, -1, 558, -1, 951, 532, 558, -1, 955, -1, - 952, 532, 955, -1, 952, -1, 952, 532, -1, 953, - -1, 528, 953, 529, -1, 560, -1, 960, -1, 559, - 562, -1, 958, -1, 4, -1, 561, 929, -1, 6, - -1, 7, -1, 956, 561, -1, 956, 528, 908, 741, - 740, 529, 561, -1, 826, 561, -1, 842, 528, 858, - 529, 857, -1, 842, 958, 857, -1, 842, 561, 857, - -1, 447, -1, 162, -1, 285, -1, 9, -1, 3, - -1, 1041, -1, 1046, -1, 3, -1, 1041, -1, 1043, - -1, 3, -1, 1041, -1, 1044, -1, 559, -1, 559, - 963, -1, 530, 564, -1, 963, 530, 564, -1, 528, - 953, 529, -1, -1, 959, -1, 565, -1, 5, -1, - 332, 955, 968, 41, 969, -1, 528, 910, 529, -1, - -1, 714, -1, 568, -1, 700, -1, 701, -1, 1014, - -1, 1030, -1, 101, 379, 558, 971, -1, 101, 379, - 194, 280, 154, 558, 971, -1, 101, 300, 361, 379, - 558, 971, -1, 971, 972, -1, -1, 622, -1, 973, - -1, 594, -1, 1036, -1, 101, 979, 205, 976, 977, - 295, 558, 975, 528, 587, 529, 978, 815, -1, 101, - 979, 205, 976, 194, 280, 154, 653, 295, 558, 975, - 528, 587, 529, 978, 815, -1, 559, -1, 467, 974, - -1, -1, 90, -1, -1, 653, -1, -1, 490, 637, - -1, -1, 457, -1, -1, 33, 427, 809, 395, 379, - 955, -1, 33, 427, 194, 154, 809, 395, 379, 955, - -1, 33, 390, 558, 395, 379, 955, -1, 33, 390, - 194, 154, 558, 395, 379, 955, -1, 33, 480, 558, - 395, 379, 955, -1, 33, 480, 194, 154, 558, 395, - 379, 955, -1, 170, 76, 982, -1, 76, 982, -1, - 559, -1, -1, 85, 295, 985, 558, 224, 984, -1, - 85, 295, 83, 858, 224, 984, -1, 561, -1, 285, - -1, 427, -1, 390, -1, 176, -1, 249, -1, 249, - 427, -1, 480, -1, 109, -1, 205, -1, 379, -1, - 451, -1, 156, 109, 561, 708, -1, 156, 109, 559, - 440, 561, 708, -1, 200, 109, 561, -1, 155, 991, - -1, 155, 995, 989, 991, -1, 155, 478, 991, -1, - 155, 528, 994, 529, 991, -1, 478, -1, -1, 996, - -1, 611, -1, -1, 980, -1, 608, -1, 542, -1, - 1035, -1, 981, -1, 701, -1, 1038, -1, 689, -1, - 970, -1, 594, -1, 622, -1, 589, -1, 557, -1, - 1014, -1, 672, -1, 604, -1, 973, -1, 568, -1, - 1005, -1, 678, -1, 593, -1, 967, -1, 566, -1, - 714, -1, 618, -1, 700, -1, 603, -1, 1009, -1, - 1027, -1, 999, -1, 1030, -1, 1036, -1, 3, -1, - 1041, -1, 1045, -1, 992, -1, 561, -1, 997, -1, - 994, 532, 997, -1, 36, -1, 35, -1, 447, -1, - 162, -1, 295, -1, 993, -1, 998, 990, -1, 992, - -1, 995, -1, 395, 1000, -1, 395, 244, 1000, -1, - 395, 394, 1000, -1, 395, 180, 1000, -1, 395, 475, - 1000, -1, 1001, -1, 1034, 174, 105, -1, 438, 511, - 1003, -1, 379, 561, -1, 1034, 440, 1004, -1, 1034, - 517, 1004, -1, 858, -1, 561, -1, 3, -1, 842, - 561, 857, -1, 842, 528, 958, 529, 561, -1, 611, - -1, 118, -1, 244, -1, 1002, -1, 1004, 532, 1002, - -1, 243, 1007, -1, 1006, 216, 1007, 1008, -1, 1006, - 216, 1007, 174, 559, 1008, -1, 1006, 216, 1007, 174, - 561, 1008, -1, -1, 170, -1, 561, -1, 559, -1, - -1, 479, 561, -1, 479, 559, -1, 468, 1011, 1013, - 989, -1, 468, 1011, 1013, 989, 558, 964, -1, 468, - 1011, 1013, 989, 1018, -1, 468, 528, 1012, 529, -1, - 468, 528, 1012, 529, 558, 964, -1, 995, -1, 478, - -1, 173, -1, 175, -1, 3, -1, 175, -1, -1, - 1010, -1, 1012, 532, 1010, -1, 173, -1, -1, 573, - 123, 174, 1015, 1017, 1016, 579, -1, 448, 735, 1015, - -1, 809, -1, 809, 559, -1, 809, 41, 559, -1, - 487, 858, -1, -1, 467, 790, -1, -1, 995, 989, - -1, 995, 989, 558, 964, -1, 48, 1021, 561, 1022, - 1026, -1, 48, 194, 280, 154, 1021, 561, 1022, 1026, - -1, 48, 300, 361, 1021, 561, 1022, 1026, -1, 129, - 565, -1, 129, 109, 565, -1, 129, 109, 194, 154, - 565, -1, 109, -1, -1, 41, 559, -1, -1, 858, - -1, -1, 565, 1023, -1, 1024, -1, 1025, 532, 1024, - -1, 528, 1025, 529, -1, -1, 363, 1029, -1, 363, - 244, 1029, -1, 363, 394, 1029, -1, 363, 180, 1029, - -1, 363, 475, 1029, -1, 1034, -1, 31, -1, 1028, - -1, 438, 511, -1, 442, 226, 239, -1, 1032, 714, - -1, 423, 714, -1, 423, 558, -1, 1032, 428, 174, - 558, -1, 1032, 558, -1, 1032, 438, 511, -1, 1032, - 442, 226, 239, -1, 1032, 31, 1033, -1, 1032, -1, - 128, -1, 127, -1, 399, -1, 1031, -1, 428, -1, - -1, 559, -1, 1034, 530, 559, -1, 62, 868, -1, - 101, 670, 480, 558, 659, 978, 41, 714, 1037, -1, - 101, 670, 480, 194, 280, 154, 558, 659, 978, 41, - 714, 1037, -1, 101, 300, 361, 670, 480, 558, 659, - 978, 41, 714, 1037, -1, 101, 670, 351, 480, 558, - 528, 663, 529, 978, 41, 714, 1037, -1, 101, 300, - 361, 670, 351, 480, 558, 528, 663, 529, 978, 41, - 714, 1037, -1, 490, 75, 298, -1, 490, 65, 75, - 298, -1, 490, 244, 75, 298, -1, -1, 101, 670, - 427, 1040, 41, 714, 1039, -1, 101, 670, 427, 194, - 280, 154, 1040, 41, 714, 1039, -1, 101, 300, 361, - 670, 427, 1040, 41, 714, 1039, -1, 490, 108, -1, - 490, 278, 108, -1, -1, 558, 659, 644, 636, -1, - 23, -1, 24, -1, 25, -1, 26, -1, 27, -1, - 28, -1, 29, -1, 30, -1, 32, -1, 33, -1, - 34, -1, 44, -1, 45, -1, 48, -1, 49, -1, - 51, -1, 52, -1, 53, -1, 61, -1, 62, -1, - 63, -1, 64, -1, 65, -1, 68, -1, 69, -1, - 70, -1, 71, -1, 74, -1, 76, -1, 77, -1, - 78, -1, 79, -1, 85, -1, 86, -1, 87, -1, - 88, -1, 89, -1, 91, -1, 92, -1, 93, -1, - 95, -1, 96, -1, 97, -1, 98, -1, 99, -1, - 100, -1, 103, -1, 104, -1, 105, -1, 106, -1, - 107, -1, 108, -1, 109, -1, 110, -1, 111, -1, - 112, -1, 114, -1, 115, -1, 117, -1, 119, -1, - 121, -1, 122, -1, 123, -1, 124, -1, 125, -1, - 126, -1, 129, -1, 130, -1, 131, -1, 132, -1, - 135, -1, 136, -1, 137, -1, 138, -1, 139, -1, - 141, -1, 142, -1, 143, -1, 145, -1, 146, -1, - 147, -1, 148, -1, 150, -1, 151, -1, 152, -1, - 153, -1, 155, -1, 156, -1, 157, -1, 158, -1, - 159, -1, 160, -1, 163, -1, 165, -1, 166, -1, - 168, -1, 170, -1, 172, -1, 176, -1, 177, -1, - 180, -1, 181, -1, 182, -1, 186, -1, 187, -1, - 189, -1, 190, -1, 191, -1, 192, -1, 193, -1, - 194, -1, 195, -1, 197, -1, 198, -1, 199, -1, - 200, -1, 202, -1, 203, -1, 204, -1, 205, -1, - 206, -1, 207, -1, 208, -1, 210, -1, 213, -1, - 214, -1, 215, -1, 216, -1, 217, -1, 223, -1, - 226, -1, 228, -1, 229, -1, 230, -1, 232, -1, - 233, -1, 234, -1, 237, -1, 239, -1, 242, -1, - 243, -1, 244, -1, 245, -1, 246, -1, 247, -1, - 248, -1, 249, -1, 251, -1, 252, -1, 253, -1, - 254, -1, 255, -1, 256, -1, 257, -1, 258, -1, - 259, -1, 260, -1, 261, -1, 262, -1, 263, -1, - 264, -1, 265, -1, 266, -1, 267, -1, 268, -1, - 269, -1, 270, -1, 271, -1, 272, -1, 276, -1, - 277, -1, 278, -1, 281, -1, 282, -1, 284, -1, - 287, -1, 289, -1, 290, -1, 291, -1, 293, -1, - 294, -1, 297, -1, 298, -1, 299, -1, 302, -1, - 303, -1, 306, -1, 309, -1, 310, -1, 311, -1, - 312, -1, 313, -1, 314, -1, 315, -1, 316, -1, - 317, -1, 318, -1, 319, -1, 320, -1, 325, -1, - 326, -1, 329, -1, 330, -1, 332, -1, 333, -1, - 334, -1, 336, -1, 337, -1, 338, -1, 339, -1, - 340, -1, 341, -1, 343, -1, 344, -1, 345, -1, - 346, -1, 347, -1, 349, -1, 350, -1, 351, -1, - 352, -1, 354, -1, 355, -1, 356, -1, 357, -1, - 358, -1, 359, -1, 360, -1, 361, -1, 362, -1, - 363, -1, 364, -1, 365, -1, 366, -1, 368, -1, - 369, -1, 371, -1, 372, -1, 373, -1, 375, -1, - 376, -1, 377, -1, 378, -1, 379, -1, 380, -1, - 381, -1, 382, -1, 383, -1, 384, -1, 385, -1, - 386, -1, 387, -1, 390, -1, 391, -1, 392, -1, - 393, -1, 394, -1, 395, -1, 397, -1, 398, -1, - 401, -1, 402, -1, 404, -1, 406, -1, 407, -1, - 408, -1, 409, -1, 410, -1, 411, -1, 412, -1, - 413, -1, 414, -1, 415, -1, 416, -1, 417, -1, - 418, -1, 419, -1, 421, -1, 425, -1, 426, -1, - 428, -1, 430, -1, 431, -1, 432, -1, 433, -1, - 434, -1, 435, -1, 437, -1, 442, -1, 443, -1, - 445, -1, 448, -1, 449, -1, 451, -1, 452, -1, - 453, -1, 454, -1, 455, -1, 458, -1, 459, -1, - 460, -1, 463, -1, 464, -1, 465, -1, 466, -1, - 468, -1, 469, -1, 470, -1, 471, -1, 472, -1, - 475, -1, 477, -1, 479, -1, 480, -1, 481, -1, - 482, -1, 483, -1, 484, -1, 485, -1, 488, -1, - 491, -1, 492, -1, 493, -1, 494, -1, 495, -1, - 496, -1, 508, -1, 509, -1, 510, -1, 511, -1, - 54, -1, 55, -1, 57, -1, 58, -1, 72, -1, - 73, -1, 80, -1, 84, -1, 113, -1, 116, -1, - 154, -1, 161, -1, 167, -1, 178, -1, 184, -1, - 185, -1, 212, -1, 218, -1, 219, -1, 221, -1, - 250, -1, 273, -1, 275, -1, 279, -1, 286, -1, - 288, -1, 304, -1, 308, -1, 327, -1, 331, -1, - 348, -1, 374, -1, 396, -1, 403, -1, 420, -1, - 422, -1, 438, -1, 439, -1, 444, -1, 446, -1, - 450, -1, 473, -1, 474, -1, 497, -1, 498, -1, - 499, -1, 500, -1, 501, -1, 502, -1, 503, -1, - 504, -1, 505, -1, 506, -1, 507, -1, 43, -1, - 47, -1, 50, -1, 56, -1, 82, -1, 90, -1, - 102, -1, 173, -1, 175, -1, 178, -1, 179, -1, - 196, -1, 211, -1, 224, -1, 225, -1, 227, -1, - 238, -1, 240, -1, 250, -1, 274, -1, 283, -1, - 305, -1, 307, -1, 328, -1, 370, -1, 400, -1, - 420, -1, 429, -1, 478, -1, 38, -1, 43, -1, - 47, -1, 50, -1, 56, -1, 60, -1, 82, -1, - 84, -1, 90, -1, 102, -1, 173, -1, 175, -1, - 179, -1, 196, -1, 211, -1, 224, -1, 225, -1, - 227, -1, 238, -1, 240, -1, 274, -1, 283, -1, - 305, -1, 307, -1, 328, -1, 370, -1, 389, -1, - 400, -1, 429, -1, 450, -1, 461, -1, 478, -1, - 38, -1, 43, -1, 47, -1, 50, -1, 54, -1, - 55, -1, 56, -1, 57, -1, 58, -1, 60, -1, - 73, -1, 72, -1, 80, -1, 82, -1, 84, -1, - 90, -1, 102, -1, 113, -1, 116, -1, 154, -1, - 161, -1, 167, -1, 173, -1, 175, -1, 178, -1, - 179, -1, 184, -1, 185, -1, 196, -1, 211, -1, - 212, -1, 219, -1, 221, -1, 218, -1, 224, -1, - 225, -1, 227, -1, 238, -1, 240, -1, 250, -1, - 273, -1, 274, -1, 275, -1, 279, -1, 283, -1, - 286, -1, 288, -1, 305, -1, 304, -1, 307, -1, - 308, -1, 327, -1, 328, -1, 331, -1, 348, -1, - 370, -1, 374, -1, 389, -1, 396, -1, 400, -1, - 403, -1, 420, -1, 422, -1, 429, -1, 438, -1, - 439, -1, 444, -1, 446, -1, 450, -1, 461, -1, - 473, -1, 474, -1, 478, -1, 497, -1, 498, -1, - 499, -1, 500, -1, 501, -1, 502, -1, 503, -1, - 504, -1, 505, -1, 506, -1, 507, -1, 38, -1, - 43, -1, 47, -1, 50, -1, 56, -1, 60, -1, - 82, -1, 84, -1, 90, -1, 102, -1, 173, -1, - 175, -1, 178, -1, 179, -1, 196, -1, 211, -1, - 224, -1, 225, -1, 227, -1, 238, -1, 240, -1, - 250, -1, 274, -1, 283, -1, 305, -1, 307, -1, - 328, -1, 370, -1, 389, -1, 400, -1, 420, -1, - 429, -1, 450, -1, 461, -1, 478, -1, 31, -1, - 35, -1, 36, -1, 37, -1, 39, -1, 40, -1, - 41, -1, 42, -1, 46, -1, 59, -1, 66, -1, - 67, -1, 75, -1, 81, -1, 83, -1, 94, -1, - 101, -1, 118, -1, 120, -1, 127, -1, 128, -1, - 133, -1, 134, -1, 140, -1, 144, -1, 149, -1, - 162, -1, 164, -1, 169, -1, 171, -1, 174, -1, - 183, -1, 188, -1, 201, -1, 209, -1, 220, -1, - 222, -1, 231, -1, 235, -1, 236, -1, 241, -1, - 280, -1, 285, -1, 292, -1, 295, -1, 296, -1, - 300, -1, 301, -1, 321, -1, 322, -1, 323, -1, - 324, -1, 335, -1, 342, -1, 353, -1, 367, -1, - 388, -1, 399, -1, 405, -1, 423, -1, 424, -1, - 427, -1, 436, -1, 440, -1, 441, -1, 447, -1, - 456, -1, 457, -1, 462, -1, 467, -1, 476, -1, - 486, -1, 487, -1, 489, -1, 490, -1 + -1, 857, -1, 858, -1, 561, -1, 860, 916, 919, + 920, -1, 860, 916, 919, -1, 324, 860, -1, 861, + 201, 861, -1, -1, 860, 919, 920, -1, 860, 920, + 919, -1, 860, 919, -1, 860, 920, -1, 907, -1, + -1, 174, 860, -1, 169, 860, -1, 860, 174, 908, + -1, 174, 908, -1, 908, -1, 717, -1, 528, 908, + 529, -1, 929, -1, 866, -1, 66, 927, 924, 926, + 144, -1, 925, -1, 924, 925, -1, 486, 860, 436, + 860, -1, 140, 860, -1, -1, 860, -1, -1, 559, + -1, 559, -1, 559, 562, -1, 526, 860, 527, -1, + 526, 930, 19, 930, 527, -1, 526, 930, 19, 930, + 19, 930, 527, -1, 526, 930, 19, 520, 19, 930, + 527, -1, 860, -1, -1, -1, 931, 563, -1, -1, + 528, 529, -1, 528, 910, 529, -1, 530, 564, 932, + -1, 526, 860, 527, -1, 526, 930, 19, 930, 527, + -1, 526, 930, 19, 930, 19, 930, 527, -1, 526, + 930, 19, 520, 19, 930, 527, -1, -1, 934, 933, + -1, 46, -1, -1, 938, -1, -1, 939, -1, 937, + 532, 939, -1, 937, -1, 937, 532, -1, 860, 41, + 968, -1, 860, 3, -1, 860, -1, 559, 19, 860, + -1, 150, 528, 943, 529, -1, 150, 941, -1, 560, + -1, 941, 530, 560, -1, 941, -1, 942, 532, 941, + -1, 942, -1, 942, 532, -1, 940, -1, -1, 860, + 41, 559, -1, 945, -1, 946, 532, 945, -1, 946, + -1, 946, 532, -1, 361, 528, 947, 529, -1, 361, + 945, -1, -1, 941, 41, 559, -1, 949, -1, 950, + 532, 949, -1, 950, -1, 950, 532, -1, 359, 528, + 951, 529, -1, 359, 949, -1, -1, 558, -1, 953, + 532, 558, -1, 957, -1, 954, 532, 957, -1, 954, + -1, 954, 532, -1, 955, -1, 528, 955, 529, -1, + 560, -1, 962, -1, 559, 562, -1, 960, -1, 4, + -1, 561, 931, -1, 6, -1, 7, -1, 958, 561, + -1, 958, 528, 910, 743, 742, 529, 561, -1, 828, + 561, -1, 844, 528, 860, 529, 859, -1, 844, 960, + 859, -1, 844, 561, 859, -1, 447, -1, 162, -1, + 285, -1, 9, -1, 3, -1, 1043, -1, 1048, -1, + 3, -1, 1043, -1, 1045, -1, 3, -1, 1043, -1, + 1046, -1, 559, -1, 559, 965, -1, 530, 564, -1, + 965, 530, 564, -1, 528, 955, 529, -1, -1, 961, + -1, 565, -1, 5, -1, 332, 957, 970, 41, 971, + -1, 528, 912, 529, -1, -1, 716, -1, 568, -1, + 702, -1, 703, -1, 1016, -1, 1032, -1, 101, 379, + 558, 973, -1, 101, 379, 194, 280, 154, 558, 973, + -1, 101, 300, 361, 379, 558, 973, -1, 973, 974, + -1, -1, 622, -1, 975, -1, 594, -1, 1038, -1, + 101, 981, 205, 978, 979, 295, 558, 977, 528, 587, + 529, 980, 817, -1, 101, 981, 205, 978, 194, 280, + 154, 655, 295, 558, 977, 528, 587, 529, 980, 817, + -1, 559, -1, 467, 976, -1, -1, 90, -1, -1, + 655, -1, -1, 490, 637, -1, -1, 457, -1, -1, + 33, 427, 811, 395, 379, 957, -1, 33, 427, 194, + 154, 811, 395, 379, 957, -1, 33, 390, 558, 395, + 379, 957, -1, 33, 390, 194, 154, 558, 395, 379, + 957, -1, 33, 480, 558, 395, 379, 957, -1, 33, + 480, 194, 154, 558, 395, 379, 957, -1, 170, 76, + 984, -1, 76, 984, -1, 559, -1, -1, 85, 295, + 987, 558, 224, 986, -1, 85, 295, 83, 860, 224, + 986, -1, 561, -1, 285, -1, 427, -1, 390, -1, + 176, -1, 249, -1, 249, 427, -1, 480, -1, 109, + -1, 205, -1, 379, -1, 451, -1, 156, 109, 561, + 710, -1, 156, 109, 559, 440, 561, 710, -1, 200, + 109, 561, -1, 155, 993, -1, 155, 997, 991, 993, + -1, 155, 478, 993, -1, 155, 528, 996, 529, 993, + -1, 478, -1, -1, 998, -1, 611, -1, -1, 982, + -1, 608, -1, 542, -1, 1037, -1, 983, -1, 703, + -1, 1040, -1, 691, -1, 972, -1, 594, -1, 622, + -1, 589, -1, 557, -1, 1016, -1, 674, -1, 604, + -1, 975, -1, 568, -1, 1007, -1, 680, -1, 593, + -1, 969, -1, 566, -1, 716, -1, 618, -1, 702, + -1, 603, -1, 1011, -1, 1029, -1, 1001, -1, 1032, + -1, 1038, -1, 3, -1, 1043, -1, 1047, -1, 994, + -1, 561, -1, 999, -1, 996, 532, 999, -1, 36, + -1, 35, -1, 447, -1, 162, -1, 295, -1, 995, + -1, 1000, 992, -1, 994, -1, 997, -1, 395, 1002, + -1, 395, 244, 1002, -1, 395, 394, 1002, -1, 395, + 180, 1002, -1, 395, 475, 1002, -1, 1003, -1, 1036, + 174, 105, -1, 438, 511, 1005, -1, 379, 561, -1, + 1036, 440, 1006, -1, 1036, 517, 1006, -1, 860, -1, + 561, -1, 3, -1, 844, 561, 859, -1, 844, 528, + 960, 529, 561, -1, 611, -1, 118, -1, 244, -1, + 1004, -1, 1006, 532, 1004, -1, 243, 1009, -1, 1008, + 216, 1009, 1010, -1, 1008, 216, 1009, 174, 559, 1010, + -1, 1008, 216, 1009, 174, 561, 1010, -1, -1, 170, + -1, 561, -1, 559, -1, -1, 479, 561, -1, 479, + 559, -1, 468, 1013, 1015, 991, -1, 468, 1013, 1015, + 991, 558, 966, -1, 468, 1013, 1015, 991, 1020, -1, + 468, 528, 1014, 529, -1, 468, 528, 1014, 529, 558, + 966, -1, 997, -1, 478, -1, 173, -1, 175, -1, + 3, -1, 175, -1, -1, 1012, -1, 1014, 532, 1012, + -1, 173, -1, -1, 573, 123, 174, 1017, 1019, 1018, + 579, -1, 448, 737, 1017, -1, 811, -1, 811, 559, + -1, 811, 41, 559, -1, 487, 860, -1, -1, 467, + 792, -1, -1, 997, 991, -1, 997, 991, 558, 966, + -1, 48, 1023, 561, 1024, 1028, -1, 48, 194, 280, + 154, 1023, 561, 1024, 1028, -1, 48, 300, 361, 1023, + 561, 1024, 1028, -1, 129, 565, -1, 129, 109, 565, + -1, 129, 109, 194, 154, 565, -1, 109, -1, -1, + 41, 559, -1, -1, 860, -1, -1, 565, 1025, -1, + 1026, -1, 1027, 532, 1026, -1, 528, 1027, 529, -1, + -1, 363, 1031, -1, 363, 244, 1031, -1, 363, 394, + 1031, -1, 363, 180, 1031, -1, 363, 475, 1031, -1, + 1036, -1, 31, -1, 1030, -1, 438, 511, -1, 442, + 226, 239, -1, 1034, 716, -1, 423, 716, -1, 423, + 558, -1, 1034, 428, 174, 558, -1, 1034, 558, -1, + 1034, 438, 511, -1, 1034, 442, 226, 239, -1, 1034, + 31, 1035, -1, 1034, -1, 128, -1, 127, -1, 399, + -1, 1033, -1, 428, -1, -1, 559, -1, 1036, 530, + 559, -1, 62, 870, -1, 101, 672, 480, 558, 661, + 980, 41, 716, 1039, -1, 101, 672, 480, 194, 280, + 154, 558, 661, 980, 41, 716, 1039, -1, 101, 300, + 361, 672, 480, 558, 661, 980, 41, 716, 1039, -1, + 101, 672, 351, 480, 558, 528, 665, 529, 980, 41, + 716, 1039, -1, 101, 300, 361, 672, 351, 480, 558, + 528, 665, 529, 980, 41, 716, 1039, -1, 490, 75, + 298, -1, 490, 65, 75, 298, -1, 490, 244, 75, + 298, -1, -1, 101, 672, 427, 1042, 41, 716, 1041, + -1, 101, 672, 427, 194, 280, 154, 1042, 41, 716, + 1041, -1, 101, 300, 361, 672, 427, 1042, 41, 716, + 1041, -1, 490, 108, -1, 490, 278, 108, -1, -1, + 558, 661, 646, 636, -1, 23, -1, 24, -1, 25, + -1, 26, -1, 27, -1, 28, -1, 29, -1, 30, + -1, 32, -1, 33, -1, 34, -1, 44, -1, 45, + -1, 48, -1, 49, -1, 51, -1, 52, -1, 53, + -1, 61, -1, 62, -1, 63, -1, 64, -1, 65, + -1, 68, -1, 69, -1, 70, -1, 71, -1, 74, + -1, 76, -1, 77, -1, 78, -1, 79, -1, 85, + -1, 86, -1, 87, -1, 88, -1, 89, -1, 91, + -1, 92, -1, 93, -1, 95, -1, 96, -1, 97, + -1, 98, -1, 99, -1, 100, -1, 103, -1, 104, + -1, 105, -1, 106, -1, 107, -1, 108, -1, 109, + -1, 110, -1, 111, -1, 112, -1, 114, -1, 115, + -1, 117, -1, 119, -1, 121, -1, 122, -1, 123, + -1, 124, -1, 125, -1, 126, -1, 129, -1, 130, + -1, 131, -1, 132, -1, 135, -1, 136, -1, 137, + -1, 138, -1, 139, -1, 141, -1, 142, -1, 143, + -1, 145, -1, 146, -1, 147, -1, 148, -1, 150, + -1, 151, -1, 152, -1, 153, -1, 155, -1, 156, + -1, 157, -1, 158, -1, 159, -1, 160, -1, 163, + -1, 165, -1, 166, -1, 168, -1, 170, -1, 172, + -1, 176, -1, 177, -1, 180, -1, 181, -1, 182, + -1, 186, -1, 187, -1, 189, -1, 190, -1, 191, + -1, 192, -1, 193, -1, 194, -1, 195, -1, 197, + -1, 198, -1, 199, -1, 200, -1, 202, -1, 203, + -1, 204, -1, 205, -1, 206, -1, 207, -1, 208, + -1, 210, -1, 213, -1, 214, -1, 215, -1, 216, + -1, 217, -1, 223, -1, 226, -1, 228, -1, 229, + -1, 230, -1, 232, -1, 233, -1, 234, -1, 237, + -1, 239, -1, 242, -1, 243, -1, 244, -1, 245, + -1, 246, -1, 247, -1, 248, -1, 249, -1, 251, + -1, 252, -1, 253, -1, 254, -1, 255, -1, 256, + -1, 257, -1, 258, -1, 259, -1, 260, -1, 261, + -1, 262, -1, 263, -1, 264, -1, 265, -1, 266, + -1, 267, -1, 268, -1, 269, -1, 270, -1, 271, + -1, 272, -1, 276, -1, 277, -1, 278, -1, 281, + -1, 282, -1, 284, -1, 287, -1, 289, -1, 290, + -1, 291, -1, 293, -1, 294, -1, 297, -1, 298, + -1, 299, -1, 302, -1, 303, -1, 306, -1, 309, + -1, 310, -1, 311, -1, 312, -1, 313, -1, 314, + -1, 315, -1, 316, -1, 317, -1, 318, -1, 319, + -1, 320, -1, 325, -1, 326, -1, 329, -1, 330, + -1, 332, -1, 333, -1, 334, -1, 336, -1, 337, + -1, 338, -1, 339, -1, 340, -1, 341, -1, 343, + -1, 344, -1, 345, -1, 346, -1, 347, -1, 349, + -1, 350, -1, 351, -1, 352, -1, 354, -1, 355, + -1, 356, -1, 357, -1, 358, -1, 359, -1, 360, + -1, 361, -1, 362, -1, 363, -1, 364, -1, 365, + -1, 366, -1, 368, -1, 369, -1, 371, -1, 372, + -1, 373, -1, 375, -1, 376, -1, 377, -1, 378, + -1, 379, -1, 380, -1, 381, -1, 382, -1, 383, + -1, 384, -1, 385, -1, 386, -1, 387, -1, 390, + -1, 391, -1, 392, -1, 393, -1, 394, -1, 395, + -1, 397, -1, 398, -1, 401, -1, 402, -1, 404, + -1, 406, -1, 407, -1, 408, -1, 409, -1, 410, + -1, 411, -1, 412, -1, 413, -1, 414, -1, 415, + -1, 416, -1, 417, -1, 418, -1, 419, -1, 421, + -1, 425, -1, 426, -1, 428, -1, 430, -1, 431, + -1, 432, -1, 433, -1, 434, -1, 435, -1, 437, + -1, 442, -1, 443, -1, 445, -1, 448, -1, 449, + -1, 451, -1, 452, -1, 453, -1, 454, -1, 455, + -1, 458, -1, 459, -1, 460, -1, 463, -1, 464, + -1, 465, -1, 466, -1, 468, -1, 469, -1, 470, + -1, 471, -1, 472, -1, 475, -1, 477, -1, 479, + -1, 480, -1, 481, -1, 482, -1, 483, -1, 484, + -1, 485, -1, 488, -1, 491, -1, 492, -1, 493, + -1, 494, -1, 495, -1, 496, -1, 508, -1, 509, + -1, 510, -1, 511, -1, 54, -1, 55, -1, 57, + -1, 58, -1, 72, -1, 73, -1, 80, -1, 84, + -1, 113, -1, 116, -1, 154, -1, 161, -1, 167, + -1, 178, -1, 184, -1, 185, -1, 212, -1, 218, + -1, 219, -1, 221, -1, 250, -1, 273, -1, 275, + -1, 279, -1, 286, -1, 288, -1, 304, -1, 308, + -1, 327, -1, 331, -1, 348, -1, 374, -1, 396, + -1, 403, -1, 420, -1, 422, -1, 438, -1, 439, + -1, 444, -1, 446, -1, 450, -1, 473, -1, 474, + -1, 497, -1, 498, -1, 499, -1, 500, -1, 501, + -1, 502, -1, 503, -1, 504, -1, 505, -1, 506, + -1, 507, -1, 43, -1, 47, -1, 50, -1, 56, + -1, 82, -1, 90, -1, 102, -1, 173, -1, 175, + -1, 178, -1, 179, -1, 196, -1, 211, -1, 224, + -1, 225, -1, 227, -1, 238, -1, 240, -1, 250, + -1, 274, -1, 283, -1, 305, -1, 307, -1, 328, + -1, 370, -1, 400, -1, 420, -1, 429, -1, 478, + -1, 38, -1, 43, -1, 47, -1, 50, -1, 56, + -1, 60, -1, 82, -1, 84, -1, 90, -1, 102, + -1, 173, -1, 175, -1, 179, -1, 196, -1, 211, + -1, 224, -1, 225, -1, 227, -1, 238, -1, 240, + -1, 274, -1, 283, -1, 305, -1, 307, -1, 328, + -1, 370, -1, 389, -1, 400, -1, 429, -1, 450, + -1, 461, -1, 478, -1, 38, -1, 43, -1, 47, + -1, 50, -1, 54, -1, 55, -1, 56, -1, 57, + -1, 58, -1, 60, -1, 73, -1, 72, -1, 80, + -1, 82, -1, 84, -1, 90, -1, 102, -1, 113, + -1, 116, -1, 154, -1, 161, -1, 167, -1, 173, + -1, 175, -1, 178, -1, 179, -1, 184, -1, 185, + -1, 196, -1, 211, -1, 212, -1, 219, -1, 221, + -1, 218, -1, 224, -1, 225, -1, 227, -1, 238, + -1, 240, -1, 250, -1, 273, -1, 274, -1, 275, + -1, 279, -1, 283, -1, 286, -1, 288, -1, 305, + -1, 304, -1, 307, -1, 308, -1, 327, -1, 328, + -1, 331, -1, 348, -1, 370, -1, 374, -1, 389, + -1, 396, -1, 400, -1, 403, -1, 420, -1, 422, + -1, 429, -1, 438, -1, 439, -1, 444, -1, 446, + -1, 450, -1, 461, -1, 473, -1, 474, -1, 478, + -1, 497, -1, 498, -1, 499, -1, 500, -1, 501, + -1, 502, -1, 503, -1, 504, -1, 505, -1, 506, + -1, 507, -1, 38, -1, 43, -1, 47, -1, 50, + -1, 56, -1, 60, -1, 82, -1, 84, -1, 90, + -1, 102, -1, 173, -1, 175, -1, 178, -1, 179, + -1, 196, -1, 211, -1, 224, -1, 225, -1, 227, + -1, 238, -1, 240, -1, 250, -1, 274, -1, 283, + -1, 305, -1, 307, -1, 328, -1, 370, -1, 389, + -1, 400, -1, 420, -1, 429, -1, 450, -1, 461, + -1, 478, -1, 31, -1, 35, -1, 36, -1, 37, + -1, 39, -1, 40, -1, 41, -1, 42, -1, 46, + -1, 59, -1, 66, -1, 67, -1, 75, -1, 81, + -1, 83, -1, 94, -1, 101, -1, 118, -1, 120, + -1, 127, -1, 128, -1, 133, -1, 134, -1, 140, + -1, 144, -1, 149, -1, 162, -1, 164, -1, 169, + -1, 171, -1, 174, -1, 183, -1, 188, -1, 201, + -1, 209, -1, 220, -1, 222, -1, 231, -1, 235, + -1, 236, -1, 241, -1, 280, -1, 285, -1, 292, + -1, 295, -1, 296, -1, 300, -1, 301, -1, 321, + -1, 322, -1, 323, -1, 324, -1, 335, -1, 342, + -1, 353, -1, 367, -1, 388, -1, 399, -1, 405, + -1, 423, -1, 424, -1, 427, -1, 436, -1, 440, + -1, 441, -1, 447, -1, 456, -1, 457, -1, 462, + -1, 467, -1, 476, -1, 486, -1, 487, -1, 489, + -1, 490, -1 }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ static const yytype_uint16 yyrline[] = { - 0, 522, 522, 538, 550, 559, 560, 561, 562, 563, - 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, - 574, 575, 576, 577, 578, 579, 580, 581, 582, 583, - 584, 585, 586, 587, 588, 589, 590, 591, 592, 593, - 594, 595, 596, 597, 598, 599, 600, 601, 603, 9, + 0, 524, 524, 540, 552, 561, 562, 563, 564, 565, + 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, + 576, 577, 578, 579, 580, 581, 582, 583, 584, 585, + 586, 587, 588, 589, 590, 591, 592, 593, 594, 595, + 596, 597, 598, 599, 600, 601, 602, 603, 605, 9, 18, 27, 36, 45, 54, 63, 72, 85, 87, 93, 94, 99, 103, 107, 118, 126, 130, 138, 139, 143, 150, 151, 156, 163, 173, 182, 191, 200, 209, 217, @@ -2699,139 +2703,140 @@ static const yytype_uint16 yyrline[] = 76, 80, 84, 88, 92, 97, 101, 105, 112, 113, 117, 118, 119, 7, 16, 7, 16, 28, 29, 2, 10, 17, 24, 32, 40, 51, 52, 53, 57, 58, - 59, 2, 7, 21, 36, 56, 57, 84, 85, 86, - 87, 88, 89, 93, 94, 99, 104, 105, 106, 107, - 108, 113, 120, 121, 122, 139, 146, 153, 163, 173, - 185, 193, 202, 220, 221, 225, 226, 230, 239, 262, - 276, 283, 288, 290, 292, 294, 297, 300, 301, 302, - 303, 308, 312, 313, 318, 325, 330, 331, 332, 333, - 334, 335, 336, 337, 343, 344, 348, 353, 360, 367, - 374, 386, 387, 388, 389, 393, 398, 399, 400, 405, - 410, 411, 412, 413, 414, 415, 420, 440, 466, 474, - 484, 485, 489, 493, 494, 495, 499, 503, 511, 512, - 517, 518, 519, 523, 531, 532, 537, 538, 542, 547, - 551, 555, 560, 568, 569, 573, 574, 578, 579, 585, - 596, 609, 623, 637, 651, 665, 688, 692, 699, 703, - 711, 716, 723, 733, 734, 735, 736, 737, 744, 751, - 752, 757, 758, 9, 19, 29, 39, 49, 59, 73, - 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, - 84, 85, 86, 87, 88, 89, 90, 95, 96, 97, - 98, 99, 100, 105, 106, 111, 112, 113, 118, 119, - 120, 7, 29, 30, 34, 35, 39, 39, 43, 51, - 58, 65, 71, 80, 87, 95, 101, 111, 112, 116, - 126, 127, 128, 132, 142, 142, 146, 147, 7, 16, - 25, 34, 43, 52, 64, 74, 84, 88, 95, 99, - 103, 113, 117, 124, 125, 130, 134, 138, 145, 149, - 156, 164, 172, 7, 1, 30, 49, 61, 62, 63, - 67, 68, 73, 77, 94, 95, 99, 100, 105, 106, - 110, 111, 115, 119, 124, 125, 130, 134, 139, 143, - 147, 151, 155, 159, 163, 167, 171, 175, 179, 183, - 187, 191, 195, 199, 211, 212, 213, 214, 215, 216, - 217, 47, 48, 52, 53, 54, 72, 73, 80, 88, - 96, 104, 112, 120, 131, 132, 159, 164, 172, 188, - 205, 223, 241, 242, 261, 265, 269, 273, 277, 287, - 298, 308, 317, 328, 339, 351, 366, 384, 384, 388, - 388, 392, 392, 396, 402, 409, 413, 414, 418, 419, - 433, 440, 447, 457, 458, 461, 475, 476, 480, 481, - 485, 486, 490, 491, 492, 496, 507, 515, 520, 525, - 530, 535, 543, 551, 556, 561, 568, 569, 573, 574, - 575, 579, 586, 587, 591, 592, 596, 597, 598, 602, - 603, 607, 608, 624, 625, 628, 637, 648, 649, 650, - 653, 654, 655, 659, 660, 661, 662, 666, 667, 671, - 673, 689, 691, 696, 699, 704, 708, 712, 719, 723, - 727, 731, 738, 743, 750, 751, 755, 760, 764, 768, - 776, 783, 784, 789, 790, 795, 796, 800, 810, 811, - 816, 817, 822, 824, 826, 831, 851, 852, 854, 859, - 860, 864, 865, 868, 869, 894, 895, 900, 904, 905, - 909, 910, 914, 915, 916, 917, 918, 922, 935, 942, - 949, 956, 957, 961, 962, 966, 967, 971, 972, 976, - 977, 981, 982, 986, 997, 998, 999, 1000, 1004, 1005, - 1010, 1011, 1012, 1021, 1027, 1036, 1037, 1050, 1051, 1055, - 1056, 1060, 1061, 1065, 1076, 1083, 1090, 1098, 1106, 1116, - 1124, 1133, 1142, 1151, 1155, 1160, 1165, 1176, 1190, 1191, - 1194, 1195, 1196, 1199, 1207, 1217, 1218, 1219, 1222, 1230, - 1239, 1243, 1250, 1251, 1255, 1264, 1268, 1293, 1297, 1310, - 1324, 1339, 1351, 1364, 1378, 1392, 1405, 1420, 1439, 1445, - 1450, 1456, 1463, 1464, 1472, 1476, 1480, 1486, 1493, 1498, - 1499, 1500, 1501, 1502, 1503, 1507, 1508, 1520, 1521, 1526, - 1533, 1540, 1547, 1579, 1590, 1603, 1608, 1609, 1612, 1613, - 1616, 1617, 1622, 1623, 1628, 1632, 1638, 1659, 1667, 1681, - 1684, 1688, 1688, 1691, 1692, 1694, 1699, 1706, 1711, 1717, - 1722, 1728, 1733, 1740, 1747, 1757, 1758, 1762, 1764, 1767, - 1771, 1772, 1773, 1774, 1775, 1776, 1781, 1801, 1802, 1803, - 1804, 1815, 1829, 1830, 1836, 1841, 1846, 1851, 1856, 1861, - 1866, 1871, 1877, 1883, 1889, 1896, 1918, 1927, 1931, 1939, - 1943, 1951, 1963, 1984, 1988, 1994, 1998, 2011, 2019, 2029, - 2031, 2033, 2035, 2037, 2039, 2044, 2045, 2052, 2061, 2069, - 2078, 2089, 2097, 2098, 2099, 2103, 2103, 2106, 2106, 2109, - 2109, 2112, 2112, 2115, 2115, 2118, 2118, 2121, 2121, 2124, - 2124, 2127, 2127, 2130, 2130, 2133, 2133, 2136, 2136, 2139, - 2139, 2142, 2144, 2146, 2148, 2150, 2152, 2154, 2156, 2158, - 2160, 2162, 2164, 2166, 2168, 2173, 2178, 2184, 2191, 2196, - 2202, 2208, 2239, 2241, 2243, 2251, 2266, 2268, 2270, 2272, - 2274, 2276, 2278, 2280, 2282, 2284, 2286, 2288, 2290, 2292, - 2294, 2296, 2299, 2301, 2303, 2306, 2308, 2310, 2312, 2314, - 2319, 2324, 2331, 2336, 2343, 2348, 2355, 2360, 2368, 2376, - 2384, 2392, 2410, 2418, 2426, 2434, 2442, 2450, 2458, 2466, - 2470, 2486, 2494, 2502, 2510, 2518, 2526, 2534, 2538, 2542, - 2546, 2550, 2558, 2566, 2574, 2582, 2602, 2624, 2635, 2642, - 2656, 2664, 2669, 2679, 2688, 2709, 2711, 2713, 2715, 2717, - 2719, 2721, 2723, 2725, 2727, 2729, 2731, 2733, 2735, 2737, - 2739, 2741, 2743, 2745, 2747, 2749, 2751, 2755, 2759, 2763, - 2777, 2778, 2792, 2793, 2794, 2805, 2829, 2840, 2850, 2854, - 2858, 2865, 2869, 2876, 2883, 2884, 2885, 2886, 2887, 2888, - 2889, 2890, 2901, 2906, 2915, 2921, 2928, 2948, 2952, 2959, - 2966, 2974, 2982, 2993, 3013, 3049, 3060, 3061, 3068, 3074, - 3076, 3078, 3082, 3091, 3096, 3103, 3118, 3125, 3129, 3133, - 3137, 3141, 3151, 3160, 3182, 3183, 3187, 3188, 3189, 3193, - 3194, 3201, 3202, 3206, 3207, 3212, 3220, 3222, 3236, 3239, - 3266, 3267, 3270, 3271, 3279, 3287, 3295, 3304, 3314, 3332, - 3378, 3387, 3396, 3405, 3414, 3426, 3427, 3428, 3429, 3430, - 3444, 3445, 3448, 3449, 3453, 3463, 3464, 3468, 3469, 3473, - 3480, 3481, 3486, 3487, 3492, 3493, 3496, 3497, 3498, 3501, - 3502, 3505, 3506, 3507, 3508, 3509, 3510, 3511, 3512, 3513, - 3514, 3515, 3516, 3517, 3518, 3521, 3523, 3528, 3530, 3535, - 3537, 3539, 3541, 3543, 3545, 3547, 3549, 3563, 3565, 3570, - 3574, 3581, 3586, 3592, 3596, 3603, 3608, 3615, 3620, 3628, - 3632, 3638, 3642, 3651, 3662, 3663, 3667, 3671, 3678, 3679, - 3680, 3681, 3682, 3683, 3684, 3685, 3686, 3687, 3688, 3689, - 3690, 3691, 3692, 3702, 3706, 3713, 3720, 3721, 3737, 3741, - 3746, 3750, 3765, 3770, 3774, 3777, 3780, 3781, 3782, 3785, - 3792, 3793, 3794, 3804, 3818, 3819, 3823, 3834, 3835, 3838, - 3839, 3847, 3853, 3857, 3864, 3872, 3880, 3888, 3898, 3899, - 3904, 3905, 3909, 3910, 3911, 3915, 3924, 3932, 3940, 3949, - 3964, 3965, 3970, 3971, 3981, 3982, 3986, 3987, 3991, 3992, - 3995, 4011, 4019, 4027, 4037, 4038, 4042, 4046, 4052, 4054, - 4059, 4060, 4064, 4065, 4068, 4072, 4073, 4077, 4078, 4081, - 4082, 4083, 4086, 4090, 4091, 4095, 4096, 4098, 4099, 4100, - 4110, 4111, 4115, 4117, 4123, 4124, 4128, 4129, 4132, 4143, - 4146, 4157, 4161, 4165, 4177, 4181, 4190, 4197, 4235, 4239, - 4243, 4247, 4251, 4255, 4259, 4265, 4282, 4283, 4284, 4287, - 4288, 4289, 4292, 4293, 4294, 4297, 4298, 4301, 4303, 4308, - 4309, 4312, 4316, 4317, 7, 18, 19, 23, 24, 25, - 26, 27, 28, 7, 26, 50, 73, 80, 85, 86, - 87, 88, 8, 33, 62, 66, 67, 72, 73, 78, - 79, 83, 84, 89, 90, 7, 16, 25, 34, 43, - 52, 5, 12, 22, 23, 7, 15, 26, 27, 30, - 31, 32, 33, 34, 35, 36, 37, 38, 39, 7, - 19, 33, 9, 16, 26, 33, 44, 45, 50, 51, - 52, 57, 58, 59, 60, 61, 62, 63, 64, 65, - 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, - 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, - 86, 87, 88, 92, 93, 94, 99, 100, 105, 109, - 117, 118, 123, 124, 125, 131, 136, 144, 145, 10, - 16, 22, 28, 34, 44, 45, 53, 64, 76, 84, - 95, 101, 105, 109, 124, 131, 132, 133, 137, 138, - 7, 17, 26, 35, 46, 47, 49, 50, 53, 54, - 55, 8, 22, 36, 48, 56, 70, 71, 72, 73, - 74, 87, 88, 93, 94, 98, 99, 7, 18, 31, - 35, 42, 53, 54, 60, 61, 9, 19, 7, 16, - 25, 37, 44, 51, 60, 61, 65, 66, 77, 78, - 82, 89, 93, 100, 105, 2, 7, 12, 17, 22, - 31, 38, 48, 49, 56, 3, 10, 17, 24, 32, - 39, 46, 53, 60, 69, 69, 71, 71, 73, 73, - 75, 76, 6, 8, 21, 34, 47, 65, 87, 88, - 89, 90, 11, 24, 37, 54, 55, 56, 61, 74, + 59, 2, 7, 31, 56, 86, 87, 114, 115, 116, + 117, 118, 119, 123, 124, 128, 133, 134, 135, 136, + 137, 142, 149, 150, 151, 168, 175, 182, 192, 202, + 214, 222, 231, 249, 250, 254, 255, 259, 268, 291, + 305, 312, 317, 319, 321, 323, 326, 329, 330, 331, + 332, 337, 340, 341, 346, 353, 358, 359, 360, 361, + 362, 363, 364, 365, 371, 372, 375, 380, 387, 394, + 401, 412, 413, 417, 421, 428, 429, 430, 431, 434, + 439, 440, 441, 446, 451, 452, 453, 454, 455, 456, + 461, 481, 507, 515, 525, 526, 530, 534, 535, 536, + 540, 544, 552, 553, 558, 559, 560, 564, 572, 573, + 578, 579, 583, 588, 592, 596, 601, 605, 609, 616, + 617, 621, 622, 626, 627, 633, 644, 657, 671, 685, + 699, 713, 736, 740, 747, 751, 759, 764, 771, 781, + 782, 783, 784, 785, 792, 799, 800, 804, 805, 9, + 19, 29, 39, 49, 59, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 95, 96, 97, 98, 99, 100, 105, + 106, 111, 112, 113, 118, 119, 120, 7, 29, 30, + 34, 35, 39, 39, 43, 51, 58, 65, 71, 80, + 87, 95, 101, 111, 112, 116, 126, 127, 128, 132, + 142, 142, 146, 147, 7, 16, 25, 34, 43, 52, + 64, 74, 84, 88, 95, 99, 103, 113, 117, 124, + 125, 130, 134, 138, 145, 149, 156, 164, 172, 7, + 1, 30, 49, 61, 62, 63, 67, 68, 73, 77, + 94, 95, 99, 100, 105, 106, 110, 111, 115, 119, + 124, 125, 130, 134, 139, 143, 147, 151, 155, 159, + 163, 167, 171, 175, 179, 183, 187, 191, 195, 199, + 211, 212, 213, 214, 215, 216, 217, 47, 48, 52, + 53, 54, 72, 73, 80, 88, 96, 104, 112, 120, + 131, 132, 159, 164, 172, 188, 205, 223, 241, 242, + 261, 265, 269, 273, 277, 287, 298, 308, 317, 328, + 339, 351, 366, 384, 384, 388, 388, 392, 392, 396, + 402, 409, 413, 414, 418, 419, 433, 440, 447, 457, + 458, 461, 475, 476, 480, 481, 485, 486, 490, 491, + 492, 496, 507, 515, 520, 525, 530, 535, 543, 551, + 556, 561, 568, 569, 573, 574, 575, 579, 586, 587, + 591, 592, 596, 597, 598, 602, 603, 607, 608, 624, + 625, 628, 637, 648, 649, 650, 653, 654, 655, 659, + 660, 661, 662, 666, 667, 671, 673, 689, 691, 696, + 699, 704, 708, 712, 719, 723, 727, 731, 738, 743, + 750, 751, 755, 760, 764, 768, 776, 783, 784, 789, + 790, 795, 796, 800, 810, 811, 816, 817, 822, 824, + 826, 831, 851, 852, 854, 859, 860, 864, 865, 868, + 869, 894, 895, 900, 904, 905, 909, 910, 914, 915, + 916, 917, 918, 922, 935, 942, 949, 956, 957, 961, + 962, 966, 967, 971, 972, 976, 977, 981, 982, 986, + 997, 998, 999, 1000, 1004, 1005, 1010, 1011, 1012, 1021, + 1027, 1036, 1037, 1050, 1051, 1055, 1056, 1060, 1061, 1065, + 1076, 1083, 1090, 1098, 1106, 1116, 1124, 1133, 1142, 1151, + 1155, 1160, 1165, 1176, 1190, 1191, 1194, 1195, 1196, 1199, + 1207, 1217, 1218, 1219, 1222, 1230, 1239, 1243, 1250, 1251, + 1255, 1264, 1268, 1293, 1297, 1310, 1324, 1339, 1351, 1364, + 1378, 1392, 1405, 1420, 1439, 1445, 1450, 1456, 1463, 1464, + 1472, 1476, 1480, 1486, 1493, 1498, 1499, 1500, 1501, 1502, + 1503, 1507, 1508, 1520, 1521, 1526, 1533, 1540, 1547, 1579, + 1590, 1603, 1608, 1609, 1612, 1613, 1616, 1617, 1622, 1623, + 1628, 1632, 1638, 1659, 1667, 1681, 1684, 1688, 1688, 1691, + 1692, 1694, 1699, 1706, 1711, 1717, 1722, 1728, 1733, 1740, + 1747, 1757, 1758, 1762, 1764, 1767, 1771, 1772, 1773, 1774, + 1775, 1776, 1781, 1801, 1802, 1803, 1804, 1815, 1829, 1830, + 1836, 1841, 1846, 1851, 1856, 1861, 1866, 1871, 1877, 1883, + 1889, 1896, 1918, 1927, 1931, 1939, 1943, 1951, 1963, 1984, + 1988, 1994, 1998, 2011, 2019, 2029, 2031, 2033, 2035, 2037, + 2039, 2044, 2045, 2052, 2061, 2069, 2078, 2089, 2097, 2098, + 2099, 2103, 2103, 2106, 2106, 2109, 2109, 2112, 2112, 2115, + 2115, 2118, 2118, 2121, 2121, 2124, 2124, 2127, 2127, 2130, + 2130, 2133, 2133, 2136, 2136, 2139, 2139, 2142, 2144, 2146, + 2148, 2150, 2152, 2154, 2156, 2158, 2160, 2162, 2164, 2166, + 2168, 2173, 2178, 2184, 2191, 2196, 2202, 2208, 2239, 2241, + 2243, 2251, 2266, 2268, 2270, 2272, 2274, 2276, 2278, 2280, + 2282, 2284, 2286, 2288, 2290, 2292, 2294, 2296, 2299, 2301, + 2303, 2306, 2308, 2310, 2312, 2314, 2319, 2324, 2331, 2336, + 2343, 2348, 2355, 2360, 2368, 2376, 2384, 2392, 2410, 2418, + 2426, 2434, 2442, 2450, 2458, 2466, 2470, 2486, 2494, 2502, + 2510, 2518, 2526, 2534, 2538, 2542, 2546, 2550, 2558, 2566, + 2574, 2582, 2602, 2624, 2635, 2642, 2656, 2664, 2669, 2679, + 2688, 2709, 2711, 2713, 2715, 2717, 2719, 2721, 2723, 2725, + 2727, 2729, 2731, 2733, 2735, 2737, 2739, 2741, 2743, 2745, + 2747, 2749, 2751, 2755, 2759, 2763, 2777, 2778, 2792, 2793, + 2794, 2805, 2829, 2840, 2850, 2854, 2858, 2865, 2869, 2876, + 2883, 2884, 2885, 2886, 2887, 2888, 2889, 2890, 2901, 2906, + 2915, 2921, 2928, 2948, 2952, 2959, 2966, 2974, 2982, 2993, + 3013, 3049, 3060, 3061, 3068, 3074, 3076, 3078, 3082, 3091, + 3096, 3103, 3118, 3125, 3129, 3133, 3137, 3141, 3151, 3160, + 3182, 3183, 3187, 3188, 3189, 3193, 3194, 3201, 3202, 3206, + 3207, 3212, 3220, 3222, 3236, 3239, 3266, 3267, 3270, 3271, + 3279, 3287, 3295, 3304, 3314, 3332, 3378, 3387, 3396, 3405, + 3414, 3426, 3427, 3428, 3429, 3430, 3444, 3445, 3448, 3449, + 3453, 3463, 3464, 3468, 3469, 3473, 3480, 3481, 3486, 3487, + 3492, 3493, 3496, 3497, 3498, 3501, 3502, 3505, 3506, 3507, + 3508, 3509, 3510, 3511, 3512, 3513, 3514, 3515, 3516, 3517, + 3518, 3521, 3523, 3528, 3530, 3535, 3537, 3539, 3541, 3543, + 3545, 3547, 3549, 3563, 3565, 3570, 3574, 3581, 3586, 3592, + 3596, 3603, 3608, 3615, 3620, 3628, 3632, 3638, 3642, 3651, + 3662, 3663, 3667, 3671, 3678, 3679, 3680, 3681, 3682, 3683, + 3684, 3685, 3686, 3687, 3688, 3689, 3690, 3691, 3692, 3702, + 3706, 3713, 3720, 3721, 3737, 3741, 3746, 3750, 3765, 3770, + 3774, 3777, 3780, 3781, 3782, 3785, 3792, 3793, 3794, 3804, + 3818, 3819, 3823, 3834, 3835, 3838, 3839, 3847, 3853, 3857, + 3864, 3872, 3880, 3888, 3898, 3899, 3904, 3905, 3909, 3910, + 3911, 3915, 3924, 3932, 3940, 3949, 3964, 3965, 3970, 3971, + 3981, 3982, 3986, 3987, 3991, 3992, 3995, 4011, 4019, 4027, + 4037, 4038, 4042, 4046, 4052, 4054, 4059, 4060, 4064, 4065, + 4068, 4072, 4073, 4077, 4078, 4081, 4082, 4083, 4086, 4090, + 4091, 4095, 4096, 4098, 4099, 4100, 4110, 4111, 4115, 4117, + 4123, 4124, 4128, 4129, 4132, 4143, 4146, 4157, 4161, 4165, + 4177, 4181, 4190, 4197, 4235, 4239, 4243, 4247, 4251, 4255, + 4259, 4265, 4282, 4283, 4284, 4287, 4288, 4289, 4292, 4293, + 4294, 4297, 4298, 4301, 4303, 4308, 4309, 4312, 4316, 4317, + 7, 18, 19, 23, 24, 25, 26, 27, 28, 7, + 26, 50, 73, 80, 85, 86, 87, 88, 8, 33, + 62, 66, 67, 72, 73, 78, 79, 83, 84, 89, + 90, 7, 16, 25, 34, 43, 52, 5, 12, 22, + 23, 7, 15, 26, 27, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 7, 19, 33, 9, 16, + 26, 33, 44, 45, 50, 51, 52, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 92, + 93, 94, 99, 100, 105, 109, 117, 118, 123, 124, + 125, 131, 136, 144, 145, 10, 16, 22, 28, 34, + 44, 45, 53, 64, 76, 84, 95, 101, 105, 109, + 124, 131, 132, 133, 137, 138, 7, 17, 26, 35, + 46, 47, 49, 50, 53, 54, 55, 8, 22, 36, + 48, 56, 70, 71, 72, 73, 74, 87, 88, 93, + 94, 98, 99, 7, 18, 31, 35, 42, 53, 54, + 60, 61, 9, 19, 7, 16, 25, 37, 44, 51, + 60, 61, 65, 66, 77, 78, 82, 89, 93, 100, + 105, 2, 7, 12, 17, 22, 31, 38, 48, 49, + 56, 3, 10, 17, 24, 32, 39, 46, 53, 60, + 69, 69, 71, 71, 73, 73, 75, 76, 6, 8, + 21, 34, 47, 65, 87, 88, 89, 90, 11, 24, + 37, 54, 55, 56, 61, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, @@ -2864,19 +2869,18 @@ static const yytype_uint16 yyrline[] = 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, - 74, 74, 74, 74, 74, 74, 74, 74, 74, 75, - 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, + 74, 74, 74, 74, 74, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, - 75, 75, 75, 76, 76, 76, 76, 76, 76, 76, + 75, 75, 75, 75, 75, 75, 75, 75, 75, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, - 76, 76, 77, 77, 77, 77, 77, 77, 77, 77, + 76, 76, 76, 76, 76, 76, 76, 76, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, - 77, 77, 77, 77, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, @@ -2884,18 +2888,19 @@ static const yytype_uint16 yyrline[] = 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, - 78, 78, 78, 78, 78, 78, 78, 78, 79, 79, - 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, + 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, + 78, 78, 78, 78, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, - 79, 79, 79, 80, 80, 80, 80, 80, 80, 80, + 79, 79, 79, 79, 79, 79, 79, 79, 79, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, - 80, 80, 80, 80, 80, 80, 80, 80 + 80, 80, 80, 80 }; #endif @@ -3020,20 +3025,22 @@ static const char *const yytname[] = "GeneratedConstraintElem", "generic_option_elem", "key_update", "key_actions", "OnCommitOption", "reloptions", "opt_no_inherit", "TableConstraint", "TableLikeOption", "reloption_list", "ExistingIndex", - "ConstraintAttr", "OptWith", "definition", "TableLikeOptionList", - "generic_option_name", "ConstraintAttributeElem", "regularColumnDef", - "generatedColumnDef", "columnDef", "def_list", "index_name", - "TableElement", "def_elem", "opt_definition", "OptTableElementList", - "columnElem", "opt_column_list", "ColQualList", "key_delete", - "reloption_elem", "columnList", "columnList_opt_comma", "func_type", - "ConstraintElem", "TableElementList", "key_match", "TableLikeClause", - "OptTemp", "generated_when", "DropStmt", "drop_type_any_name", - "drop_type_name", "any_name_list", "opt_drop_behavior", - "drop_type_name_on_any_name", "MergeIntoStmt", "opt_and_clause", - "opt_insert_column_list", "opt_star_expr", "matched_clause_action", - "opt_error_message", "matched_clause", "opt_source_or_target", - "not_matched_clause", "matched_or_not_matched_clause", - "merge_match_list", "CreateFunctionStmt", "table_macro_definition", + "ConstraintAttr", "OptPartitionSortedOptions", + "OptPartitionSortedOption", "OptWith", "definition", + "TableLikeOptionList", "generic_option_name", "ConstraintAttributeElem", + "regularColumnDef", "generatedColumnDef", "columnDef", "def_list", + "index_name", "TableElement", "def_elem", "opt_definition", + "OptTableElementList", "columnElem", "opt_column_list", "ColQualList", + "key_delete", "reloption_elem", "columnList", "columnList_opt_comma", + "func_type", "ConstraintElem", "TableElementList", "key_match", + "TableLikeClause", "OptTemp", "generated_when", "DropStmt", + "drop_type_any_name", "drop_type_name", "any_name_list", + "opt_drop_behavior", "drop_type_name_on_any_name", "MergeIntoStmt", + "opt_and_clause", "opt_insert_column_list", "opt_star_expr", + "matched_clause_action", "opt_error_message", "matched_clause", + "opt_source_or_target", "not_matched_clause", + "matched_or_not_matched_clause", "merge_match_list", + "CreateFunctionStmt", "table_macro_definition", "table_macro_definition_parens", "table_macro_list_internal", "table_macro_list", "macro_definition", "macro_definition_list", "macro_alias", "param_list", "MacroParameterList", "MacroParameter", @@ -3239,196 +3246,197 @@ static const yytype_uint16 yyr1[] = 633, 634, 635, 635, 635, 635, 635, 636, 636, 636, 636, 637, 638, 638, 639, 639, 640, 640, 640, 640, 640, 640, 640, 640, 641, 641, 642, 643, 643, 643, - 643, 644, 644, 644, 644, 645, 646, 646, 646, 647, - 648, 648, 648, 648, 648, 648, 649, 650, 651, 651, - 652, 652, 653, 654, 654, 654, 655, 655, 656, 656, - 657, 657, 657, 658, 659, 659, 660, 660, 661, 662, - 662, 662, 662, 663, 663, 664, 664, 665, 665, 665, - 666, 666, 666, 666, 666, 666, 667, 667, 668, 668, - 668, 668, 669, 670, 670, 670, 670, 670, 670, 670, - 670, 671, 671, 672, 672, 672, 672, 672, 672, 673, - 673, 673, 673, 673, 673, 673, 673, 673, 673, 673, - 673, 673, 673, 673, 673, 673, 673, 674, 674, 674, - 674, 674, 674, 675, 675, 676, 676, 676, 677, 677, - 677, 678, 679, 679, 680, 680, 681, 681, 682, 682, - 682, 682, 682, 682, 682, 682, 682, 683, 683, 684, - 685, 685, 685, 686, 687, 687, 688, 688, 689, 689, - 689, 689, 689, 689, 690, 691, 692, 692, 693, 693, - 694, 695, 695, 696, 696, 697, 697, 697, 698, 698, - 699, 699, 699, 700, 701, 701, 701, 702, 702, 702, - 703, 703, 704, 704, 705, 705, 706, 706, 707, 707, - 708, 708, 709, 709, 710, 710, 711, 711, 712, 712, - 712, 712, 712, 712, 712, 712, 712, 712, 712, 712, - 712, 712, 712, 712, 713, 713, 713, 713, 713, 713, - 713, 714, 714, 715, 715, 715, 716, 716, 716, 716, - 716, 716, 716, 716, 717, 717, 718, 718, 719, 719, - 719, 719, 719, 719, 719, 719, 719, 719, 719, 719, - 719, 719, 719, 719, 719, 719, 719, 720, 720, 721, - 721, 722, 722, 723, 723, 723, 724, 724, 725, 725, - 726, 726, 726, 727, 727, 728, 729, 729, 730, 730, - 731, 731, 732, 732, 732, 733, 733, 734, 734, 734, - 734, 734, 734, 734, 734, 734, 735, 735, 736, 736, - 736, 737, 738, 738, 739, 739, 740, 740, 740, 741, - 741, 742, 742, 743, 743, 744, 744, 745, 745, 745, - 746, 746, 746, 747, 747, 747, 747, 748, 748, 749, - 749, 749, 749, 750, 750, 751, 751, 751, 752, 752, - 752, 752, 753, 753, 754, 754, 755, 755, 755, 755, - 756, 757, 757, 758, 758, 759, 759, 760, 761, 761, - 762, 762, 762, 762, 762, 763, 764, 764, 764, 765, - 765, 766, 766, 767, 767, 768, 768, 768, 769, 769, - 770, 770, 771, 771, 771, 771, 771, 772, 773, 774, - 775, 776, 776, 777, 777, 778, 778, 779, 779, 780, - 780, 781, 781, 782, 783, 783, 783, 783, 784, 784, - 785, 785, 785, 786, 786, 787, 787, 788, 788, 789, - 789, 790, 790, 791, 792, 792, 792, 792, 792, 792, - 792, 792, 792, 792, 792, 792, 792, 792, 793, 793, - 794, 794, 794, 795, 795, 796, 796, 796, 797, 797, - 798, 798, 799, 799, 800, 801, 801, 802, 802, 802, - 802, 802, 802, 802, 802, 802, 802, 802, 803, 803, - 803, 803, 804, 804, 805, 805, 805, 805, 805, 806, - 806, 806, 806, 806, 806, 807, 807, 808, 808, 809, - 809, 809, 809, 810, 810, 811, 812, 812, 813, 813, - 814, 814, 815, 815, 816, 816, 817, 818, 818, 819, - 819, 820, 820, 821, 821, 822, 822, 822, 822, 822, - 822, 822, 822, 822, 822, 823, 823, 824, 824, 824, - 825, 825, 825, 825, 825, 825, 825, 826, 826, 826, - 826, 827, 828, 828, 829, 829, 829, 829, 829, 829, - 829, 829, 829, 829, 829, 830, 830, 831, 831, 832, - 832, 833, 834, 835, 835, 836, 836, 837, 838, 839, - 839, 839, 839, 839, 839, 840, 840, 841, 841, 841, - 841, 842, 843, 843, 843, 844, 844, 845, 845, 846, - 846, 847, 847, 848, 848, 849, 849, 850, 850, 851, - 851, 852, 852, 853, 853, 854, 854, 855, 855, 856, - 856, 857, 857, 857, 857, 857, 857, 857, 857, 857, - 857, 857, 857, 857, 857, 857, 857, 857, 857, 857, - 857, 857, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 858, 858, 858, 858, 859, 859, 859, 859, 859, + 643, 644, 644, 645, 645, 646, 646, 646, 646, 647, + 648, 648, 648, 649, 650, 650, 650, 650, 650, 650, + 651, 652, 653, 653, 654, 654, 655, 656, 656, 656, + 657, 657, 658, 658, 659, 659, 659, 660, 661, 661, + 662, 662, 663, 664, 664, 664, 664, 664, 664, 665, + 665, 666, 666, 667, 667, 667, 668, 668, 668, 668, + 668, 668, 669, 669, 670, 670, 670, 670, 671, 672, + 672, 672, 672, 672, 672, 672, 672, 673, 673, 674, + 674, 674, 674, 674, 674, 675, 675, 675, 675, 675, + 675, 675, 675, 675, 675, 675, 675, 675, 675, 675, + 675, 675, 675, 676, 676, 676, 676, 676, 676, 677, + 677, 678, 678, 678, 679, 679, 679, 680, 681, 681, + 682, 682, 683, 683, 684, 684, 684, 684, 684, 684, + 684, 684, 684, 685, 685, 686, 687, 687, 687, 688, + 689, 689, 690, 690, 691, 691, 691, 691, 691, 691, + 692, 693, 694, 694, 695, 695, 696, 697, 697, 698, + 698, 699, 699, 699, 700, 700, 701, 701, 701, 702, + 703, 703, 703, 704, 704, 704, 705, 705, 706, 706, + 707, 707, 708, 708, 709, 709, 710, 710, 711, 711, + 712, 712, 713, 713, 714, 714, 714, 714, 714, 714, + 714, 714, 714, 714, 714, 714, 714, 714, 714, 714, + 715, 715, 715, 715, 715, 715, 715, 716, 716, 717, + 717, 717, 718, 718, 718, 718, 718, 718, 718, 718, + 719, 719, 720, 720, 721, 721, 721, 721, 721, 721, + 721, 721, 721, 721, 721, 721, 721, 721, 721, 721, + 721, 721, 721, 722, 722, 723, 723, 724, 724, 725, + 725, 725, 726, 726, 727, 727, 728, 728, 728, 729, + 729, 730, 731, 731, 732, 732, 733, 733, 734, 734, + 734, 735, 735, 736, 736, 736, 736, 736, 736, 736, + 736, 736, 737, 737, 738, 738, 738, 739, 740, 740, + 741, 741, 742, 742, 742, 743, 743, 744, 744, 745, + 745, 746, 746, 747, 747, 747, 748, 748, 748, 749, + 749, 749, 749, 750, 750, 751, 751, 751, 751, 752, + 752, 753, 753, 753, 754, 754, 754, 754, 755, 755, + 756, 756, 757, 757, 757, 757, 758, 759, 759, 760, + 760, 761, 761, 762, 763, 763, 764, 764, 764, 764, + 764, 765, 766, 766, 766, 767, 767, 768, 768, 769, + 769, 770, 770, 770, 771, 771, 772, 772, 773, 773, + 773, 773, 773, 774, 775, 776, 777, 778, 778, 779, + 779, 780, 780, 781, 781, 782, 782, 783, 783, 784, + 785, 785, 785, 785, 786, 786, 787, 787, 787, 788, + 788, 789, 789, 790, 790, 791, 791, 792, 792, 793, + 794, 794, 794, 794, 794, 794, 794, 794, 794, 794, + 794, 794, 794, 794, 795, 795, 796, 796, 796, 797, + 797, 798, 798, 798, 799, 799, 800, 800, 801, 801, + 802, 803, 803, 804, 804, 804, 804, 804, 804, 804, + 804, 804, 804, 804, 805, 805, 805, 805, 806, 806, + 807, 807, 807, 807, 807, 808, 808, 808, 808, 808, + 808, 809, 809, 810, 810, 811, 811, 811, 811, 812, + 812, 813, 814, 814, 815, 815, 816, 816, 817, 817, + 818, 818, 819, 820, 820, 821, 821, 822, 822, 823, + 823, 824, 824, 824, 824, 824, 824, 824, 824, 824, + 824, 825, 825, 826, 826, 826, 827, 827, 827, 827, + 827, 827, 827, 828, 828, 828, 828, 829, 830, 830, + 831, 831, 831, 831, 831, 831, 831, 831, 831, 831, + 831, 832, 832, 833, 833, 834, 834, 835, 836, 837, + 837, 838, 838, 839, 840, 841, 841, 841, 841, 841, + 841, 842, 842, 843, 843, 843, 843, 844, 845, 845, + 845, 846, 846, 847, 847, 848, 848, 849, 849, 850, + 850, 851, 851, 852, 852, 853, 853, 854, 854, 855, + 855, 856, 856, 857, 857, 858, 858, 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, - 859, 859, 859, 859, 859, 859, 859, 859, 859, 859, - 860, 860, 861, 861, 861, 861, 861, 861, 862, 862, - 862, 863, 863, 863, 864, 864, 864, 864, 864, 864, - 864, 864, 864, 864, 865, 866, 867, 868, 868, 868, - 868, 868, 868, 868, 869, 869, 870, 870, 871, 871, - 871, 871, 871, 871, 871, 871, 871, 871, 871, 871, - 871, 871, 872, 872, 873, 873, 874, 874, 874, 875, - 875, 876, 876, 877, 877, 878, 879, 879, 879, 880, - 881, 881, 882, 882, 883, 883, 883, 883, 884, 884, - 885, 885, 885, 885, 885, 886, 886, 886, 886, 886, - 887, 887, 888, 888, 889, 890, 890, 891, 891, 892, - 893, 893, 894, 894, 895, 895, 896, 896, 896, 897, - 897, 898, 898, 898, 898, 898, 898, 898, 898, 898, - 898, 898, 898, 898, 898, 899, 899, 900, 900, 901, - 901, 901, 901, 901, 901, 901, 901, 902, 902, 903, - 903, 904, 904, 905, 905, 906, 906, 907, 907, 908, - 908, 909, 909, 909, 910, 910, 911, 911, 912, 912, - 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, - 912, 912, 912, 913, 913, 914, 915, 915, 916, 916, - 916, 916, 916, 916, 917, 918, 919, 919, 919, 920, - 920, 920, 920, 921, 922, 922, 923, 924, 924, 925, - 925, 926, 927, 927, 563, 563, 563, 563, 928, 928, - 929, 929, 930, 930, 930, 931, 931, 931, 931, 931, - 932, 932, 933, 933, 934, 934, 935, 935, 936, 936, - 937, 937, 937, 937, 938, 938, 939, 939, 940, 940, - 941, 941, 942, 942, 943, 944, 944, 945, 945, 946, - 946, 946, 947, 948, 948, 949, 949, 950, 950, 950, - 951, 951, 952, 952, 953, 953, 954, 954, 955, 956, - 956, 957, 957, 957, 957, 957, 957, 957, 957, 957, - 957, 957, 957, 957, 957, 958, 959, 959, 959, 960, - 960, 960, 961, 961, 961, 962, 962, 963, 963, 964, - 964, 965, 966, 966, 967, 968, 968, 969, 969, 969, - 969, 969, 969, 970, 970, 970, 971, 971, 972, 972, - 972, 972, 973, 973, 974, 975, 975, 976, 976, 977, - 977, 978, 978, 979, 979, 980, 980, 980, 980, 980, - 980, 981, 981, 982, 982, 983, 983, 984, 984, 985, - 985, 985, 985, 985, 985, 985, 985, 985, 985, 986, - 986, 987, 988, 988, 988, 988, 989, 989, 990, 990, - 990, 991, 991, 991, 991, 991, 991, 991, 991, 991, - 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, - 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, - 991, 991, 991, 992, 992, 992, 993, 993, 994, 994, - 995, 995, 996, 996, 996, 996, 997, 998, 998, 999, - 999, 999, 999, 999, 1000, 1000, 1000, 1000, 1001, 1001, - 1002, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1004, 1004, - 1005, 1005, 1005, 1005, 1006, 1006, 1007, 1007, 1008, 1008, - 1008, 1009, 1009, 1009, 1009, 1009, 1010, 1010, 1010, 1010, - 1010, 1011, 1011, 1012, 1012, 1013, 1013, 1014, 1014, 1015, - 1015, 1015, 1016, 1016, 1017, 1017, 1018, 1018, 1019, 1019, - 1019, 1020, 1020, 1020, 1021, 1021, 1022, 1022, 1023, 1023, - 1024, 1025, 1025, 1026, 1026, 1027, 1027, 1027, 1027, 1027, - 1028, 1028, 1029, 1029, 1029, 1030, 1030, 1030, 1030, 1030, - 1030, 1030, 1030, 1030, 1031, 1031, 1032, 1032, 1033, 1033, - 1034, 1034, 1035, 1036, 1036, 1036, 1036, 1036, 1037, 1037, - 1037, 1037, 1038, 1038, 1038, 1039, 1039, 1039, 1040, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, - 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1041, 1042, - 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, - 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, - 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, - 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, - 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, 1042, - 1042, 1042, 1042, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 859, 859, 859, 859, 859, 859, 859, 859, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 861, 861, 861, 861, 861, 861, 861, 861, 861, + 861, 861, 861, 861, 861, 861, 861, 861, 861, 861, + 861, 861, 861, 861, 861, 861, 862, 862, 863, 863, + 863, 863, 863, 863, 864, 864, 864, 865, 865, 865, + 866, 866, 866, 866, 866, 866, 866, 866, 866, 866, + 867, 868, 869, 870, 870, 870, 870, 870, 870, 870, + 871, 871, 872, 872, 873, 873, 873, 873, 873, 873, + 873, 873, 873, 873, 873, 873, 873, 873, 874, 874, + 875, 875, 876, 876, 876, 877, 877, 878, 878, 879, + 879, 880, 881, 881, 881, 882, 883, 883, 884, 884, + 885, 885, 885, 885, 886, 886, 887, 887, 887, 887, + 887, 888, 888, 888, 888, 888, 889, 889, 890, 890, + 891, 892, 892, 893, 893, 894, 895, 895, 896, 896, + 897, 897, 898, 898, 898, 899, 899, 900, 900, 900, + 900, 900, 900, 900, 900, 900, 900, 900, 900, 900, + 900, 901, 901, 902, 902, 903, 903, 903, 903, 903, + 903, 903, 903, 904, 904, 905, 905, 906, 906, 907, + 907, 908, 908, 909, 909, 910, 910, 911, 911, 911, + 912, 912, 913, 913, 914, 914, 914, 914, 914, 914, + 914, 914, 914, 914, 914, 914, 914, 914, 914, 915, + 915, 916, 917, 917, 918, 918, 918, 918, 918, 918, + 919, 920, 921, 921, 921, 922, 922, 922, 922, 923, + 924, 924, 925, 926, 926, 927, 927, 928, 929, 929, + 563, 563, 563, 563, 930, 930, 931, 931, 932, 932, + 932, 933, 933, 933, 933, 933, 934, 934, 935, 935, + 936, 936, 937, 937, 938, 938, 939, 939, 939, 939, + 940, 940, 941, 941, 942, 942, 943, 943, 944, 944, + 945, 946, 946, 947, 947, 948, 948, 948, 949, 950, + 950, 951, 951, 952, 952, 952, 953, 953, 954, 954, + 955, 955, 956, 956, 957, 958, 958, 959, 959, 959, + 959, 959, 959, 959, 959, 959, 959, 959, 959, 959, + 959, 960, 961, 961, 961, 962, 962, 962, 963, 963, + 963, 964, 964, 965, 965, 966, 966, 967, 968, 968, + 969, 970, 970, 971, 971, 971, 971, 971, 971, 972, + 972, 972, 973, 973, 974, 974, 974, 974, 975, 975, + 976, 977, 977, 978, 978, 979, 979, 980, 980, 981, + 981, 982, 982, 982, 982, 982, 982, 983, 983, 984, + 984, 985, 985, 986, 986, 987, 987, 987, 987, 987, + 987, 987, 987, 987, 987, 988, 988, 989, 990, 990, + 990, 990, 991, 991, 992, 992, 992, 993, 993, 993, + 993, 993, 993, 993, 993, 993, 993, 993, 993, 993, + 993, 993, 993, 993, 993, 993, 993, 993, 993, 993, + 993, 993, 993, 993, 993, 993, 993, 993, 993, 994, + 994, 994, 995, 995, 996, 996, 997, 997, 998, 998, + 998, 998, 999, 1000, 1000, 1001, 1001, 1001, 1001, 1001, + 1002, 1002, 1002, 1002, 1003, 1003, 1004, 1005, 1005, 1005, + 1005, 1005, 1005, 1005, 1006, 1006, 1007, 1007, 1007, 1007, + 1008, 1008, 1009, 1009, 1010, 1010, 1010, 1011, 1011, 1011, + 1011, 1011, 1012, 1012, 1012, 1012, 1012, 1013, 1013, 1014, + 1014, 1015, 1015, 1016, 1016, 1017, 1017, 1017, 1018, 1018, + 1019, 1019, 1020, 1020, 1021, 1021, 1021, 1022, 1022, 1022, + 1023, 1023, 1024, 1024, 1025, 1025, 1026, 1027, 1027, 1028, + 1028, 1029, 1029, 1029, 1029, 1029, 1030, 1030, 1031, 1031, + 1031, 1032, 1032, 1032, 1032, 1032, 1032, 1032, 1032, 1032, + 1033, 1033, 1034, 1034, 1035, 1035, 1036, 1036, 1037, 1038, + 1038, 1038, 1038, 1038, 1039, 1039, 1039, 1039, 1040, 1040, + 1040, 1041, 1041, 1041, 1042, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, - 1043, 1043, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, 1043, + 1043, 1043, 1043, 1043, 1043, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, - 1044, 1044, 1044, 1044, 1045, 1045, 1045, 1045, 1045, 1045, - 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, - 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, - 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, - 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, - 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, + 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, + 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, + 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1044, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1045, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, 1046, - 1046, 1046, 1046, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, - 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047 + 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, + 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, 1047, + 1047, 1047, 1047, 1047, 1048, 1048, 1048, 1048, 1048, 1048, + 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, + 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, + 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1048, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, 1049, + 1049, 1049, 1049, 1049 }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ @@ -3463,139 +3471,140 @@ static const yytype_uint8 yyr2[] = 2, 2, 2, 3, 3, 3, 1, 3, 1, 0, 1, 2, 2, 6, 8, 5, 7, 0, 2, 2, 3, 3, 2, 2, 2, 1, 1, 0, 2, 2, - 0, 2, 9, 12, 11, 0, 2, 1, 1, 1, + 0, 2, 10, 13, 12, 0, 2, 1, 1, 1, 1, 1, 1, 3, 0, 1, 2, 1, 1, 2, 2, 3, 1, 1, 2, 2, 1, 2, 3, 5, 3, 2, 5, 1, 1, 1, 0, 5, 7, 5, 2, 3, 1, 1, 2, 2, 0, 3, 4, 4, 0, 3, 2, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 1, 2, 2, - 2, 2, 2, 2, 0, 3, 3, 3, 0, 1, - 2, 1, 2, 2, 2, 2, 2, 3, 2, 2, - 1, 3, 1, 1, 1, 1, 3, 1, 2, 0, - 1, 2, 0, 1, 3, 0, 2, 0, 3, 3, - 1, 5, 3, 1, 3, 1, 2, 1, 4, 5, - 5, 6, 3, 7, 4, 11, 1, 3, 2, 2, - 2, 0, 3, 1, 1, 2, 2, 2, 2, 1, - 0, 1, 2, 6, 4, 6, 4, 6, 8, 1, - 1, 1, 1, 2, 1, 2, 1, 2, 1, 1, - 1, 1, 3, 3, 3, 3, 1, 2, 2, 1, - 3, 1, 1, 1, 3, 1, 1, 0, 1, 1, - 1, 9, 2, 0, 3, 0, 1, 0, 3, 3, - 2, 1, 6, 3, 3, 2, 2, 1, 0, 5, - 2, 2, 0, 7, 1, 1, 1, 2, 5, 8, - 7, 5, 8, 7, 4, 4, 1, 3, 1, 1, - 3, 1, 3, 1, 1, 2, 4, 3, 1, 3, - 2, 4, 4, 8, 11, 9, 7, 0, 3, 3, - 1, 1, 3, 0, 1, 0, 1, 0, 1, 0, - 1, 3, 2, 0, 2, 0, 1, 0, 1, 1, - 1, 3, 3, 1, 1, 3, 3, 3, 3, 3, - 3, 4, 3, 2, 1, 1, 1, 3, 1, 3, - 1, 1, 1, 3, 3, 3, 1, 2, 4, 4, - 2, 3, 5, 5, 1, 1, 3, 0, 11, 11, - 10, 12, 1, 2, 5, 4, 4, 4, 4, 7, - 5, 4, 7, 6, 9, 9, 4, 1, 1, 1, - 1, 1, 1, 1, 5, 1, 1, 3, 1, 2, - 2, 2, 3, 1, 3, 8, 5, 0, 1, 2, - 1, 3, 1, 2, 0, 2, 0, 3, 3, 4, - 4, 4, 4, 3, 2, 1, 1, 0, 1, 1, - 0, 2, 1, 5, 1, 0, 2, 2, 0, 1, - 0, 3, 5, 1, 3, 4, 3, 1, 1, 0, - 2, 2, 0, 2, 2, 1, 1, 1, 0, 2, - 4, 5, 4, 2, 3, 1, 1, 1, 2, 2, - 1, 2, 3, 0, 1, 0, 5, 1, 4, 6, - 2, 1, 0, 4, 0, 1, 1, 3, 4, 0, - 1, 1, 2, 2, 2, 1, 1, 2, 2, 1, - 1, 1, 1, 1, 1, 3, 3, 0, 1, 3, - 1, 2, 1, 1, 1, 1, 1, 2, 4, 4, - 5, 1, 1, 2, 0, 2, 0, 1, 3, 1, - 0, 1, 2, 3, 2, 4, 2, 3, 2, 0, - 1, 2, 0, 4, 5, 1, 2, 2, 0, 1, - 3, 1, 2, 2, 4, 4, 3, 3, 3, 3, - 3, 3, 3, 1, 4, 4, 9, 9, 3, 0, - 2, 2, 0, 5, 3, 1, 1, 3, 5, 3, - 1, 2, 1, 3, 5, 1, 2, 3, 4, 5, - 4, 5, 4, 6, 5, 4, 5, 5, 5, 2, - 4, 1, 1, 0, 1, 4, 5, 4, 0, 2, - 2, 2, 1, 1, 1, 1, 0, 4, 2, 1, - 2, 2, 4, 2, 6, 2, 1, 3, 4, 0, - 2, 0, 2, 0, 1, 3, 3, 2, 0, 2, - 4, 1, 1, 1, 0, 2, 3, 5, 6, 2, - 3, 2, 5, 5, 5, 3, 3, 3, 4, 0, - 1, 1, 1, 1, 1, 2, 4, 1, 1, 1, - 1, 2, 3, 0, 1, 1, 1, 1, 1, 2, - 2, 2, 2, 2, 1, 3, 0, 1, 1, 1, - 1, 5, 2, 1, 1, 1, 1, 4, 1, 2, - 2, 1, 3, 3, 2, 1, 0, 5, 2, 5, - 2, 1, 3, 3, 0, 1, 1, 1, 1, 1, + 2, 2, 0, 5, 5, 2, 2, 2, 0, 3, + 3, 3, 0, 1, 2, 1, 2, 2, 2, 2, + 2, 3, 2, 2, 1, 3, 1, 1, 1, 1, + 3, 1, 2, 0, 1, 2, 0, 1, 3, 0, + 2, 0, 3, 3, 1, 5, 3, 3, 1, 1, + 3, 1, 2, 1, 4, 5, 5, 6, 3, 7, + 4, 11, 1, 3, 2, 2, 2, 0, 3, 1, + 1, 2, 2, 2, 2, 1, 0, 1, 2, 6, + 4, 6, 4, 6, 8, 1, 1, 1, 1, 2, + 1, 2, 1, 2, 1, 1, 1, 1, 3, 3, + 3, 3, 1, 2, 2, 1, 3, 1, 1, 1, + 3, 1, 1, 0, 1, 1, 1, 9, 2, 0, + 3, 0, 1, 0, 3, 3, 2, 1, 6, 3, + 3, 2, 2, 1, 0, 5, 2, 2, 0, 7, + 1, 1, 1, 2, 5, 8, 7, 5, 8, 7, + 4, 4, 1, 3, 1, 1, 3, 1, 3, 1, + 1, 2, 4, 3, 1, 3, 2, 4, 4, 8, + 11, 9, 7, 0, 3, 3, 1, 1, 3, 0, + 1, 0, 1, 0, 1, 0, 1, 3, 2, 0, + 2, 0, 1, 0, 1, 1, 1, 3, 3, 1, + 1, 3, 3, 3, 3, 3, 3, 4, 3, 2, + 1, 1, 1, 3, 1, 3, 1, 1, 1, 3, + 3, 3, 1, 2, 4, 4, 2, 3, 5, 5, + 1, 1, 3, 0, 11, 11, 10, 12, 1, 2, + 5, 4, 4, 4, 4, 7, 5, 4, 7, 6, + 9, 9, 4, 1, 1, 1, 1, 1, 1, 1, + 5, 1, 1, 3, 1, 2, 2, 2, 3, 1, + 3, 8, 5, 0, 1, 2, 1, 3, 1, 2, + 0, 2, 0, 3, 3, 4, 4, 4, 4, 3, + 2, 1, 1, 0, 1, 1, 0, 2, 1, 5, + 1, 0, 2, 2, 0, 1, 0, 3, 5, 1, + 3, 4, 3, 1, 1, 0, 2, 2, 0, 2, + 2, 1, 1, 1, 0, 2, 4, 5, 4, 2, + 3, 1, 1, 1, 2, 2, 1, 2, 3, 0, + 1, 0, 5, 1, 4, 6, 2, 1, 0, 4, + 0, 1, 1, 3, 4, 0, 1, 1, 2, 2, + 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, + 1, 3, 3, 0, 1, 3, 1, 2, 1, 1, + 1, 1, 1, 2, 4, 4, 5, 1, 1, 2, + 0, 2, 0, 1, 3, 1, 0, 1, 2, 3, + 2, 4, 2, 3, 2, 0, 1, 2, 0, 4, + 5, 1, 2, 2, 0, 1, 3, 1, 2, 2, + 4, 4, 3, 3, 3, 3, 3, 3, 3, 1, + 4, 4, 9, 9, 3, 0, 2, 2, 0, 5, + 3, 1, 1, 3, 5, 3, 1, 2, 1, 3, + 5, 1, 2, 3, 4, 5, 4, 5, 4, 6, + 5, 4, 5, 5, 5, 2, 4, 1, 1, 0, + 1, 4, 5, 4, 0, 2, 2, 2, 1, 1, + 1, 1, 0, 4, 2, 1, 2, 2, 4, 2, + 6, 2, 1, 3, 4, 0, 2, 0, 2, 0, + 1, 3, 3, 2, 0, 2, 4, 1, 1, 1, + 0, 2, 3, 5, 6, 2, 3, 2, 5, 5, + 5, 3, 3, 3, 4, 0, 1, 1, 1, 1, + 1, 2, 4, 1, 1, 1, 1, 2, 3, 0, + 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, + 1, 3, 0, 1, 1, 1, 1, 5, 2, 1, + 1, 1, 1, 4, 1, 2, 2, 1, 3, 3, + 2, 1, 0, 5, 2, 5, 2, 1, 3, 3, + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, - 3, 0, 1, 3, 3, 5, 2, 2, 3, 3, - 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 2, 2, 3, 3, 2, 2, 3, - 3, 5, 4, 6, 3, 5, 4, 6, 4, 6, - 5, 7, 3, 2, 4, 3, 2, 4, 3, 3, - 3, 3, 4, 3, 4, 3, 4, 5, 6, 6, - 7, 6, 7, 6, 7, 3, 4, 4, 6, 1, - 4, 4, 5, 4, 6, 1, 3, 2, 2, 3, + 3, 3, 3, 3, 3, 3, 3, 0, 1, 3, + 3, 5, 2, 2, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, + 2, 3, 3, 2, 2, 3, 3, 5, 4, 6, + 3, 5, 4, 6, 4, 6, 5, 7, 3, 2, + 4, 3, 2, 4, 3, 3, 3, 3, 4, 3, + 4, 3, 4, 5, 6, 6, 7, 6, 7, 6, + 7, 3, 4, 4, 6, 1, 4, 4, 5, 4, + 6, 1, 3, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, - 3, 3, 3, 3, 2, 2, 5, 6, 6, 7, - 1, 2, 1, 1, 1, 2, 2, 4, 3, 1, - 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, - 1, 2, 4, 2, 3, 3, 4, 3, 5, 6, - 7, 9, 7, 7, 5, 1, 1, 1, 5, 6, - 6, 4, 4, 4, 4, 6, 5, 5, 5, 4, - 6, 4, 7, 9, 5, 0, 5, 4, 0, 1, - 0, 2, 0, 1, 3, 3, 2, 2, 0, 6, - 1, 0, 3, 0, 3, 3, 3, 0, 1, 4, - 2, 2, 2, 2, 2, 3, 2, 2, 3, 0, - 4, 3, 1, 5, 3, 1, 3, 1, 2, 3, - 1, 3, 1, 2, 1, 0, 1, 1, 1, 1, + 2, 2, 5, 6, 6, 7, 1, 2, 1, 1, + 1, 2, 2, 4, 3, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 1, 1, 2, 4, 2, + 3, 3, 4, 3, 5, 6, 7, 9, 7, 7, + 5, 1, 1, 1, 5, 6, 6, 4, 4, 4, + 4, 6, 5, 5, 5, 4, 6, 4, 7, 9, + 5, 0, 5, 4, 0, 1, 0, 2, 0, 1, + 3, 3, 2, 2, 0, 6, 1, 0, 3, 0, + 3, 3, 3, 0, 1, 4, 2, 2, 2, 2, + 2, 3, 2, 2, 3, 0, 4, 3, 1, 5, + 3, 1, 3, 1, 2, 3, 1, 3, 1, 2, + 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 4, 1, 4, 1, - 4, 1, 2, 1, 2, 1, 2, 1, 3, 1, - 3, 1, 2, 1, 3, 1, 2, 1, 0, 1, - 3, 1, 3, 3, 1, 3, 3, 0, 1, 1, + 1, 1, 4, 1, 4, 1, 4, 1, 2, 1, + 2, 1, 2, 1, 3, 1, 3, 1, 2, 1, + 3, 1, 2, 1, 0, 1, 3, 1, 3, 3, + 1, 3, 3, 0, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, + 3, 2, 3, 0, 3, 3, 2, 2, 1, 0, + 2, 2, 3, 2, 1, 1, 3, 1, 1, 5, + 1, 2, 4, 2, 0, 1, 0, 1, 1, 2, + 3, 5, 7, 7, 1, 0, 0, 2, 0, 2, + 3, 3, 3, 5, 7, 7, 0, 2, 1, 0, + 1, 0, 1, 3, 1, 2, 3, 2, 1, 3, + 4, 2, 1, 3, 1, 3, 1, 2, 1, 0, + 3, 1, 3, 1, 2, 4, 2, 0, 3, 1, + 3, 1, 2, 4, 2, 0, 1, 3, 1, 3, + 1, 2, 1, 3, 1, 1, 2, 1, 1, 2, + 1, 1, 2, 7, 2, 5, 3, 3, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 2, 2, 3, 3, 0, 1, 1, 1, + 5, 3, 0, 1, 1, 1, 1, 1, 1, 4, + 7, 6, 2, 0, 1, 1, 1, 1, 13, 16, + 1, 2, 0, 1, 0, 1, 0, 2, 0, 1, + 0, 6, 8, 6, 8, 6, 8, 3, 2, 1, + 0, 6, 6, 1, 1, 1, 1, 1, 1, 2, + 1, 1, 1, 1, 1, 4, 6, 3, 2, 4, + 3, 5, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 4, 3, 2, 3, 0, 3, 3, - 2, 2, 1, 0, 2, 2, 3, 2, 1, 1, - 3, 1, 1, 5, 1, 2, 4, 2, 0, 1, - 0, 1, 1, 2, 3, 5, 7, 7, 1, 0, - 0, 2, 0, 2, 3, 3, 3, 5, 7, 7, - 0, 2, 1, 0, 1, 0, 1, 3, 1, 2, - 3, 2, 1, 3, 4, 2, 1, 3, 1, 3, - 1, 2, 1, 0, 3, 1, 3, 1, 2, 4, - 2, 0, 3, 1, 3, 1, 2, 4, 2, 0, - 1, 3, 1, 3, 1, 2, 1, 3, 1, 1, - 2, 1, 1, 2, 1, 1, 2, 7, 2, 5, - 3, 3, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 2, 2, 3, 3, - 0, 1, 1, 1, 5, 3, 0, 1, 1, 1, - 1, 1, 1, 4, 7, 6, 2, 0, 1, 1, - 1, 1, 13, 16, 1, 2, 0, 1, 0, 1, - 0, 2, 0, 1, 0, 6, 8, 6, 8, 6, - 8, 3, 2, 1, 0, 6, 6, 1, 1, 1, - 1, 1, 1, 2, 1, 1, 1, 1, 1, 4, - 6, 3, 2, 4, 3, 5, 1, 0, 1, 1, - 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, - 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, - 3, 3, 3, 3, 1, 3, 3, 2, 3, 3, - 1, 1, 1, 3, 5, 1, 1, 1, 1, 3, - 2, 4, 6, 6, 0, 1, 1, 1, 0, 2, - 2, 4, 6, 5, 4, 6, 1, 1, 1, 1, - 1, 1, 0, 1, 3, 1, 0, 7, 3, 1, - 2, 3, 2, 0, 2, 0, 2, 4, 5, 8, - 7, 2, 3, 5, 1, 0, 2, 0, 1, 0, - 2, 1, 3, 3, 0, 2, 3, 3, 3, 3, - 1, 1, 1, 2, 3, 2, 2, 2, 4, 2, - 3, 4, 3, 1, 1, 1, 1, 1, 1, 0, - 1, 3, 2, 9, 12, 11, 12, 14, 3, 4, - 4, 0, 7, 10, 9, 2, 3, 0, 4, 1, + 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, + 1, 1, 2, 1, 1, 2, 3, 3, 3, 3, + 1, 3, 3, 2, 3, 3, 1, 1, 1, 3, + 5, 1, 1, 1, 1, 3, 2, 4, 6, 6, + 0, 1, 1, 1, 0, 2, 2, 4, 6, 5, + 4, 6, 1, 1, 1, 1, 1, 1, 0, 1, + 3, 1, 0, 7, 3, 1, 2, 3, 2, 0, + 2, 0, 2, 4, 5, 8, 7, 2, 3, 5, + 1, 0, 2, 0, 1, 0, 2, 1, 3, 3, + 0, 2, 3, 3, 3, 3, 1, 1, 1, 2, + 3, 2, 2, 2, 4, 2, 3, 4, 3, 1, + 1, 1, 1, 1, 1, 0, 1, 3, 2, 9, + 12, 11, 12, 14, 3, 4, 4, 0, 7, 10, + 9, 2, 3, 0, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -3659,7 +3668,7 @@ static const yytype_uint8 yyr2[] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1 + 1, 1, 1, 1 }; /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state @@ -3667,2106 +3676,1937 @@ static const yytype_uint8 yyr2[] = means the default is an error. */ static const yytype_uint16 yydefact[] = { - 169, 287, 0, 1491, 1490, 1565, 287, 0, 1424, 0, - 287, 547, 430, 0, 1595, 1594, 0, 224, 287, 0, - 169, 0, 1525, 0, 0, 0, 609, 612, 610, 0, - 0, 0, 287, 655, 0, 1596, 287, 0, 0, 647, - 611, 0, 1542, 0, 0, 0, 0, 0, 2, 4, + 169, 287, 0, 1497, 1496, 1571, 287, 0, 1430, 0, + 287, 553, 436, 0, 1601, 1600, 0, 224, 287, 0, + 169, 0, 1531, 0, 0, 0, 615, 618, 616, 0, + 0, 0, 287, 661, 0, 1602, 287, 0, 0, 653, + 617, 0, 1548, 0, 0, 0, 0, 0, 2, 4, 8, 22, 37, 32, 0, 21, 35, 19, 18, 40, 27, 7, 5, 25, 39, 42, 20, 26, 34, 16, - 41, 14, 38, 585, 571, 660, 584, 0, 0, 168, - 765, 592, 36, 17, 31, 6, 12, 13, 29, 30, - 28, 1447, 45, 33, 0, 43, 23, 9, 10, 24, - 44, 46, 1597, 1593, 11, 47, 15, 286, 285, 279, - 0, 0, 0, 0, 0, 0, 1564, 0, 0, 0, - 290, 125, 1619, 1620, 1621, 1622, 1623, 1624, 1625, 1626, - 1627, 1628, 1629, 2003, 1630, 1631, 2004, 1632, 1633, 2005, - 1634, 1635, 1636, 1949, 1950, 2006, 1951, 1952, 1637, 1638, - 1639, 1640, 1641, 1642, 1643, 1644, 1645, 1953, 1954, 1646, - 1647, 1648, 1649, 1650, 1955, 2007, 1956, 1651, 1652, 1653, - 1654, 1655, 2008, 1656, 1657, 1658, 1659, 1660, 1661, 1662, - 1663, 1664, 2009, 1665, 1666, 1667, 1668, 1669, 1670, 1671, - 1672, 1673, 1674, 1957, 1675, 1676, 1958, 1677, 1678, 1679, - 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, - 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, - 1700, 1701, 1702, 1703, 1704, 1959, 1705, 1706, 1707, 1708, - 1709, 1710, 1960, 1711, 1712, 1713, 1961, 1714, 1715, 1716, - 2010, 2011, 1717, 1718, 1962, 2013, 1719, 1720, 1721, 1963, - 1964, 1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, - 2014, 1731, 1732, 1733, 1734, 1735, 1736, 1737, 1738, 1739, - 1740, 1741, 1742, 2015, 1965, 1743, 1744, 1745, 1746, 1747, - 1966, 1967, 1968, 1748, 2016, 2017, 1749, 2018, 1750, 1751, - 1752, 1753, 1754, 1755, 1756, 2019, 1757, 2020, 1758, 1759, - 1760, 1761, 1762, 1763, 1764, 1765, 1969, 1766, 1767, 1768, - 1769, 1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, - 1779, 1780, 1781, 1782, 1783, 1784, 1785, 1786, 1787, 1970, - 2022, 1971, 1788, 1789, 1790, 1972, 1791, 1792, 2023, 1793, - 1973, 1794, 1974, 1795, 1796, 1797, 1798, 1799, 1800, 1801, - 1802, 1803, 1804, 1975, 2024, 1805, 2025, 1976, 1806, 1807, - 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, - 1818, 1819, 1977, 2026, 1820, 1821, 1978, 1822, 1823, 1824, - 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, - 1835, 1979, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, - 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, - 1854, 2027, 1855, 1856, 1857, 1980, 1858, 1859, 1860, 1861, - 1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 1870, 1871, - 1872, 1873, 1874, 1875, 1876, 1981, 1877, 1878, 2028, 1879, - 1880, 1982, 1881, 1882, 1883, 1884, 1885, 1886, 1887, 1888, - 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1983, 1896, 1984, - 1897, 1898, 1899, 2030, 1900, 1901, 1902, 1903, 1904, 1905, - 1906, 1985, 1986, 1907, 1908, 1987, 1909, 1988, 1910, 1911, - 1989, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 1919, 1920, - 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1990, 1991, - 1929, 1930, 2031, 1931, 1932, 1933, 1934, 1935, 1936, 1937, - 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 1945, 1946, - 1947, 1948, 0, 1602, 0, 1349, 126, 127, 1371, 125, - 1962, 1969, 1983, 1423, 1422, 126, 0, 282, 546, 0, - 0, 0, 0, 0, 0, 226, 0, 424, 423, 1413, - 429, 0, 0, 0, 129, 121, 1822, 128, 1348, 119, - 135, 2183, 2184, 2185, 2186, 2064, 2187, 2188, 2189, 2190, - 2065, 2191, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2192, - 2073, 2193, 2194, 2075, 2074, 2195, 2076, 2196, 2077, 2197, - 2078, 2079, 2198, 2199, 2080, 1671, 2081, 2082, 2200, 2201, - 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2083, 2084, 2209, - 2210, 2085, 2211, 2212, 2086, 2213, 2087, 2088, 2089, 2214, - 2090, 2091, 2215, 2092, 2216, 2217, 2093, 2094, 2097, 2095, - 2218, 2096, 2219, 2098, 2099, 2100, 2220, 2221, 2222, 2101, - 2102, 2223, 2103, 2104, 2105, 2106, 2107, 2224, 2108, 2225, - 2109, 2110, 2226, 2227, 2228, 2229, 2230, 2112, 2111, 2113, - 2114, 2231, 2232, 2233, 2234, 2115, 2116, 2117, 2235, 2236, - 2118, 2237, 2238, 2119, 2120, 2239, 2121, 2122, 2240, 2123, - 2124, 2241, 2125, 2126, 2242, 2243, 2244, 2127, 2245, 2128, - 2129, 2246, 2247, 2130, 2131, 2248, 2132, 2249, 2250, 2133, - 2251, 2252, 2134, 2135, 2253, 2136, 2254, 2255, 2256, 2257, - 2137, 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, - 2147, 1561, 137, 136, 138, 0, 448, 449, 0, 459, - 0, 441, 446, 442, 0, 468, 461, 469, 450, 440, - 462, 451, 439, 225, 0, 470, 456, 444, 0, 0, - 0, 0, 283, 242, 0, 430, 0, 169, 0, 1453, - 1463, 1473, 1468, 1462, 1471, 1460, 1477, 1466, 1452, 1475, - 1461, 1465, 1470, 1458, 1476, 1456, 1474, 1472, 1459, 1467, - 1451, 1455, 1442, 1447, 1480, 1469, 1478, 1464, 1479, 1481, - 1454, 1482, 1457, 0, 1424, 0, 1955, 2007, 1960, 0, - 1973, 0, 1976, 1977, 1858, 1984, 1987, 1988, 1989, 1990, - 0, 839, 128, 123, 823, 0, 587, 0, 769, 783, - 823, 828, 1116, 851, 1117, 0, 130, 1527, 1526, 1520, - 211, 1386, 1581, 1719, 1760, 1875, 1985, 1907, 1929, 1600, - 1582, 1575, 1580, 284, 654, 652, 0, 1305, 1719, 1760, - 1862, 1875, 1985, 1929, 1499, 1504, 0, 290, 1587, 128, - 123, 1586, 0, 593, 646, 0, 291, 1541, 0, 1546, - 0, 1838, 620, 623, 1380, 621, 585, 0, 0, 1, - 169, 0, 175, 0, 0, 650, 650, 0, 650, 0, - 577, 0, 0, 585, 580, 584, 766, 1446, 1556, 0, - 1599, 1899, 1985, 1907, 1589, 1585, 1729, 0, 1729, 0, - 0, 1729, 0, 1729, 0, 1729, 0, 0, 1565, 1567, - 0, 280, 1289, 0, 1350, 131, 0, 0, 1435, 1431, - 1436, 1432, 1437, 1430, 1429, 1438, 1434, 0, 0, 0, - 395, 428, 427, 426, 425, 430, 1729, 1397, 222, 513, - 514, 0, 0, 0, 0, 0, 0, 1408, 122, 120, - 1729, 1562, 457, 458, 0, 447, 443, 445, 0, 0, - 1729, 1375, 467, 463, 1729, 467, 1342, 1729, 0, 0, - 234, 0, 423, 1444, 1483, 2134, 1497, 0, 1498, 1488, - 1450, 1484, 1485, 169, 0, 545, 1421, 0, 0, 0, - 1237, 823, 828, 0, 0, 841, 0, 1257, 0, 1263, - 0, 0, 0, 823, 592, 0, 783, 840, 124, 773, - 0, 821, 822, 702, 702, 655, 0, 636, 0, 702, - 709, 702, 833, 0, 0, 836, 834, 0, 836, 0, - 0, 0, 836, 832, 792, 0, 709, 0, 821, 824, - 702, 0, 843, 1441, 0, 0, 0, 0, 1578, 1576, - 1577, 1583, 0, 1579, 0, 0, 1352, 1354, 1355, 1205, - 1365, 1092, 0, 1950, 1951, 1952, 1280, 1953, 1954, 1956, - 1957, 1958, 1049, 1691, 1959, 1363, 1961, 1963, 1964, 1966, - 1967, 1968, 0, 1969, 1970, 1971, 0, 1364, 1974, 1800, - 1979, 1980, 1982, 1985, 1986, 1362, 0, 1991, 0, 0, - 0, 1323, 1228, 0, 1091, 0, 0, 0, 1282, 1290, - 1084, 0, 0, 887, 888, 909, 910, 889, 915, 916, - 918, 890, 0, 1312, 982, 1080, 1300, 1094, 1089, 1099, - 1095, 1096, 1135, 1097, 1115, 1100, 1172, 1090, 0, 1098, - 1082, 1308, 636, 1306, 0, 1083, 1351, 636, 1304, 1502, - 1500, 1507, 1501, 0, 1503, 0, 0, 0, 281, 124, - 1549, 1548, 1540, 1538, 1539, 1537, 1536, 1543, 0, 1545, - 1447, 1282, 1223, 1225, 0, 622, 0, 0, 627, 574, - 573, 575, 3, 0, 0, 0, 0, 1709, 0, 648, - 649, 0, 0, 0, 0, 0, 0, 0, 0, 750, - 675, 676, 678, 747, 751, 759, 0, 0, 0, 0, - 0, 581, 0, 1380, 1528, 1598, 1592, 0, 1590, 0, + 41, 14, 38, 591, 577, 666, 590, 0, 0, 168, + 771, 598, 36, 17, 31, 6, 12, 13, 29, 30, + 28, 1453, 45, 33, 0, 43, 23, 9, 10, 24, + 44, 46, 1603, 1599, 11, 47, 15, 286, 285, 279, + 0, 0, 0, 0, 0, 0, 1570, 0, 0, 0, + 290, 125, 1625, 1626, 1627, 1628, 1629, 1630, 1631, 1632, + 1633, 1634, 1635, 2009, 1636, 1637, 2010, 1638, 1639, 2011, + 1640, 1641, 1642, 1955, 1956, 2012, 1957, 1958, 1643, 1644, + 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1959, 1960, 1652, + 1653, 1654, 1655, 1656, 1961, 2013, 1962, 1657, 1658, 1659, + 1660, 1661, 2014, 1662, 1663, 1664, 1665, 1666, 1667, 1668, + 1669, 1670, 2015, 1671, 1672, 1673, 1674, 1675, 1676, 1677, + 1678, 1679, 1680, 1963, 1681, 1682, 1964, 1683, 1684, 1685, + 1686, 1687, 1688, 1689, 1690, 1691, 1692, 1693, 1694, 1695, + 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705, + 1706, 1707, 1708, 1709, 1710, 1965, 1711, 1712, 1713, 1714, + 1715, 1716, 1966, 1717, 1718, 1719, 1967, 1720, 1721, 1722, + 2016, 2017, 1723, 1724, 1968, 2019, 1725, 1726, 1727, 1969, + 1970, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, + 2020, 1737, 1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, + 1746, 1747, 1748, 2021, 1971, 1749, 1750, 1751, 1752, 1753, + 1972, 1973, 1974, 1754, 2022, 2023, 1755, 2024, 1756, 1757, + 1758, 1759, 1760, 1761, 1762, 2025, 1763, 2026, 1764, 1765, + 1766, 1767, 1768, 1769, 1770, 1771, 1975, 1772, 1773, 1774, + 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, + 1785, 1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1976, + 2028, 1977, 1794, 1795, 1796, 1978, 1797, 1798, 2029, 1799, + 1979, 1800, 1980, 1801, 1802, 1803, 1804, 1805, 1806, 1807, + 1808, 1809, 1810, 1981, 2030, 1811, 2031, 1982, 1812, 1813, + 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, + 1824, 1825, 1983, 2032, 1826, 1827, 1984, 1828, 1829, 1830, + 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, + 1841, 1985, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, + 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, + 1860, 2033, 1861, 1862, 1863, 1986, 1864, 1865, 1866, 1867, + 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, + 1878, 1879, 1880, 1881, 1882, 1987, 1883, 1884, 2034, 1885, + 1886, 1988, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, + 1895, 1896, 1897, 1898, 1899, 1900, 1901, 1989, 1902, 1990, + 1903, 1904, 1905, 2036, 1906, 1907, 1908, 1909, 1910, 1911, + 1912, 1991, 1992, 1913, 1914, 1993, 1915, 1994, 1916, 1917, + 1995, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, + 1927, 1928, 1929, 1930, 1931, 1932, 1933, 1934, 1996, 1997, + 1935, 1936, 2037, 1937, 1938, 1939, 1940, 1941, 1942, 1943, + 1944, 1945, 1946, 1947, 1948, 1949, 1950, 1998, 1999, 2000, + 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 1951, 1952, + 1953, 1954, 0, 1608, 0, 1355, 126, 127, 1377, 125, + 1968, 1975, 1989, 1429, 1428, 126, 0, 282, 552, 0, + 0, 0, 0, 0, 0, 226, 0, 430, 429, 1419, + 435, 0, 0, 0, 129, 121, 1828, 128, 1354, 119, + 135, 2189, 2190, 2191, 2192, 2070, 2193, 2194, 2195, 2196, + 2071, 2197, 2072, 2073, 2074, 2075, 2076, 2077, 2078, 2198, + 2079, 2199, 2200, 2081, 2080, 2201, 2082, 2202, 2083, 2203, + 2084, 2085, 2204, 2205, 2086, 1677, 2087, 2088, 2206, 2207, + 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2089, 2090, 2215, + 2216, 2091, 2217, 2218, 2092, 2219, 2093, 2094, 2095, 2220, + 2096, 2097, 2221, 2098, 2222, 2223, 2099, 2100, 2103, 2101, + 2224, 2102, 2225, 2104, 2105, 2106, 2226, 2227, 2228, 2107, + 2108, 2229, 2109, 2110, 2111, 2112, 2113, 2230, 2114, 2231, + 2115, 2116, 2232, 2233, 2234, 2235, 2236, 2118, 2117, 2119, + 2120, 2237, 2238, 2239, 2240, 2121, 2122, 2123, 2241, 2242, + 2124, 2243, 2244, 2125, 2126, 2245, 2127, 2128, 2246, 2129, + 2130, 2247, 2131, 2132, 2248, 2249, 2250, 2133, 2251, 2134, + 2135, 2252, 2253, 2136, 2137, 2254, 2138, 2255, 2256, 2139, + 2257, 2258, 2140, 2141, 2259, 2142, 2260, 2261, 2262, 2263, + 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, + 2153, 1567, 137, 136, 138, 0, 454, 455, 0, 465, + 0, 447, 452, 448, 0, 474, 467, 475, 456, 446, + 468, 457, 445, 225, 0, 476, 462, 450, 0, 0, + 0, 0, 283, 242, 0, 436, 0, 169, 0, 1459, + 1469, 1479, 1474, 1468, 1477, 1466, 1483, 1472, 1458, 1481, + 1467, 1471, 1476, 1464, 1482, 1462, 1480, 1478, 1465, 1473, + 1457, 1461, 1448, 1453, 1486, 1475, 1484, 1470, 1485, 1487, + 1460, 1488, 1463, 0, 1430, 0, 1961, 2013, 1966, 0, + 1979, 0, 1982, 1983, 1864, 1990, 1993, 1994, 1995, 1996, + 0, 845, 128, 123, 829, 0, 593, 0, 775, 789, + 829, 834, 1122, 857, 1123, 0, 130, 1533, 1532, 1526, + 211, 1392, 1587, 1725, 1766, 1881, 1991, 1913, 1935, 1606, + 1588, 1581, 1586, 284, 660, 658, 0, 1311, 1725, 1766, + 1868, 1881, 1991, 1935, 1505, 1510, 0, 290, 1593, 128, + 123, 1592, 0, 599, 652, 0, 291, 1547, 0, 1552, + 0, 1844, 626, 629, 1386, 627, 591, 0, 0, 1, + 169, 0, 175, 0, 0, 656, 656, 0, 656, 0, + 583, 0, 0, 591, 586, 590, 772, 1452, 1562, 0, + 1605, 1905, 1991, 1913, 1595, 1591, 1735, 0, 1735, 0, + 0, 1735, 0, 1735, 0, 1735, 0, 0, 1571, 1573, + 0, 280, 1295, 0, 1356, 131, 0, 0, 1441, 1437, + 1442, 1438, 1443, 1436, 1435, 1444, 1440, 0, 0, 0, + 399, 434, 433, 432, 431, 436, 1735, 1403, 222, 519, + 520, 0, 0, 0, 0, 0, 0, 1414, 122, 120, + 1735, 1568, 463, 464, 0, 453, 449, 451, 0, 0, + 1735, 1381, 473, 469, 1735, 473, 1348, 1735, 0, 0, + 234, 0, 429, 1450, 1489, 2140, 1503, 0, 1504, 1494, + 1456, 1490, 1491, 169, 0, 551, 1427, 0, 0, 0, + 1243, 829, 834, 0, 0, 847, 0, 1263, 0, 1269, + 0, 0, 0, 829, 598, 0, 789, 846, 124, 779, + 0, 827, 828, 708, 708, 661, 0, 642, 0, 708, + 715, 708, 839, 0, 0, 842, 840, 0, 842, 0, + 0, 0, 842, 838, 798, 0, 715, 0, 827, 830, + 708, 0, 849, 1447, 0, 0, 0, 0, 1584, 1582, + 1583, 1589, 0, 1585, 0, 0, 1358, 1360, 1361, 1211, + 1371, 1098, 0, 1956, 1957, 1958, 1286, 1959, 1960, 1962, + 1963, 1964, 1055, 1697, 1965, 1369, 1967, 1969, 1970, 1972, + 1973, 1974, 0, 1975, 1976, 1977, 0, 1370, 1980, 1806, + 1985, 1986, 1988, 1991, 1992, 1368, 0, 1997, 0, 0, + 0, 1329, 1234, 0, 1097, 0, 0, 0, 1288, 1296, + 1090, 0, 0, 893, 894, 915, 916, 895, 921, 922, + 924, 896, 0, 1318, 988, 1086, 1306, 1100, 1095, 1105, + 1101, 1102, 1141, 1103, 1121, 1106, 1178, 1096, 0, 1104, + 1088, 1314, 642, 1312, 0, 1089, 1357, 642, 1310, 1508, + 1506, 1513, 1507, 0, 1509, 0, 0, 0, 281, 124, + 1555, 1554, 1546, 1544, 1545, 1543, 1542, 1549, 0, 1551, + 1453, 1288, 1229, 1231, 0, 628, 0, 0, 633, 580, + 579, 581, 3, 0, 0, 0, 0, 1715, 0, 654, + 655, 0, 0, 0, 0, 0, 0, 0, 0, 756, + 681, 682, 684, 753, 757, 765, 0, 0, 0, 0, + 0, 587, 0, 1386, 1534, 1604, 1598, 0, 1596, 0, 0, 0, 0, 0, 153, 153, 0, 0, 0, 0, 0, 113, 51, 106, 0, 0, 0, 0, 256, 269, 0, 0, 0, 0, 0, 266, 0, 0, 249, 53, 243, 245, 0, 153, 0, 49, 0, 0, 0, 55, - 1565, 0, 0, 1574, 288, 289, 1288, 0, 133, 134, - 132, 125, 0, 2148, 2003, 2004, 2005, 2006, 2153, 2007, - 1956, 2008, 2009, 0, 2010, 2011, 1962, 2013, 2014, 2015, - 2016, 2017, 2018, 2019, 2020, 1969, 2022, 2023, 2024, 2025, - 2026, 2027, 2176, 2028, 1983, 2030, 1989, 2181, 0, 2031, - 1107, 658, 1231, 660, 1229, 1381, 0, 126, 1368, 0, - 1433, 0, 0, 0, 0, 543, 0, 0, 0, 0, - 1393, 1729, 223, 227, 0, 1729, 218, 1729, 395, 0, - 1729, 0, 1729, 395, 1729, 0, 1407, 1410, 0, 460, - 455, 453, 452, 454, 1729, 277, 0, 0, 1376, 465, - 466, 0, 434, 0, 0, 436, 0, 0, 239, 0, - 237, 0, 430, 169, 0, 250, 1493, 1494, 1492, 0, - 0, 1487, 1449, 253, 270, 1496, 1486, 1495, 1448, 1443, - 0, 0, 1439, 540, 0, 0, 0, 1238, 958, 957, - 939, 940, 955, 956, 941, 942, 949, 950, 960, 959, - 947, 948, 943, 944, 937, 938, 953, 954, 945, 946, - 951, 952, 935, 936, 1252, 1239, 1240, 1241, 1242, 1243, - 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 0, 0, - 782, 779, 0, 0, 0, 0, 0, 0, 1282, 0, - 1055, 1090, 0, 0, 0, 1223, 1262, 0, 0, 0, - 0, 0, 0, 1223, 1268, 0, 0, 807, 819, 0, - 695, 701, 780, 778, 0, 1305, 770, 0, 853, 783, - 781, 0, 702, 777, 0, 833, 0, 832, 0, 0, - 835, 829, 0, 830, 0, 0, 0, 0, 831, 0, - 0, 0, 0, 0, 702, 0, 819, 0, 776, 850, - 1510, 1518, 212, 0, 1372, 2032, 2033, 2034, 2035, 897, - 2036, 926, 904, 2037, 926, 926, 2038, 2039, 2040, 2041, - 893, 893, 906, 2042, 2043, 2044, 2045, 2046, 894, 895, - 931, 2047, 2048, 2049, 2050, 2051, 0, 0, 2052, 926, - 2053, 893, 2054, 2055, 2056, 898, 2057, 861, 2058, 0, - 2059, 896, 862, 2060, 934, 934, 2061, 0, 2062, 921, - 2063, 0, 1234, 879, 879, 880, 881, 882, 907, 908, - 883, 913, 914, 884, 981, 0, 893, 1373, 1374, 169, - 1584, 1601, 0, 1228, 1101, 925, 912, 1279, 0, 920, - 919, 0, 1228, 902, 901, 900, 1086, 0, 899, 0, - 1185, 926, 926, 924, 1007, 903, 0, 0, 0, 0, - 0, 930, 0, 928, 0, 1008, 986, 987, 0, 0, - 1322, 1331, 1223, 1227, 0, 1084, 1223, 0, 1093, 1103, - 0, 1175, 1177, 0, 0, 0, 1283, 1353, 1085, 0, - 1358, 0, 0, 981, 981, 1311, 1205, 0, 1195, 1198, - 0, 0, 1202, 1203, 1204, 0, 0, 0, 1303, 0, - 1213, 1215, 0, 0, 1023, 1211, 0, 1026, 0, 0, - 0, 0, 1199, 1200, 1201, 1191, 1192, 1193, 1194, 1196, - 1197, 1209, 1190, 1004, 0, 1081, 0, 1138, 0, 1003, - 1309, 768, 0, 1356, 768, 1512, 1516, 1517, 1511, 1515, - 0, 1506, 1505, 1508, 1509, 0, 1550, 1534, 0, 1531, - 1226, 763, 624, 1344, 0, 0, 0, 1555, 174, 173, - 0, 0, 233, 0, 597, 596, 669, 661, 663, 669, - 0, 595, 0, 723, 724, 0, 0, 0, 0, 756, - 754, 1352, 1365, 711, 679, 710, 0, 0, 683, 0, - 715, 982, 749, 579, 673, 674, 677, 578, 0, 752, - 0, 762, 0, 616, 618, 601, 615, 613, 598, 606, - 750, 678, 0, 1557, 0, 0, 1521, 1588, 1591, 0, - 0, 0, 0, 0, 0, 0, 1729, 0, 0, 864, + 1571, 0, 0, 1580, 288, 289, 1294, 0, 133, 134, + 132, 125, 0, 2154, 2009, 2010, 2011, 2012, 2159, 2013, + 1962, 2014, 2015, 0, 2016, 2017, 1968, 2019, 2020, 2021, + 2022, 2023, 2024, 2025, 2026, 1975, 2028, 2029, 2030, 2031, + 2032, 2033, 2182, 2034, 1989, 2036, 1995, 2187, 0, 2037, + 1113, 664, 1237, 666, 1235, 1387, 0, 126, 1374, 0, + 1439, 0, 0, 0, 0, 549, 0, 0, 0, 0, + 1399, 1735, 223, 227, 0, 1735, 218, 1735, 399, 0, + 1735, 0, 1735, 399, 1735, 0, 1413, 1416, 0, 466, + 461, 459, 458, 460, 1735, 277, 0, 0, 1382, 471, + 472, 0, 440, 0, 0, 442, 0, 0, 239, 0, + 237, 0, 436, 169, 0, 250, 1499, 1500, 1498, 0, + 0, 1493, 1455, 253, 270, 1502, 1492, 1501, 1454, 1449, + 0, 0, 1445, 546, 0, 0, 0, 1244, 964, 963, + 945, 946, 961, 962, 947, 948, 955, 956, 966, 965, + 953, 954, 949, 950, 943, 944, 959, 960, 951, 952, + 957, 958, 941, 942, 1258, 1245, 1246, 1247, 1248, 1249, + 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257, 0, 0, + 788, 785, 0, 0, 0, 0, 0, 0, 1288, 0, + 1061, 1096, 0, 0, 0, 1229, 1268, 0, 0, 0, + 0, 0, 0, 1229, 1274, 0, 0, 813, 825, 0, + 701, 707, 786, 784, 0, 1311, 776, 0, 859, 789, + 787, 0, 708, 783, 0, 839, 0, 838, 0, 0, + 841, 835, 0, 836, 0, 0, 0, 0, 837, 0, + 0, 0, 0, 0, 708, 0, 825, 0, 782, 856, + 1516, 1524, 212, 0, 1378, 2038, 2039, 2040, 2041, 903, + 2042, 932, 910, 2043, 932, 932, 2044, 2045, 2046, 2047, + 899, 899, 912, 2048, 2049, 2050, 2051, 2052, 900, 901, + 937, 2053, 2054, 2055, 2056, 2057, 0, 0, 2058, 932, + 2059, 899, 2060, 2061, 2062, 904, 2063, 867, 2064, 0, + 2065, 902, 868, 2066, 940, 940, 2067, 0, 2068, 927, + 2069, 0, 1240, 885, 885, 886, 887, 888, 913, 914, + 889, 919, 920, 890, 987, 0, 899, 1379, 1380, 169, + 1590, 1607, 0, 1234, 1107, 931, 918, 1285, 0, 926, + 925, 0, 1234, 908, 907, 906, 1092, 0, 905, 0, + 1191, 932, 932, 930, 1013, 909, 0, 0, 0, 0, + 0, 936, 0, 934, 0, 1014, 992, 993, 0, 0, + 1328, 1337, 1229, 1233, 0, 1090, 1229, 0, 1099, 1109, + 0, 1181, 1183, 0, 0, 0, 1289, 1359, 1091, 0, + 1364, 0, 0, 987, 987, 1317, 1211, 0, 1201, 1204, + 0, 0, 1208, 1209, 1210, 0, 0, 0, 1309, 0, + 1219, 1221, 0, 0, 1029, 1217, 0, 1032, 0, 0, + 0, 0, 1205, 1206, 1207, 1197, 1198, 1199, 1200, 1202, + 1203, 1215, 1196, 1010, 0, 1087, 0, 1144, 0, 1009, + 1315, 774, 0, 1362, 774, 1518, 1522, 1523, 1517, 1521, + 0, 1512, 1511, 1514, 1515, 0, 1556, 1540, 0, 1537, + 1232, 769, 630, 1350, 0, 0, 0, 1561, 174, 173, + 0, 0, 233, 0, 603, 602, 675, 667, 669, 675, + 0, 601, 0, 729, 730, 0, 0, 0, 0, 762, + 760, 1358, 1371, 717, 685, 716, 0, 0, 689, 0, + 721, 988, 755, 585, 679, 680, 683, 584, 0, 758, + 0, 768, 0, 622, 624, 607, 621, 619, 604, 612, + 756, 684, 0, 1563, 0, 0, 1527, 1594, 1597, 0, + 0, 0, 0, 0, 0, 0, 1735, 0, 0, 870, 74, 70, 97, 345, 152, 0, 0, 0, 0, 0, 0, 0, 0, 0, 105, 102, 0, 0, 103, 104, - 0, 0, 0, 0, 1372, 254, 255, 268, 0, 259, + 0, 0, 0, 0, 1378, 254, 255, 268, 0, 259, 260, 257, 261, 262, 0, 0, 247, 248, 0, 0, 0, 0, 246, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1567, 1566, 0, 1558, 1284, 1289, 660, 660, - 660, 0, 0, 0, 0, 658, 659, 0, 0, 0, - 0, 0, 539, 393, 403, 0, 0, 0, 1397, 222, - 0, 0, 0, 0, 0, 0, 0, 430, 1400, 1398, - 1396, 1399, 1401, 0, 0, 0, 0, 0, 214, 217, - 0, 392, 364, 0, 0, 0, 0, 1412, 0, 0, - 508, 506, 509, 498, 511, 501, 0, 1729, 382, 1409, - 0, 1563, 0, 0, 275, 467, 1377, 0, 464, 467, - 1343, 0, 467, 241, 0, 0, 1445, 1489, 251, 271, - 252, 272, 545, 1569, 1571, 0, 548, 553, 537, 0, - 537, 0, 550, 554, 537, 549, 0, 537, 544, 0, - 1131, 0, 1121, 0, 0, 842, 0, 0, 1122, 1057, - 1058, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1075, - 1074, 1123, 846, 0, 849, 0, 0, 1260, 1261, 0, - 1124, 0, 0, 1267, 0, 0, 0, 1129, 0, 784, - 0, 0, 685, 686, 694, 690, 697, 0, 700, 687, - 636, 586, 1719, 1760, 0, 647, 647, 647, 645, 635, - 0, 727, 785, 0, 775, 0, 0, 0, 808, 0, - 0, 810, 812, 0, 0, 815, 0, 791, 790, 0, - 0, 774, 0, 0, 854, 0, 1348, 0, 0, 213, - 0, 0, 0, 879, 0, 0, 0, 871, 869, 865, - 0, 961, 962, 963, 964, 965, 966, 967, 968, 969, - 970, 971, 972, 973, 885, 1385, 0, 891, 1388, 0, - 1389, 1390, 1387, 1384, 1391, 1392, 0, 0, 0, 0, - 1278, 1274, 0, 0, 0, 0, 0, 1180, 1182, 1184, - 0, 923, 922, 1189, 1195, 1198, 1202, 1203, 1204, 1199, - 1200, 1201, 1191, 1192, 1193, 1194, 1196, 1197, 0, 1217, - 0, 1171, 0, 0, 0, 0, 0, 0, 0, 0, - 1316, 1315, 0, 1339, 0, 1104, 1088, 0, 0, 1178, - 1105, 1313, 1323, 1291, 0, 0, 0, 1361, 1360, 983, - 992, 995, 1028, 1029, 999, 1000, 1001, 1005, 1383, 1382, - 1310, 0, 1302, 0, 0, 984, 1009, 1014, 0, 1269, - 1272, 1045, 1271, 0, 1033, 0, 1022, 0, 1031, 1035, - 1010, 1025, 0, 1006, 0, 1303, 1214, 1216, 0, 1212, - 0, 996, 997, 998, 988, 989, 990, 991, 993, 994, - 1002, 1188, 1186, 1187, 0, 1289, 0, 1301, 0, 0, - 1140, 0, 0, 1030, 1307, 0, 853, 660, 853, 0, - 981, 1551, 1380, 1544, 1380, 1533, 1224, 1345, 1379, 0, - 634, 0, 1553, 160, 164, 0, 0, 1290, 194, 196, - 768, 0, 667, 668, 672, 0, 0, 672, 651, 594, - 1980, 1858, 0, 0, 0, 0, 716, 757, 0, 748, - 713, 714, 0, 712, 1352, 717, 1351, 718, 721, 722, - 684, 1340, 758, 760, 0, 753, 0, 1346, 600, 619, - 0, 0, 0, 0, 0, 583, 582, 764, 1528, 1528, - 1530, 1529, 0, 273, 0, 52, 0, 1729, 76, 0, - 0, 0, 0, 0, 0, 295, 72, 73, 0, 397, - 0, 71, 67, 295, 118, 1729, 467, 1729, 467, 1623, - 1692, 1876, 0, 65, 369, 109, 0, 146, 79, 81, - 400, 0, 354, 0, 0, 99, 114, 139, 0, 0, - 54, 244, 258, 263, 142, 267, 264, 1417, 265, 153, - 0, 50, 0, 140, 0, 1415, 0, 0, 56, 144, - 1419, 1567, 1574, 0, 0, 1288, 0, 658, 658, 658, - 656, 657, 1108, 0, 1230, 0, 1232, 1233, 1022, 1427, - 1426, 1428, 1425, 527, 538, 0, 394, 0, 542, 530, - 531, 539, 1395, 227, 0, 218, 395, 0, 0, 395, - 0, 1397, 0, 0, 222, 228, 0, 0, 0, 0, - 0, 393, 385, 383, 416, 0, 390, 384, 0, 0, - 340, 0, 1617, 0, 1697, 201, 206, 0, 0, 0, - 0, 1366, 2149, 2150, 2151, 2152, 2154, 2155, 2156, 2157, - 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, - 2168, 2169, 2170, 2171, 2172, 2173, 2174, 2175, 2177, 2178, - 2179, 2180, 2181, 2182, 515, 0, 518, 864, 1367, 0, - 0, 0, 0, 0, 277, 278, 433, 1378, 435, 0, - 437, 240, 238, 1440, 1568, 1570, 541, 0, 536, 0, - 563, 0, 0, 0, 0, 0, 0, 0, 0, 1118, - 1236, 0, 1255, 1254, 1056, 1063, 1066, 1070, 1071, 1072, - 1256, 0, 0, 0, 1067, 1068, 1069, 1059, 1060, 1061, - 1062, 1064, 1065, 1073, 851, 0, 0, 845, 1265, 1264, - 1258, 1259, 0, 1126, 1127, 1128, 1266, 0, 0, 820, - 689, 691, 688, 0, 0, 853, 647, 647, 647, 647, - 644, 0, 0, 0, 852, 0, 744, 705, 706, 0, - 0, 816, 814, 0, 838, 0, 811, 0, 817, 0, - 802, 0, 809, 858, 825, 0, 0, 827, 1519, 875, - 0, 870, 866, 0, 0, 0, 876, 0, 0, 0, - 0, 0, 0, 0, 1235, 0, 653, 1102, 0, 0, - 0, 1275, 0, 1050, 892, 905, 1027, 0, 1183, 1106, - 0, 1206, 1170, 933, 932, 934, 934, 1051, 0, 1318, - 1320, 0, 0, 0, 0, 1330, 0, 1053, 0, 1224, - 1174, 1176, 1331, 1087, 917, 981, 0, 0, 0, 0, - 0, 0, 0, 1034, 1024, 0, 1032, 1036, 0, 0, - 0, 1018, 0, 0, 1016, 1046, 1012, 0, 0, 1047, - 1288, 0, 1292, 0, 0, 1139, 1148, 771, 767, 727, - 658, 727, 0, 1513, 1535, 1532, 0, 632, 0, 0, - 1554, 0, 183, 0, 0, 0, 0, 0, 186, 200, - 197, 1553, 0, 0, 662, 664, 0, 1207, 672, 666, - 720, 719, 0, 682, 755, 680, 0, 761, 0, 617, - 0, 603, 0, 794, 0, 0, 1522, 1523, 0, 0, - 0, 0, 344, 0, 0, 0, 295, 0, 405, 0, - 412, 0, 0, 397, 376, 69, 68, 98, 0, 0, - 0, 61, 117, 90, 82, 57, 96, 0, 0, 101, - 0, 94, 111, 112, 110, 115, 0, 305, 330, 0, - 0, 341, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1574, 1560, 1573, 1289, 1289, - 1285, 0, 0, 0, 660, 1109, 0, 526, 568, 565, - 566, 0, 564, 249, 570, 404, 0, 0, 0, 216, - 392, 0, 0, 1412, 500, 503, 1394, 430, 0, 227, - 0, 231, 0, 0, 218, 395, 0, 368, 378, 379, - 364, 391, 362, 361, 363, 0, 1618, 242, 0, 1612, - 0, 208, 204, 395, 1411, 0, 0, 517, 0, 520, - 863, 507, 0, 512, 0, 0, 510, 0, 1406, 276, - 467, 1572, 551, 556, 0, 562, 558, 557, 552, 560, - 559, 555, 1119, 1130, 1253, 0, 0, 0, 0, 844, - 847, 0, 1125, 1120, 818, 0, 0, 727, 0, 0, - 0, 0, 638, 637, 643, 0, 0, 1142, 0, 708, - 813, 0, 0, 0, 800, 789, 795, 796, 0, 0, - 0, 856, 855, 826, 879, 0, 859, 879, 0, 879, - 877, 0, 0, 886, 974, 975, 976, 977, 978, 979, - 980, 911, 0, 1277, 1273, 1179, 1181, 1218, 929, 927, - 1052, 1321, 1314, 1317, 1223, 1325, 1327, 0, 0, 0, - 0, 1338, 0, 1173, 1339, 1359, 985, 0, 0, 1015, - 1270, 1037, 0, 0, 0, 1011, 1206, 0, 0, 0, - 0, 0, 1020, 0, 1296, 1289, 0, 1295, 0, 0, - 0, 0, 1114, 772, 744, 0, 744, 0, 1281, 0, - 628, 630, 633, 169, 1552, 0, 1547, 161, 162, 163, - 0, 0, 0, 178, 155, 0, 0, 0, 195, 183, - 171, 670, 671, 0, 665, 681, 1341, 1347, 602, 0, - 1084, 0, 0, 599, 0, 274, 147, 295, 0, 0, - 75, 0, 414, 356, 406, 389, 371, 0, 0, 0, - 296, 0, 431, 0, 0, 377, 0, 0, 0, 0, - 357, 0, 0, 316, 0, 0, 389, 0, 396, 312, - 313, 0, 60, 91, 0, 87, 0, 116, 0, 0, - 0, 0, 0, 63, 86, 0, 58, 864, 467, 467, - 66, 1372, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, - 2040, 2041, 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, - 2050, 2051, 2169, 2052, 302, 2053, 1800, 2054, 2055, 2056, - 2057, 2058, 0, 2059, 862, 2060, 2061, 2249, 2062, 2063, - 1191, 1192, 301, 300, 399, 297, 407, 299, 0, 1373, - 298, 402, 355, 0, 0, 143, 1418, 0, 141, 0, - 1416, 150, 148, 145, 1420, 1559, 0, 0, 1112, 1113, - 1110, 658, 0, 0, 0, 0, 545, 533, 0, 0, - 0, 1617, 203, 0, 0, 1729, 0, 0, 230, 229, - 219, 0, 1412, 215, 392, 0, 422, 340, 864, 417, - 0, 1617, 1615, 0, 0, 209, 0, 207, 1412, 1611, - 499, 502, 516, 519, 0, 0, 0, 0, 585, 504, - 0, 0, 0, 438, 561, 1076, 0, 0, 0, 0, - 698, 0, 704, 744, 642, 641, 640, 639, 726, 1666, - 1963, 1857, 0, 730, 725, 728, 733, 735, 734, 736, - 732, 743, 0, 746, 707, 837, 1219, 1221, 0, 0, - 0, 0, 801, 803, 0, 805, 0, 857, 873, 0, - 874, 0, 872, 878, 867, 1276, 1319, 1328, 1329, 1324, - 1333, 1335, 0, 0, 0, 982, 1054, 1043, 1041, 1038, - 0, 1039, 1019, 0, 0, 1017, 1013, 0, 1048, 0, - 0, 1293, 0, 1134, 0, 1137, 1151, 1147, 1146, 1142, - 1109, 1142, 1514, 626, 629, 0, 182, 159, 185, 184, - 0, 1290, 192, 0, 0, 183, 0, 494, 495, 496, - 183, 0, 187, 523, 0, 0, 614, 793, 607, 608, - 0, 410, 77, 0, 389, 0, 295, 373, 372, 375, - 370, 374, 0, 432, 0, 0, 314, 0, 321, 359, - 360, 358, 315, 389, 395, 317, 0, 0, 0, 83, - 62, 59, 64, 84, 0, 0, 85, 88, 858, 100, - 93, 1372, 0, 0, 0, 78, 80, 0, 0, 1287, - 1286, 0, 529, 528, 567, 569, 525, 534, 249, 0, - 0, 0, 364, 1614, 0, 0, 0, 392, 0, 232, - 0, 0, 0, 1617, 0, 0, 292, 0, 337, 0, - 235, 1616, 202, 205, 0, 0, 0, 1603, 521, 522, - 0, 0, 1404, 1405, 0, 1077, 0, 1078, 848, 0, - 0, 696, 1142, 0, 0, 0, 737, 731, 0, 1141, - 1143, 0, 693, 1222, 797, 0, 799, 0, 823, 0, - 823, 806, 868, 860, 1326, 1336, 1337, 1332, 1132, 0, - 1040, 1044, 1042, 1021, 1289, 1289, 1297, 1294, 1136, 1150, - 1153, 746, 1357, 746, 631, 625, 0, 0, 170, 0, - 0, 167, 154, 473, 0, 497, 471, 172, 1208, 604, - 605, 0, 295, 0, 388, 411, 326, 304, 0, 0, - 0, 311, 318, 421, 320, 0, 92, 108, 0, 0, - 401, 151, 149, 1111, 545, 0, 221, 1412, 340, 1611, - 0, 0, 0, 0, 364, 242, 1613, 353, 346, 347, - 348, 349, 350, 351, 352, 367, 366, 338, 339, 210, - 0, 0, 0, 0, 505, 1406, 0, 189, 198, 0, - 189, 1079, 699, 0, 746, 0, 0, 0, 729, 0, - 0, 745, 0, 590, 1220, 0, 788, 786, 0, 787, - 1334, 0, 0, 0, 0, 660, 693, 693, 156, 0, - 157, 193, 0, 0, 0, 0, 0, 492, 395, 413, - 387, 0, 380, 324, 323, 325, 329, 0, 327, 0, - 343, 0, 336, 304, 0, 95, 0, 408, 524, 532, - 0, 294, 1605, 392, 0, 220, 1611, 340, 1617, 1611, - 0, 1608, 0, 0, 0, 0, 191, 1412, 0, 191, - 0, 693, 739, 0, 738, 1145, 1144, 695, 798, 0, - 1133, 1299, 1298, 0, 1157, 589, 588, 0, 0, 0, - 0, 472, 0, 0, 473, 421, 0, 365, 0, 0, - 326, 0, 319, 418, 419, 420, 0, 332, 322, 333, - 89, 107, 409, 0, 392, 1606, 293, 236, 1604, 1609, - 1610, 0, 189, 188, 669, 190, 853, 199, 669, 703, - 591, 740, 692, 804, 1152, 0, 0, 0, 0, 0, - 166, 853, 177, 0, 481, 0, 488, 164, 164, 489, - 490, 491, 0, 336, 386, 381, 303, 328, 342, 0, - 0, 0, 334, 0, 335, 1611, 0, 191, 672, 1402, - 672, 1949, 1667, 1914, 0, 1169, 1158, 1169, 1169, 1149, - 158, 165, 0, 485, 486, 487, 0, 0, 477, 0, - 0, 480, 0, 295, 308, 0, 307, 0, 398, 331, - 1607, 1412, 669, 179, 180, 0, 1162, 1161, 1160, 1164, - 1163, 0, 1156, 1154, 1155, 853, 484, 0, 476, 483, - 0, 479, 478, 493, 415, 306, 310, 309, 853, 672, - 0, 0, 1166, 0, 1167, 176, 474, 0, 1403, 181, - 1159, 1165, 1168, 0, 482 + 0, 0, 1573, 1572, 0, 1564, 1290, 1295, 666, 666, + 666, 0, 0, 0, 0, 664, 665, 0, 0, 0, + 0, 0, 545, 397, 409, 0, 0, 0, 1403, 222, + 0, 0, 0, 0, 0, 0, 0, 436, 1406, 1404, + 1402, 1405, 1407, 0, 0, 0, 0, 0, 214, 217, + 0, 396, 368, 0, 0, 0, 0, 1418, 0, 0, + 514, 512, 515, 504, 517, 507, 0, 1735, 386, 1415, + 0, 1569, 0, 0, 275, 473, 1383, 0, 470, 473, + 1349, 0, 473, 241, 0, 0, 1451, 1495, 251, 271, + 252, 272, 551, 1575, 1577, 0, 554, 559, 543, 0, + 543, 0, 556, 560, 543, 555, 0, 543, 550, 0, + 1137, 0, 1127, 0, 0, 848, 0, 0, 1128, 1063, + 1064, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1081, + 1080, 1129, 852, 0, 855, 0, 0, 1266, 1267, 0, + 1130, 0, 0, 1273, 0, 0, 0, 1135, 0, 790, + 0, 0, 691, 692, 700, 696, 703, 0, 706, 693, + 642, 592, 1725, 1766, 0, 653, 653, 653, 651, 641, + 0, 733, 791, 0, 781, 0, 0, 0, 814, 0, + 0, 816, 818, 0, 0, 821, 0, 797, 796, 0, + 0, 780, 0, 0, 860, 0, 1354, 0, 0, 213, + 0, 0, 0, 885, 0, 0, 0, 877, 875, 871, + 0, 967, 968, 969, 970, 971, 972, 973, 974, 975, + 976, 977, 978, 979, 891, 1391, 0, 897, 1394, 0, + 1395, 1396, 1393, 1390, 1397, 1398, 0, 0, 0, 0, + 1284, 1280, 0, 0, 0, 0, 0, 1186, 1188, 1190, + 0, 929, 928, 1195, 1201, 1204, 1208, 1209, 1210, 1205, + 1206, 1207, 1197, 1198, 1199, 1200, 1202, 1203, 0, 1223, + 0, 1177, 0, 0, 0, 0, 0, 0, 0, 0, + 1322, 1321, 0, 1345, 0, 1110, 1094, 0, 0, 1184, + 1111, 1319, 1329, 1297, 0, 0, 0, 1367, 1366, 989, + 998, 1001, 1034, 1035, 1005, 1006, 1007, 1011, 1389, 1388, + 1316, 0, 1308, 0, 0, 990, 1015, 1020, 0, 1275, + 1278, 1051, 1277, 0, 1039, 0, 1028, 0, 1037, 1041, + 1016, 1031, 0, 1012, 0, 1309, 1220, 1222, 0, 1218, + 0, 1002, 1003, 1004, 994, 995, 996, 997, 999, 1000, + 1008, 1194, 1192, 1193, 0, 1295, 0, 1307, 0, 0, + 1146, 0, 0, 1036, 1313, 0, 859, 666, 859, 0, + 987, 1557, 1386, 1550, 1386, 1539, 1230, 1351, 1385, 0, + 640, 0, 1559, 160, 164, 0, 0, 1296, 194, 196, + 774, 0, 673, 674, 678, 0, 0, 678, 657, 600, + 1986, 1864, 0, 0, 0, 0, 722, 763, 0, 754, + 719, 720, 0, 718, 1358, 723, 1357, 724, 727, 728, + 690, 1346, 764, 766, 0, 759, 0, 1352, 606, 625, + 0, 0, 0, 0, 0, 589, 588, 770, 1534, 1534, + 1536, 1535, 0, 273, 0, 52, 0, 1735, 76, 0, + 0, 0, 0, 0, 0, 295, 72, 73, 0, 401, + 0, 71, 67, 295, 118, 1735, 473, 1735, 473, 1629, + 1698, 1882, 0, 65, 373, 109, 0, 146, 79, 81, + 408, 404, 0, 354, 0, 0, 99, 114, 139, 0, + 0, 54, 244, 258, 263, 142, 267, 264, 1423, 265, + 153, 0, 50, 0, 140, 0, 1421, 0, 0, 56, + 144, 1425, 1573, 1580, 0, 0, 1294, 0, 664, 664, + 664, 662, 663, 1114, 0, 1236, 0, 1238, 1239, 1028, + 1433, 1432, 1434, 1431, 533, 544, 0, 398, 0, 548, + 536, 537, 545, 1401, 227, 0, 218, 399, 0, 0, + 399, 0, 1403, 0, 0, 222, 228, 0, 0, 0, + 0, 0, 397, 389, 387, 422, 0, 394, 388, 0, + 0, 340, 0, 1623, 0, 1703, 201, 206, 0, 0, + 0, 0, 1372, 2155, 2156, 2157, 2158, 2160, 2161, 2162, + 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2171, 2172, + 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2183, + 2184, 2185, 2186, 2187, 2188, 521, 0, 524, 870, 1373, + 0, 0, 0, 0, 0, 277, 278, 439, 1384, 441, + 0, 443, 240, 238, 1446, 1574, 1576, 547, 0, 542, + 0, 569, 0, 0, 0, 0, 0, 0, 0, 0, + 1124, 1242, 0, 1261, 1260, 1062, 1069, 1072, 1076, 1077, + 1078, 1262, 0, 0, 0, 1073, 1074, 1075, 1065, 1066, + 1067, 1068, 1070, 1071, 1079, 857, 0, 0, 851, 1271, + 1270, 1264, 1265, 0, 1132, 1133, 1134, 1272, 0, 0, + 826, 695, 697, 694, 0, 0, 859, 653, 653, 653, + 653, 650, 0, 0, 0, 858, 0, 750, 711, 712, + 0, 0, 822, 820, 0, 844, 0, 817, 0, 823, + 0, 808, 0, 815, 864, 831, 0, 0, 833, 1525, + 881, 0, 876, 872, 0, 0, 0, 882, 0, 0, + 0, 0, 0, 0, 0, 1241, 0, 659, 1108, 0, + 0, 0, 1281, 0, 1056, 898, 911, 1033, 0, 1189, + 1112, 0, 1212, 1176, 939, 938, 940, 940, 1057, 0, + 1324, 1326, 0, 0, 0, 0, 1336, 0, 1059, 0, + 1230, 1180, 1182, 1337, 1093, 923, 987, 0, 0, 0, + 0, 0, 0, 0, 1040, 1030, 0, 1038, 1042, 0, + 0, 0, 1024, 0, 0, 1022, 1052, 1018, 0, 0, + 1053, 1294, 0, 1298, 0, 0, 1145, 1154, 777, 773, + 733, 664, 733, 0, 1519, 1541, 1538, 0, 638, 0, + 0, 1560, 0, 183, 0, 0, 0, 0, 0, 186, + 200, 197, 1559, 0, 0, 668, 670, 0, 1213, 678, + 672, 726, 725, 0, 688, 761, 686, 0, 767, 0, + 623, 0, 609, 0, 800, 0, 0, 1528, 1529, 0, + 0, 0, 0, 344, 0, 0, 0, 295, 0, 411, + 0, 418, 0, 0, 401, 380, 69, 68, 98, 0, + 0, 0, 61, 117, 90, 82, 57, 96, 0, 0, + 101, 0, 94, 111, 112, 110, 115, 0, 305, 330, + 0, 0, 0, 341, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1580, 1566, 1579, + 1295, 1295, 1291, 0, 0, 0, 666, 1115, 0, 532, + 574, 571, 572, 0, 570, 249, 576, 410, 0, 0, + 0, 216, 396, 0, 0, 1418, 506, 509, 1400, 436, + 0, 227, 0, 231, 0, 0, 218, 399, 0, 372, + 382, 383, 362, 395, 366, 365, 367, 0, 1624, 242, + 0, 1618, 0, 208, 204, 399, 1417, 0, 0, 523, + 0, 526, 869, 513, 0, 518, 0, 0, 516, 0, + 1412, 276, 473, 1578, 557, 562, 0, 568, 564, 563, + 558, 566, 565, 561, 1125, 1136, 1259, 0, 0, 0, + 0, 850, 853, 0, 1131, 1126, 824, 0, 0, 733, + 0, 0, 0, 0, 644, 643, 649, 0, 0, 1148, + 0, 714, 819, 0, 0, 0, 806, 795, 801, 802, + 0, 0, 0, 862, 861, 832, 885, 0, 865, 885, + 0, 885, 883, 0, 0, 892, 980, 981, 982, 983, + 984, 985, 986, 917, 0, 1283, 1279, 1185, 1187, 1224, + 935, 933, 1058, 1327, 1320, 1323, 1229, 1331, 1333, 0, + 0, 0, 0, 1344, 0, 1179, 1345, 1365, 991, 0, + 0, 1021, 1276, 1043, 0, 0, 0, 1017, 1212, 0, + 0, 0, 0, 0, 1026, 0, 1302, 1295, 0, 1301, + 0, 0, 0, 0, 1120, 778, 750, 0, 750, 0, + 1287, 0, 634, 636, 639, 169, 1558, 0, 1553, 161, + 162, 163, 0, 0, 0, 178, 155, 0, 0, 0, + 195, 183, 171, 676, 677, 0, 671, 687, 1347, 1353, + 608, 0, 1090, 0, 0, 605, 0, 274, 147, 295, + 0, 0, 75, 0, 420, 356, 412, 393, 375, 0, + 0, 0, 296, 0, 437, 0, 0, 381, 0, 0, + 0, 0, 357, 0, 0, 316, 0, 0, 393, 0, + 400, 312, 313, 0, 60, 91, 0, 87, 0, 116, + 0, 0, 0, 0, 0, 63, 86, 0, 58, 870, + 473, 473, 66, 407, 403, 406, 355, 0, 0, 143, + 1424, 0, 141, 0, 1422, 150, 148, 145, 1426, 1565, + 0, 0, 1118, 1119, 1116, 664, 0, 0, 0, 0, + 551, 539, 0, 0, 0, 1623, 203, 0, 0, 1735, + 0, 0, 230, 229, 219, 0, 1418, 215, 396, 0, + 428, 368, 870, 423, 0, 1623, 1621, 0, 0, 209, + 0, 207, 1418, 1617, 505, 508, 522, 525, 0, 0, + 0, 0, 591, 510, 0, 0, 0, 444, 567, 1082, + 0, 0, 0, 0, 704, 0, 710, 750, 648, 647, + 646, 645, 732, 1672, 1969, 1863, 0, 736, 731, 734, + 739, 741, 740, 742, 738, 749, 0, 752, 713, 843, + 1225, 1227, 0, 0, 0, 0, 807, 809, 0, 811, + 0, 863, 879, 0, 880, 0, 878, 884, 873, 1282, + 1325, 1334, 1335, 1330, 1339, 1341, 0, 0, 0, 988, + 1060, 1049, 1047, 1044, 0, 1045, 1025, 0, 0, 1023, + 1019, 0, 1054, 0, 0, 1299, 0, 1140, 0, 1143, + 1157, 1153, 1152, 1148, 1115, 1148, 1520, 632, 635, 0, + 182, 159, 185, 184, 0, 1296, 192, 0, 0, 183, + 0, 500, 501, 502, 183, 0, 187, 529, 0, 0, + 620, 799, 613, 614, 0, 416, 77, 0, 393, 0, + 295, 377, 376, 379, 374, 378, 0, 438, 0, 0, + 314, 0, 321, 359, 360, 358, 315, 393, 399, 317, + 0, 0, 0, 83, 62, 59, 64, 84, 0, 0, + 85, 88, 864, 100, 93, 0, 78, 80, 0, 0, + 1293, 1292, 0, 535, 534, 573, 575, 531, 540, 249, + 0, 0, 0, 362, 1620, 0, 0, 0, 396, 0, + 232, 0, 0, 0, 1623, 0, 0, 0, 0, 361, + 340, 0, 337, 0, 235, 1622, 202, 205, 0, 0, + 0, 1609, 527, 528, 0, 0, 1410, 1411, 0, 1083, + 0, 1084, 854, 0, 0, 702, 1148, 0, 0, 0, + 743, 737, 0, 1147, 1149, 0, 699, 1228, 803, 0, + 805, 0, 829, 0, 829, 812, 874, 866, 1332, 1342, + 1343, 1338, 1138, 0, 1046, 1050, 1048, 1027, 1295, 1295, + 1303, 1300, 1142, 1156, 1159, 752, 1363, 752, 637, 631, + 0, 0, 170, 0, 0, 167, 154, 479, 0, 503, + 477, 172, 1214, 610, 611, 0, 295, 0, 392, 417, + 326, 304, 0, 0, 0, 311, 318, 427, 320, 0, + 92, 108, 1378, 2038, 2039, 2040, 2041, 2042, 2043, 2044, + 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, + 2055, 2056, 2057, 2175, 2058, 302, 2059, 1806, 2060, 2061, + 2062, 2063, 2064, 0, 2065, 868, 2066, 2067, 2255, 2068, + 2069, 1197, 1198, 301, 300, 405, 297, 413, 299, 0, + 1379, 298, 151, 149, 1117, 551, 0, 221, 1418, 368, + 1617, 0, 0, 0, 0, 362, 242, 1619, 353, 346, + 347, 348, 349, 350, 351, 352, 371, 370, 0, 0, + 292, 338, 339, 210, 0, 0, 0, 0, 511, 1412, + 0, 189, 198, 0, 189, 1085, 705, 0, 752, 0, + 0, 0, 735, 0, 0, 751, 0, 596, 1226, 0, + 794, 792, 0, 793, 1340, 0, 0, 0, 0, 666, + 699, 699, 156, 0, 157, 193, 0, 0, 0, 0, + 0, 498, 399, 419, 391, 0, 384, 324, 323, 325, + 329, 0, 327, 0, 343, 0, 336, 304, 0, 95, + 1378, 0, 0, 530, 538, 0, 340, 1611, 396, 0, + 220, 1617, 368, 1623, 0, 0, 1617, 0, 1614, 0, + 0, 0, 0, 191, 1418, 0, 191, 0, 699, 745, + 0, 744, 1151, 1150, 701, 804, 0, 1139, 1305, 1304, + 0, 1163, 595, 594, 0, 0, 0, 0, 478, 0, + 0, 479, 427, 0, 369, 0, 0, 326, 0, 319, + 424, 425, 426, 0, 332, 322, 333, 89, 107, 0, + 0, 0, 294, 396, 1612, 340, 236, 0, 0, 1610, + 1615, 1616, 0, 189, 188, 675, 190, 859, 199, 675, + 709, 597, 746, 698, 810, 1158, 0, 0, 0, 0, + 0, 166, 859, 177, 0, 487, 0, 494, 164, 164, + 495, 496, 497, 0, 336, 390, 385, 303, 328, 342, + 0, 0, 0, 334, 0, 335, 0, 414, 1617, 293, + 363, 364, 0, 191, 678, 1408, 678, 1955, 1673, 1920, + 0, 1175, 1164, 1175, 1175, 1155, 158, 165, 0, 491, + 492, 493, 0, 0, 483, 0, 0, 486, 0, 295, + 308, 0, 307, 0, 402, 331, 415, 1613, 1418, 675, + 179, 180, 0, 1168, 1167, 1166, 1170, 1169, 0, 1162, + 1160, 1161, 859, 490, 0, 482, 489, 0, 485, 484, + 499, 421, 306, 310, 309, 859, 678, 0, 0, 1172, + 0, 1173, 176, 480, 0, 1409, 181, 1165, 1171, 1174, + 0, 488 }; /* YYDEFGOTO[NTERM-NUM]. */ static const yytype_int16 yydefgoto[] = { - -1, 47, 48, 49, 769, 2773, 2774, 2775, 2352, 2341, - 2342, 1819, 1820, 1251, 3615, 2353, 1252, 1253, 2777, 770, + -1, 47, 48, 49, 769, 2774, 2775, 2776, 2352, 2341, + 2342, 1819, 1820, 1251, 3619, 2353, 1252, 1253, 2778, 770, 821, 1191, 870, 1129, 1666, 935, 1288, 1289, 771, 1826, - 772, 3023, 2264, 2715, 3594, 54, 3322, 2268, 1205, 3325, - 3558, 3016, 3320, 2717, 3636, 3694, 3323, 2269, 2270, 3559, - 2271, 773, 2455, 3206, 3207, 774, 775, 1918, 58, 1353, - 561, 1915, 3188, 2841, 2842, 776, 777, 1388, 1389, 990, - 778, 1919, 1858, 3143, 1271, 1848, 1403, 62, 63, 1944, - 779, 109, 931, 65, 780, 2760, 3144, 3608, 2788, 3768, - 3078, 3079, 3605, 3606, 2763, 2355, 3677, 3678, 2856, 1839, - 3672, 2442, 3545, 2361, 2335, 3080, 2450, 3504, 3196, 2356, - 3060, 2848, 2849, 2443, 3601, 1939, 2444, 3602, 3346, 2445, - 1894, 1922, 2764, 3679, 2362, 1895, 2759, 3145, 1823, 2446, - 3612, 2447, 562, 3064, 781, 759, 760, 982, 1382, 761, - 782, 3596, 3759, 3789, 3719, 3754, 3327, 3664, 3328, 3329, - 3330, 783, 1930, 1931, 1932, 1933, 1934, 1935, 966, 1936, - 2495, 2496, 784, 785, 2817, 2421, 3398, 3399, 2519, 2415, - 1412, 1897, 1413, 551, 1978, 2823, 786, 1130, 74, 75, - 1037, 76, 3340, 77, 78, 1793, 1794, 1795, 872, 882, - 883, 1746, 3009, 3010, 2709, 1498, 2049, 875, 1211, 1762, - 856, 857, 1883, 899, 1886, 1757, 1758, 2274, 2724, 1786, - 1787, 1220, 1221, 2035, 2036, 3573, 2037, 2038, 1491, 1492, - 3441, 2589, 2590, 1502, 1774, 1778, 1779, 2295, 2285, 1765, - 2586, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 1131, 2917, - 3452, 1782, 1783, 1223, 1224, 1225, 1791, 2305, 80, 81, - 2246, 2697, 2698, 827, 828, 3261, 1522, 1796, 2923, 2924, - 2925, 3264, 3265, 3266, 829, 1032, 1033, 1060, 1055, 1511, - 2061, 830, 831, 2012, 2013, 2557, 1062, 2051, 2073, 2074, - 2931, 2614, 1591, 2338, 1592, 1593, 2087, 1594, 1132, 1595, - 1623, 1133, 1628, 1597, 1134, 1135, 1136, 1600, 1137, 1138, - 1139, 1140, 1616, 1141, 1142, 1641, 2091, 2092, 2093, 2094, - 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, - 1192, 1797, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 1151, - 1152, 1153, 833, 1154, 1155, 1717, 2240, 2696, 3253, 3449, - 3450, 3002, 3308, 3480, 3585, 3708, 3745, 3746, 3782, 1156, - 1157, 1661, 1662, 1663, 2127, 2128, 2129, 2130, 2234, 1711, - 1712, 1158, 3147, 1714, 2150, 3257, 3258, 1193, 1484, 1654, - 1333, 1334, 1605, 1458, 1459, 1465, 1987, 1473, 1477, 2017, - 2018, 1485, 2201, 1159, 2120, 2121, 2632, 1618, 3011, 1160, - 1287, 1667, 2997, 2237, 1715, 2194, 1167, 1161, 1168, 1163, - 1650, 2970, 2650, 2651, 1651, 2655, 2966, 2967, 2163, 2971, - 3281, 3282, 2657, 2302, 1743, 2307, 2308, 986, 1164, 1165, - 1166, 1335, 535, 1606, 3695, 1378, 1198, 1336, 2190, 787, - 1067, 2113, 788, 1350, 1910, 789, 3433, 3222, 1367, 1940, - 2459, 563, 790, 791, 544, 87, 2410, 947, 88, 89, - 90, 908, 1405, 792, 996, 1407, 997, 91, 1408, 999, - 1000, 794, 864, 865, 1531, 1731, 1532, 795, 94, 839, - 1806, 796, 1187, 879, 1188, 1190, 797, 1208, 2712, 2262, - 97, 98, 99, 119, 1283, 2515, 1964, 1965, 1875, 798, - 850, 851, 888, 102, 103, 1236, 852, 800, 801, 3427, - 802, 2859, 1359, 545, 537, 538, 1608, 733, 1338, 734 + 772, 3025, 2264, 2716, 3598, 54, 3276, 2268, 1205, 3279, + 3562, 3018, 3274, 2718, 3643, 3705, 3277, 2269, 2270, 3563, + 2271, 773, 2456, 3160, 3161, 774, 775, 1918, 58, 1353, + 561, 1915, 3142, 2843, 2844, 776, 777, 1388, 1389, 990, + 778, 1919, 1858, 3514, 1271, 1848, 1403, 62, 63, 1944, + 779, 109, 931, 65, 780, 2761, 3515, 3612, 2789, 3784, + 3080, 3081, 3609, 3610, 2764, 2355, 3684, 3685, 2858, 1839, + 3679, 2443, 3546, 2362, 2335, 3082, 3151, 3369, 2451, 3458, + 3150, 2356, 3062, 2850, 2851, 2444, 3605, 1939, 2445, 3606, + 3300, 2446, 1894, 1922, 2765, 3686, 2363, 1895, 2760, 3516, + 1823, 2447, 3616, 2448, 562, 3066, 781, 759, 760, 982, + 1382, 761, 782, 3600, 3775, 3806, 3730, 3770, 3281, 3671, + 3282, 3283, 3284, 783, 1930, 1931, 1932, 1933, 1934, 1935, + 966, 1936, 2496, 2497, 784, 785, 2819, 2422, 3349, 3350, + 2520, 2416, 1412, 1897, 1413, 551, 1978, 2825, 786, 1130, + 74, 75, 1037, 76, 3294, 77, 78, 1793, 1794, 1795, + 872, 882, 883, 1746, 3011, 3012, 2710, 1498, 2049, 875, + 1211, 1762, 856, 857, 1883, 899, 1886, 1757, 1758, 2274, + 2725, 1786, 1787, 1220, 1221, 2035, 2036, 3577, 2037, 2038, + 1491, 1492, 3395, 2590, 2591, 1502, 1774, 1778, 1779, 2295, + 2285, 1765, 2587, 3197, 3198, 3199, 3200, 3201, 3202, 3203, + 1131, 2919, 3406, 1782, 1783, 1223, 1224, 1225, 1791, 2305, + 80, 81, 2246, 2698, 2699, 827, 828, 3215, 1522, 1796, + 2925, 2926, 2927, 3218, 3219, 3220, 829, 1032, 1033, 1060, + 1055, 1511, 2061, 830, 831, 2012, 2013, 2558, 1062, 2051, + 2073, 2074, 2933, 2615, 1591, 2338, 1592, 1593, 2087, 1594, + 1132, 1595, 1623, 1133, 1628, 1597, 1134, 1135, 1136, 1600, + 1137, 1138, 1139, 1140, 1616, 1141, 1142, 1641, 2091, 2092, + 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, + 2103, 2104, 1192, 1797, 1144, 1145, 1146, 1147, 1148, 1149, + 1150, 1151, 1152, 1153, 833, 1154, 1155, 1717, 2240, 2697, + 3207, 3403, 3404, 3004, 3262, 3434, 3589, 3719, 3761, 3762, + 3799, 1156, 1157, 1661, 1662, 1663, 2127, 2128, 2129, 2130, + 2234, 1711, 1712, 1158, 3518, 1714, 2150, 3211, 3212, 1193, + 1484, 1654, 1333, 1334, 1605, 1458, 1459, 1465, 1987, 1473, + 1477, 2017, 2018, 1485, 2201, 1159, 2120, 2121, 2633, 1618, + 3013, 1160, 1287, 1667, 2999, 2237, 1715, 2194, 1167, 1161, + 1168, 1163, 1650, 2972, 2651, 2652, 1651, 2656, 2968, 2969, + 2163, 2973, 3235, 3236, 2658, 2302, 1743, 2307, 2308, 986, + 1164, 1165, 1166, 1335, 535, 1606, 3706, 1378, 1198, 1336, + 2190, 787, 1067, 2113, 788, 1350, 1910, 789, 3387, 3176, + 1367, 1940, 2460, 563, 790, 791, 544, 87, 2411, 947, + 88, 89, 90, 908, 1405, 792, 996, 1407, 997, 91, + 1408, 999, 1000, 794, 864, 865, 1531, 1731, 1532, 795, + 94, 839, 1806, 796, 1187, 879, 1188, 1190, 797, 1208, + 2713, 2262, 97, 98, 99, 119, 1283, 2516, 1964, 1965, + 1875, 798, 850, 851, 888, 102, 103, 1236, 852, 800, + 801, 3381, 802, 2861, 1359, 545, 537, 538, 1608, 733, + 1338, 734 }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF -3295 +#define YYPACT_NINF -3343 static const int yypact[] = { - 7837, 387, 787, -3295, -3295, 708, 387, 53010, 69762, 148, - 387, 124, 3023, 55540, -3295, -3295, 49956, 3804, 387, 59582, - 76838, 461, 467, 34057, 552, 60091, -3295, -3295, -3295, 69762, - 59582, 60600, 387, 353, 70271, -3295, 387, 37113, 56049, 525, - -3295, 59582, 92, 297, 61109, 59582, 4028, 888, 445, -3295, - -3295, -3295, -3295, -3295, 323, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, 185, -3295, 134, 214, 34057, 34057, 955, - 449, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, 546, -3295, -3295, 838, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, 36603, -3295, -3295, -3295, -3295, -3295, -3295, - 70780, 61618, 59582, 62127, 56558, 62636, -3295, 827, 707, 1115, - 841, 181, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, 201, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, 634, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, 225, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, 565, -3295, 665, -3295, 226, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, 145, -3295, -3295, 1091, - 2223, 59582, 411, 519, 885, -3295, 63145, -3295, 880, -3295, - -3295, 898, 963, 1049, -3295, -3295, 57067, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, 50465, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, 1013, -3295, -3295, 829, -3295, - 270, -3295, -3295, 866, 819, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, 922, -3295, -3295, -3295, 925, 71289, - 63654, 64163, -3295, 812, 711, 987, 6452, 76856, 33037, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, 546, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, 60091, 69762, 824, 836, 1189, 840, 35075, - 844, 37623, 857, 863, 1241, 899, 914, 927, 941, 297, - 33547, 950, 565, 1472, 64672, 64672, -36, 34566, 2495, -3295, - 64672, 65181, -3295, 980, -3295, 1115, -3295, -3295, -3295, -3295, - 395, 968, -3295, 65690, 65690, 65690, 1000, 1287, 65690, -3295, - -3295, -3295, 1007, -3295, -3295, 1236, 21003, 21003, 71798, 71798, - 1115, 71798, 1031, 71798, -3295, -3295, 374, 841, -3295, 565, - -3295, -3295, 955, -3295, -3295, 56049, -3295, -3295, 292, 1375, - 21003, 59582, 1014, -3295, 1035, 1014, 1041, 1061, 1066, -3295, - 7837, 1404, 1299, 1381, 57576, 370, 370, 1537, 370, 786, - 923, 4316, 2204, -3295, 1297, -3295, 1098, -3295, 59582, 60091, - 1200, 1460, 1129, 1417, -3295, -3295, 1491, 1331, 1502, 773, - 1346, 1560, 6505, 1565, 1090, 1567, 1123, 1598, 1552, 1713, - 41, -3295, 21003, 50974, 565, -3295, 12479, 21003, -3295, -3295, - -3295, 1333, -3295, -3295, -3295, -3295, -3295, 59582, 69762, 1246, - 1237, -3295, -3295, -3295, -3295, 1709, 1497, -3295, 72307, -3295, - -3295, 1309, 66199, 66708, 67217, 67726, 68235, 1702, -3295, -3295, - 1650, -3295, -3295, -3295, 1301, -3295, -3295, -3295, 199, 72816, - 1653, 1306, 123, -3295, 1684, 245, -3295, 1686, 1536, 15129, - -3295, 1489, -3295, -3295, -3295, 297, -3295, 626, -3295, -3295, - 46910, -3295, -3295, 76856, 1419, 1350, -3295, 21003, 21003, 1356, - 5835, 64672, 65181, 21003, 59582, -3295, 21003, 26343, 1357, 21003, - 21003, 13013, 21003, 31027, 64672, 2495, 1358, -3295, 710, -3295, - 59582, 1363, -3295, 1464, 1464, 353, 34057, 1675, 33547, 1464, - 1848, 1464, -3295, 919, 1672, 1595, -3295, 34057, 1595, 1138, - 1376, 1678, 1595, -3295, 281, 1681, 1848, 38132, 1379, -3295, - 1464, 1610, -3295, -3295, 21003, 15129, 58085, 1883, -3295, -3295, - -3295, -3295, 1691, -3295, 69762, 1403, -3295, -3295, -3295, -3295, - -3295, -3295, 772, 1920, 174, 1927, 21003, 174, 174, 1407, - 228, 228, -3295, 1607, 1414, -3295, 232, 1418, 1423, 1947, - 1949, 189, 59582, 167, 1008, 174, 21003, -3295, 228, 1427, - 1953, 1431, 1960, 204, 216, -3295, 1438, 234, 21003, 21003, - 21003, 312, 21003, 11411, -3295, 50974, 1961, 59582, 263, -3295, - 565, 1441, 1115, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - 1447, -3295, 227, 7043, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, 1483, -3295, -3295, -3295, -3295, 1671, 21003, -3295, - -3295, 1448, 1675, -3295, 237, -3295, -3295, 1675, -3295, -3295, - -3295, -3295, -3295, 255, -3295, 1876, 21003, 21003, -3295, 565, - 73325, -3295, -3295, -3295, -3295, -3295, -3295, -3295, 675, -3295, - 546, 655, 48616, 1450, 1454, 1014, 59582, 59582, 1525, -3295, - -3295, -3295, -3295, 56049, 200, 1781, 56049, 182, 1611, -3295, - -3295, 955, 955, 16197, 1843, 309, 83, 16731, 21537, 1838, - 1719, 236, 913, 1841, -3295, 1723, 1955, 26343, 21003, 21003, - 786, 923, 21003, 1035, 104, -3295, -3295, 59582, -3295, 1779, - 69762, 1580, 59582, 53519, 855, 886, 1494, 1583, 54, 897, - 1930, -3295, 1493, -3295, 1586, 59582, 75855, 252, -3295, 1968, - 252, 252, 264, 1970, 1592, 290, 1765, 1302, -85, 1493, - 2981, -3295, 56049, 161, 1477, 1493, 59582, 1597, 1503, 1493, - 1552, 1115, 69762, 1514, -3295, -3295, 9937, 2016, -3295, -3295, - -3295, 194, 15129, -3295, 1128, 1203, 1492, 1507, -3295, 426, - 209, 1569, 1596, 15129, 1608, 1641, 198, 1646, 1673, 1680, - 1697, 1718, 1724, 1726, 1728, 179, 1730, 1732, 1743, 1750, - 1770, 1772, -3295, 1774, 205, 1786, 239, 1438, 15129, 1788, - -3295, 150, 48616, 32, -3295, -3295, 1801, 221, -3295, 48867, - -3295, 1815, 1605, 1621, 69762, 1557, 59582, 1662, 1202, 1897, - 1966, 1782, -3295, 1867, 59582, 1790, 2981, 1797, 1551, 2031, - 1800, 2041, 1804, 1237, 1805, 1559, -3295, 73834, 50974, -3295, - -3295, -3295, -3295, -3295, 1936, 1918, 69762, 50974, 1561, -3295, - -3295, 69762, -3295, 59582, 59582, -3295, 59582, 69762, -3295, 694, - 48616, 2081, 131, 76856, 51992, -3295, -3295, -3295, -3295, 444, - 562, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - 1115, 50974, -3295, 3327, 47487, 1571, 21003, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, 1572, 1922, - -3295, -3295, 6933, 1577, 47564, 1588, 26343, 26343, 565, 1833, - -3295, -3295, 26343, 1591, 52501, 47434, 1566, 1593, 47821, 17265, - 21003, 17265, 17265, 47958, -3295, 1599, 48010, 64672, 1581, 59582, - 30515, -3295, -3295, -3295, 21003, 21003, 2495, 58579, 1628, 1603, - -3295, 1606, 1464, -3295, 34057, -3295, 34057, -3295, 1899, 34057, - -3295, -3295, 4506, -3295, 34057, 1913, 21003, 34057, -3295, 34057, - 1846, 1859, 1619, 34057, 1464, 59582, 1620, 59582, -3295, -3295, - 48616, -3295, 1622, 727, 1623, -3295, -3295, -3295, -3295, -3295, - -3295, 1679, -3295, -3295, 1679, 1679, -3295, -3295, -3295, -3295, - 1624, 1624, 1634, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, 1639, 1008, -3295, 1679, - -3295, 1624, -3295, -3295, -3295, -3295, -3295, -3295, -3295, 75855, - -3295, -3295, -3295, -3295, 350, 645, -3295, 1640, -3295, -3295, - -3295, 1642, -3295, 1643, 2132, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, 8165, 739, 1624, -3295, -3295, 1975, - -3295, -3295, 21003, 21003, -3295, -3295, 1648, 48616, 1688, -3295, - -3295, 21003, 21003, -3295, -3295, -3295, -3295, 2168, -3295, 196, - 21003, 1679, 1679, -3295, 2991, -3295, 43732, 17799, 1744, 1751, - 2168, -3295, 2168, -3295, 21003, 2991, 2170, 2170, 1660, 38641, - -3295, 1831, 48091, -3295, 1666, 2242, 7772, 1663, -3295, -3295, - 2175, -3295, 1664, 1665, 21003, 45383, 195, 565, 565, 21003, - -3295, 2168, 21003, 6176, 6176, -3295, 210, 58085, 21003, 21003, - 21003, 21003, 21003, 21003, 21003, 21003, 49447, 1761, 223, 69762, - 21003, 21003, 30001, 1677, -3295, 21003, 1916, -3295, 1685, 21003, - 1763, 1079, 21003, 21003, 21003, 21003, 21003, 21003, 21003, 21003, - 21003, -3295, -3295, 29487, 265, 669, 2023, 2049, -31, 421, - 21003, 2042, 12479, -3295, 2042, -3295, -3295, -3295, -3295, -3295, - 238, -3295, -3295, 1622, 1622, 69762, -3295, 59582, 292, 55031, - 21003, -3295, -3295, 1683, 1690, 1988, 2179, 1754, -3295, -3295, - 59582, 1755, -3295, 42204, 2003, -3295, 351, 1692, -3295, 47416, - 1954, 2003, 955, -3295, -3295, 26877, 1828, 1998, 1934, -3295, - -3295, 1914, 1921, -3295, 1700, 48945, 22071, 22071, -3295, 1373, - 48616, 1397, -3295, -3295, -3295, -3295, -3295, -3295, 632, -3295, - 59582, 119, 39150, -3295, 1711, 133, -3295, 2038, 2058, 2024, - 1838, 913, 1716, -3295, 60091, 60091, -3295, -3295, -3295, 1889, - 69762, 1734, 1722, 74343, 59582, 2026, 1976, 2028, -43, 58085, - -3295, 1729, -3295, -3295, -3295, 59582, 69762, 68744, 74852, 51483, - 59582, 2212, 2216, 50974, -3295, -3295, 2224, 2228, -3295, -3295, - 59582, 495, 59582, 6962, -3295, -3295, -3295, -3295, 252, -3295, - -3295, -3295, -3295, -3295, 69762, 59582, -3295, -3295, 252, 69762, - 59582, 252, -3295, 1764, 59582, 59582, 69762, 59582, 1906, 59582, - 59582, 1115, 1713, -3295, 50974, -3295, -3295, 22605, 52, 52, - 1963, 1996, 2002, 1771, 13547, 150, -3295, 21003, 21003, 354, - 336, 69762, 1950, -3295, -3295, 750, 1999, 118, -3295, 69762, - 1813, 59582, 59582, 59582, 59582, 59582, 59582, 1511, -3295, -3295, - -3295, -3295, -3295, 2154, 2306, 1784, 1785, 2156, -3295, 2981, - 2163, 54028, 826, 3313, 2164, 59088, 2167, 1832, 2171, 32045, - -3295, -3295, 1794, -3295, -3295, 1796, 2283, 2050, -3295, -3295, - 2034, -3295, 69762, 2328, -3295, 123, -3295, 50974, -3295, 245, - -3295, 2043, 424, -3295, 15129, 21003, -3295, -3295, -3295, -3295, - -3295, -3295, 1350, 21003, -3295, 778, -3295, -3295, 2295, 1115, - 2295, 536, -3295, -3295, 2295, -3295, 2279, 2295, -3295, 58085, - -3295, 8363, -3295, 21003, 21003, -3295, 21003, 2166, -3295, 2334, - 2334, 58085, 26343, 26343, 26343, 26343, 26343, 26343, 813, 1427, - 26343, 26343, 26343, 26343, 26343, 26343, 26343, 26343, 26343, 27411, - 440, -3295, -3295, 780, 2305, 21003, 21003, 2182, 2166, 21003, - -3295, 58085, 1829, -3295, 1830, 1835, 21003, -3295, 58085, -3295, - 59582, 1836, -3295, -3295, -3295, 27, 1834, 1842, -3295, -3295, - 1675, -3295, 949, 1006, 59582, 1649, 2236, 3005, -3295, -3295, - 21003, 2177, -3295, -22, -3295, 4506, 4506, 34057, -3295, 21003, - 1847, -3295, -3295, 34057, 2192, -3295, 4506, -3295, -3295, 39659, - 4506, -3295, 58085, 788, -3295, 59582, 58085, 810, 21003, -3295, - 15129, 2363, 58085, 2337, 69762, 69762, 2377, 1857, 1860, 1857, - 2168, 1959, -3295, 1964, 1967, 1969, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, 58085, -3295, -3295, 327, - -3295, -3295, -3295, -3295, -3295, -3295, 1861, 1862, 21003, 21003, - 122, -3295, 8444, 1864, 1865, 21003, 48345, -3295, 1869, -3295, - 1866, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, 1878, -3295, - 1884, -3295, 1885, 1901, 1905, 1888, 1891, 8557, 21003, 59582, - -3295, 1900, 23139, 2059, 59582, -3295, -3295, 21003, 21003, 59582, - -3295, 48616, 2277, -3295, 1907, 1909, 8961, -3295, -3295, -3295, - 254, 412, 3909, 421, 4000, 4000, 4000, 2991, -3295, -3295, - -3295, 1924, -3295, 26343, 26343, -3295, 2417, 3326, 11411, -3295, - -3295, -3295, -3295, 2270, -3295, 1056, -3295, 1923, -3295, -3295, - 3371, -3295, 43732, 8191, 21003, 229, -3295, 21003, 30001, 21003, - 2009, 4000, 4000, 4000, 398, 398, 254, 254, 254, 412, - 421, -3295, -3295, -3295, 1925, 21003, 50974, -3295, 1929, 1931, - 2298, 1431, 21003, -3295, -3295, 34057, 1628, 32, 1628, 2168, - 6176, -3295, 1035, -3295, 1035, -3295, 48616, 59582, -3295, 1932, - 583, 34057, 1965, 2420, 2398, 34057, 69762, -3295, -3295, 1937, - 2042, 1956, -3295, -3295, 1957, 21003, 1758, 1957, -3295, 2003, - 34, 2176, 962, 962, 1373, 2178, -3295, -3295, 2011, -3295, - -3295, -3295, 21003, 15663, 1442, -3295, 1446, -3295, -3295, -3295, - -3295, -3295, 1944, -3295, 2219, -3295, 59582, -3295, -3295, 26343, - 2407, 21003, 40168, 2419, 2209, -3295, -3295, -3295, 2005, 2005, - -3295, -3295, 2045, -3295, 2046, 1493, 21003, 2202, -3295, 329, - 1973, 2338, 341, 2286, 69762, -3295, -3295, -3295, 316, 342, - 50974, 1729, -3295, -3295, 224, 2339, 424, 2341, 424, 50974, - 50974, 50974, 815, -3295, -3295, -3295, 1115, -3295, -3295, -3295, - 317, 816, -3295, 1974, 1977, -3295, -3295, -3295, 2056, 1725, - 1493, 2981, -3295, -3295, -3295, -3295, -3295, -3295, -3295, 190, - 1792, 1493, 2064, -3295, 2068, -3295, 2071, 1935, 1493, -3295, - -3295, 1713, 1514, 830, 18333, 48616, 208, 150, 150, 150, - -3295, -3295, -3295, 15129, -3295, 1983, 48616, 48616, 146, -3295, - -3295, -3295, -3295, 1985, -3295, 178, -3295, 69762, -3295, -3295, - -3295, 1950, 1966, 1867, 59582, 2981, 1986, 2474, 2475, 1237, - 1559, -3295, 2157, 37, 69762, -3295, 50974, 69762, 59582, 59582, - 59582, 54537, -3295, -3295, -3295, 1990, 1991, -3295, 47, 2229, - 2222, 59582, 2037, 59582, 2001, -3295, -3295, 59582, 2008, 2489, - 59582, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, 831, -3295, 58085, -3295, 1559, - 1559, 18867, 2385, 59582, 1918, -3295, -3295, -3295, -3295, 69762, - -3295, -3295, 48616, -3295, 48616, -3295, -3295, 50974, -3295, 1115, - -3295, 1115, 2255, 69762, 45892, 1115, 46401, 1115, 2012, -3295, - 48616, 9074, 48616, 2182, -3295, 260, 2334, 811, 811, 811, - 3261, 2368, 249, 2019, 811, 811, 811, 333, 333, 260, - 260, 260, 2334, 440, 980, 52501, 2021, -3295, 48616, 48616, - -3295, -3295, 2022, -3295, -3295, -3295, -3295, 2027, 2036, -3295, - -3295, -3295, -3295, 69762, 186, 1628, 525, 525, 525, 525, - -3295, 59582, 59582, 59582, 48616, 2490, 2364, -3295, -3295, 2549, - 2039, -3295, -3295, 4506, 48616, 59582, -3295, 28459, -3295, 59582, - -3295, 2397, -3295, 2486, -3295, 59582, 848, -3295, -3295, -3295, - 867, 2044, 1857, 58085, 868, 869, -3295, 152, 2168, 2047, - 1556, 1544, 938, 1443, -3295, 56049, -3295, -3295, 2048, 48422, - 21003, -3295, 2429, -3295, -3295, -3295, 48616, 21003, 21003, -3295, - 43732, -3295, -3295, -3295, -3295, -81, -81, -3295, 9493, 1900, - 2051, 2053, 59582, 11411, 48536, -3295, 40677, -3295, 73, 9629, - 48616, -3295, 1831, -3295, -3295, 6176, 21003, 3078, 5169, 21003, - 2055, 21003, 2405, -3295, -3295, 2052, -3295, -3295, 58085, 21003, - 2062, 3889, 26343, 26343, 4426, -3295, 4459, 21003, 11411, -3295, - 44397, 2566, 2066, 1963, 19401, -3295, 2289, 2060, -3295, 2177, - 150, 2177, 2069, -3295, -3295, -3295, 69762, -3295, 2345, 2072, - -3295, 21003, 2234, 69762, 557, 2266, 4506, 873, -3295, 565, - 42204, 1965, 21003, 250, -3295, -3295, 2074, -3295, 1957, -3295, - -3295, -3295, 2308, -3295, -3295, -3295, 59582, -3295, 2079, -3295, - 39150, 2426, 11945, -3295, 39150, 59582, -3295, -3295, 69762, 59582, - 9796, 2456, -3295, 69762, 69762, 69762, -3295, 69762, 2082, 2088, - 1024, 2091, 814, -3295, 2406, -3295, -3295, 1024, 2442, 279, - 2008, 290, 3000, 473, -3295, -3295, -3295, 2173, 59582, -3295, - 69762, -3295, -3295, -3295, -3295, -3295, 51483, -3295, -3295, 43222, - 50974, -3295, 50974, 21003, 21003, 59582, 59582, 59582, 59582, 69762, - 59582, 59582, 59582, 59582, 59582, 1514, -3295, -3295, 21003, 21003, - -3295, 2092, 2093, 2096, 1963, -3295, 206, -3295, 2097, -3295, - -3295, 21003, -3295, -85, -3295, -3295, 178, 2098, 2100, -3295, - 54028, 2223, 59088, 1832, -3295, 1796, 1966, 1044, 69253, 1867, - 21003, -3295, 874, 884, 2981, 2101, 2591, -3295, -3295, -3295, - 826, 54028, -3295, -3295, -3295, 2546, -3295, 812, 259, -3295, - 2593, 1406, -3295, 1237, -3295, 2223, 1559, -3295, 32539, 1821, - -3295, -3295, 2594, -3295, 2595, 2223, 48616, 69762, 2172, -3295, - 424, -3295, -3295, -3295, 69762, 2105, -3295, 2105, -3295, -3295, - 2105, -3295, -3295, -3295, -3295, 26343, 2464, 2112, 58085, -3295, - -3295, 59582, -3295, -3295, -3295, 894, 2113, 2177, 59582, 59582, - 59582, 59582, -3295, -3295, -3295, 19935, 21003, 2152, 21003, -3295, - -3295, 2114, 14081, 2443, -3295, 27945, -3295, -3295, 2116, 39659, - 69762, -3295, -3295, -3295, -3295, 2168, -3295, -3295, 69762, -3295, - -3295, 2125, 2126, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - -3295, -3295, 21003, 48616, -3295, 48616, -3295, -3295, -3295, -3295, - -3295, 59582, -3295, -3295, 7617, -3295, 2124, 2129, 69762, 59582, - 128, -3295, 21003, -3295, 2059, -3295, 452, 21003, 21003, 2417, - -3295, 10249, 21003, 58085, 902, 2417, 293, 21003, 5189, 5219, - 21003, 21003, 5372, 9902, -3295, 23673, 14595, -3295, 2136, 21003, - 10043, 42713, -3295, 34057, 2364, 2138, 2364, 1115, -3295, 2139, - 2137, -3295, -3295, 1975, 48616, 21003, -3295, -3295, -3295, -3295, - 2188, -5, 36093, 2378, -3295, 2191, 2161, 69762, -3295, 2234, - 48616, -3295, -3295, 43732, -3295, -3295, -3295, -3295, -3295, 2614, - 1917, 2150, 2159, -3295, 1370, -3295, -3295, -3295, 69762, 2160, - -3295, 2180, 1024, -3295, 69762, 2193, -3295, 269, 2483, 157, - -3295, 21003, -3295, 2577, 2658, 2406, 2174, 69762, 59582, 26343, - -3295, 285, 272, -3295, 2471, 59582, 2193, 2616, -3295, -3295, - -3295, 814, -3295, 2513, 2423, -3295, 252, -3295, 21003, 814, - 2425, 153, 69762, -3295, -3295, 2770, -3295, 58085, 424, 424, - -3295, 1623, 2181, 2186, 2187, 2190, 2194, 2197, 2199, 2201, - 2206, 2208, 2210, 2213, 2214, 2215, 2217, 2220, 2225, 2227, - 2230, 2240, 1639, 2243, -3295, 2244, 2074, 2245, 2246, 2247, - 2248, 2251, 75361, 2254, 2258, 2259, 2260, 1640, 2263, 2267, - 444, 562, -3295, -3295, -3295, -3295, -3295, -3295, 1306, 2268, - -3295, 2195, -3295, 2189, 904, -3295, -3295, 2281, -3295, 2292, - -3295, -3295, -3295, -3295, -3295, -3295, 2207, 2231, -3295, -3295, - -3295, 150, 2235, 2271, 69762, 10346, 1350, 121, 50974, 69762, - 2274, 2037, -3295, 2701, 771, 2466, 2221, 2278, -3295, 48616, - -3295, 50974, 1832, -3295, 54028, 3636, 664, 2222, 58085, -3295, - 737, 2037, -3295, 2644, 59088, -3295, 2276, 2264, 1832, 2309, - -3295, 1796, -3295, -3295, 21003, 21003, 2380, 21003, 160, -3295, - 2514, 69762, 2284, -3295, 2105, 4604, 26343, 58085, 952, 960, - -3295, 2804, 2455, 2364, -3295, -3295, -3295, -3295, -3295, 2290, - 439, 2291, 10877, 2294, -3295, -3295, -3295, -3295, -3295, -3295, - 48616, 48616, 69762, 2479, 48616, -3295, -3295, 2296, 2293, 41186, - 2767, 2300, -3295, -3295, 2629, -3295, 31536, -3295, 1857, 2310, - 1857, 58085, 1857, -3295, -3295, 48616, 1900, 21003, -3295, -3295, - -3295, 2304, 2303, 69762, 44667, 2645, -3295, 2417, 2417, 10249, - 961, -3295, 2417, 21003, 21003, 2417, 2417, 21003, -3295, 20469, - 231, -3295, 969, -3295, 44249, -3295, 76349, -3295, -3295, 2152, - 1115, 2152, -3295, -3295, 69762, 2311, 2313, -3295, -3295, -3295, - 2366, -3295, -3295, 990, 2759, 2234, 191, -3295, -3295, 2191, - 2234, 21003, -3295, -3295, 2323, 39150, -3295, -3295, -3295, -3295, - 39150, 1024, -3295, 2501, 2193, 2330, -3295, -3295, -3295, -3295, - -3295, -3295, 44267, -3295, 79, 21003, -3295, 1001, 3261, -3295, - -3295, -3295, -3295, 2193, 1237, -3295, 59582, 2823, 2712, -3295, - -3295, 48616, -3295, -3295, 2168, 2168, -3295, -3295, 2486, -3295, - -3295, 2340, 1306, 401, 43222, -3295, -3295, 59582, 59582, -3295, - -3295, 2342, -3295, -3295, -3295, -3295, -3295, -3295, -85, 2742, - 996, 1015, 826, -3295, 2223, 59582, 2721, 54028, 50974, -3295, - 2835, 2353, 59582, 2037, 1178, 1178, -3295, 2510, -3295, 2517, - -3295, -3295, -3295, -3295, 1115, 2848, 301, -3295, 48616, 48616, - 1414, 59582, -3295, -3295, 35584, 4604, 1023, -3295, -3295, 2367, - 2371, -3295, 2152, 21003, 2372, 21003, -3295, 24207, 2860, 2373, - -3295, 21003, 2436, 28973, -3295, 21003, -3295, 59582, 64672, 2376, - 64672, -3295, -3295, -3295, -3295, 59582, -3295, -3295, -3295, 21003, - -3295, 2417, 2417, 2417, 21003, 21003, -3295, -3295, -3295, -3295, - 2592, 2479, -3295, 2479, -3295, -3295, 21003, 2223, 565, 3646, - 69762, 12, -3295, 2869, 2657, -3295, -3295, 48616, -3295, -3295, - -3295, 59582, -3295, 50974, -3295, 1024, 8, 2384, 21003, 44302, - 2628, -3295, -3295, 2662, -3295, 2723, -3295, 2450, 630, 2468, - -3295, -3295, -3295, -3295, 1350, 1115, -3295, 1832, 2222, 2309, - 2392, 59582, 1029, 2223, 826, 812, -3295, -3295, -3295, -3295, - -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, -3295, - 2223, 2846, 2624, 2850, -3295, 2172, 21003, 110, -3295, 1033, - 2842, -3295, -3295, 2915, 2479, 2399, 24207, 2401, -3295, 2403, - 69762, 48616, 2555, -3295, -3295, 2413, -3295, -3295, 21003, -3295, - -3295, 44878, 2408, 2416, 2874, 1963, 2436, 2436, -3295, -5, - -3295, -3295, 2852, 35584, 2810, 21003, 2511, 2889, 1237, 1024, - 2433, 1045, -3295, -3295, -3295, -3295, -3295, 2981, -3295, 44320, - 2673, 601, 2659, 2384, 21003, -3295, 2502, -3295, -3295, -3295, - 2914, -3295, -3295, 54028, 2428, -3295, 2309, 2222, 2037, 2309, - 2660, -3295, 2668, 2439, 44355, 69762, 69762, 1832, 35584, 69762, - 2448, 2436, -3295, 2449, -3295, -3295, -3295, 30515, -3295, 2457, - -3295, -3295, -3295, 21003, 169, -3295, -3295, 2496, 59582, 1075, - 82, 48616, 276, 434, 2869, 2662, 43222, -3295, 50974, 1028, - 8, 2765, -3295, -3295, -3295, -3295, 241, 2690, -3295, 2692, - -3295, 48616, -3295, 2223, 54028, -3295, -3295, -3295, -3295, -3295, - -3295, 35584, 2842, -3295, 351, -3295, 1628, -3295, 351, -3295, - -3295, -3295, -3295, -3295, 1566, 24741, 24741, 24741, 2461, 2223, - -3295, 1628, -3295, 2596, -3295, 2713, 21003, 129, 246, -3295, - -3295, -3295, 2557, 2659, -3295, -3295, -3295, -3295, -3295, 533, - 533, 2872, -3295, 2533, -3295, 2309, 1103, 69762, 1957, -3295, - 1957, 25809, 2626, 211, 47469, 2853, -3295, 2853, 2853, -3295, - -3295, -3295, 42204, -3295, -3295, 48616, 2525, 69762, 2488, 2531, - 41695, -3295, 276, -3295, -3295, 2984, -3295, 268, -3295, -3295, - -3295, 1832, 351, -3295, -3295, 2977, -3295, -3295, -3295, -3295, - -3295, 951, -3295, -3295, -3295, 1628, -3295, 1110, -3295, -3295, - 2491, -3295, -3295, -3295, 1024, -3295, -3295, -3295, 1628, 1957, - 25275, 2647, -3295, 2715, -3295, -3295, -3295, 21003, -3295, -3295, - -3295, -3295, -3295, 2498, -3295 + 7366, 651, 750, -3343, -3343, 195, 651, 53409, 70161, 95, + 651, 98, 2090, 55939, -3343, -3343, 50355, 6484, 651, 59981, + 77237, 361, 490, 33375, 540, 60490, -3343, -3343, -3343, 70161, + 59981, 60999, 651, 785, 70670, -3343, 651, 36431, 56448, 351, + -3343, 59981, 9, 294, 61508, 59981, 119, 885, 320, -3343, + -3343, -3343, -3343, -3343, 244, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, 181, -3343, 725, 182, 33375, 33375, 1988, + 389, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, 473, -3343, -3343, 745, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, 35921, -3343, -3343, -3343, -3343, -3343, -3343, + 71179, 62017, 59981, 62526, 56957, 63035, -3343, 724, 720, 1156, + 824, 186, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, 197, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, 658, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, 202, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, 815, -3343, 686, -3343, 225, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, 1067, -3343, -3343, 1117, + 2837, 59981, 942, 969, 871, -3343, 63544, -3343, 875, -3343, + -3343, 909, 1578, 1095, -3343, -3343, 57466, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, 50864, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, 1083, -3343, -3343, 912, -3343, + 278, -3343, -3343, 958, 922, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, 1006, -3343, -3343, -3343, 1021, 71688, + 64053, 64562, -3343, 883, 74, 2109, 7381, 77255, 32355, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, 473, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, 60490, 70161, 887, 891, 1274, 895, 34393, + 921, 36941, 934, 941, 1310, 968, 975, 980, 999, 294, + 32865, 1028, 815, 1543, 65071, 65071, -28, 33884, 3514, -3343, + 65071, 65580, -3343, 1053, -3343, 1156, -3343, -3343, -3343, -3343, + -55, 1045, -3343, 66089, 66089, 66089, 1069, 1356, 66089, -3343, + -3343, -3343, 1062, -3343, -3343, 1317, 20321, 20321, 72197, 72197, + 1156, 72197, 1107, 72197, -3343, -3343, 53, 824, -3343, 815, + -3343, -3343, 1988, -3343, -3343, 56448, -3343, -3343, 312, 1458, + 20321, 59981, 1104, -3343, 1113, 1104, 1118, 1123, 1131, -3343, + 7366, 1495, 1409, 1492, 57975, 944, 944, 1656, 944, 654, + 925, 1063, 3988, -3343, 648, -3343, 1190, -3343, 59981, 60490, + 1301, 1562, 1229, 1529, -3343, -3343, 1613, 1404, 1622, 1081, + 1431, 1638, 2156, 1640, 1127, 1665, 1212, 1677, 1693, 1780, + 69, -3343, 20321, 51373, 815, -3343, 11797, 20321, -3343, -3343, + -3343, 1397, -3343, -3343, -3343, -3343, -3343, 59981, 70161, 1304, + 1307, -3343, -3343, -3343, -3343, 2377, 1557, -3343, 72706, -3343, + -3343, 1361, 66598, 67107, 67616, 68125, 68634, 1753, -3343, -3343, + 1695, -3343, -3343, -3343, 1357, -3343, -3343, -3343, 273, 73215, + 1702, 1331, 92, -3343, 1712, 102, -3343, 1717, 1579, 14447, + -3343, 1515, -3343, -3343, -3343, 294, -3343, 571, -3343, -3343, + 46672, -3343, -3343, 77255, 1443, 1359, -3343, 20321, 20321, 1367, + 6946, 65071, 65580, 20321, 59981, -3343, 20321, 25661, 1374, 20321, + 20321, 12331, 20321, 30345, 65071, 3514, 1360, -3343, 825, -3343, + 59981, 1380, -3343, 1496, 1496, 785, 33375, 1699, 32865, 1496, + 1870, 1496, -3343, 989, 1703, 1630, -3343, 33375, 1630, 1048, + 1414, 1735, 1630, -3343, 653, 1738, 1870, 37450, 1439, -3343, + 1496, 1669, -3343, -3343, 20321, 14447, 58484, 1928, -3343, -3343, + -3343, -3343, 1734, -3343, 70161, 1447, -3343, -3343, -3343, -3343, + -3343, -3343, 910, 1973, 227, 2006, 20321, 227, 227, 1485, + 228, 228, -3343, 1697, 1506, -3343, 229, 1509, 1513, 2019, + 2041, 168, 59981, 166, 362, 227, 20321, -3343, 228, 1520, + 2046, 1525, 2050, 223, 240, -3343, 1536, 230, 20321, 20321, + 20321, 333, 20321, 10729, -3343, 51373, 2048, 59981, 217, -3343, + 815, 1542, 1156, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + 1544, -3343, 220, 6752, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, 1583, -3343, -3343, -3343, -3343, 1771, 20321, -3343, + -3343, 1548, 1699, -3343, 234, -3343, -3343, 1699, -3343, -3343, + -3343, -3343, -3343, 261, -3343, 1978, 20321, 20321, -3343, 815, + 73724, -3343, -3343, -3343, -3343, -3343, -3343, -3343, 780, -3343, + 473, 839, 48378, 1553, 1559, 1104, 59981, 59981, 1637, -3343, + -3343, -3343, -3343, 56448, 158, 1875, 56448, 167, 1711, -3343, + -3343, 1988, 1988, 15515, 769, 215, 926, 16049, 20855, 1946, + 1837, 250, 964, 1961, -3343, 1843, 2071, 25661, 20321, 20321, + 654, 925, 20321, 1113, 254, -3343, -3343, 59981, -3343, 1893, + 70161, 1694, 59981, 53918, 1079, 1208, 1607, 1696, 1, 1033, + 2043, -3343, 1612, -3343, 1701, 59981, 76254, 269, -3343, 2083, + 269, 269, 719, 2085, 1713, 280, 1885, 1098, -53, 1612, + 3591, -3343, 56448, 300, 1345, 1612, 59981, 1714, 1463, 1612, + 1693, 1156, 70161, 1631, -3343, -3343, 44334, 2139, -3343, -3343, + -3343, 192, 14447, -3343, 1320, 1441, 1574, 1582, -3343, 955, + 175, 1667, 1680, 14447, 1691, 1709, 196, 1721, 1732, 1761, + 1816, 1826, 1832, 1834, 1841, 190, 1846, 1872, 1879, 1898, + 1900, 1920, -3343, 1931, 206, 1937, 239, 1536, 14447, 1941, + -3343, 157, 48378, -10, -3343, -3343, 1944, 210, -3343, 48629, + -3343, 1942, 1725, 1728, 70161, 1682, 59981, 1784, 1689, 2020, + 2072, 1895, -3343, 1980, 59981, 1899, 3591, 1904, 1662, 2144, + 1912, 2153, 1916, 1307, 1921, 1675, -3343, 74233, 51373, -3343, + -3343, -3343, -3343, -3343, 2059, 2030, 70161, 51373, 1685, -3343, + -3343, 70161, -3343, 59981, 59981, -3343, 59981, 70161, -3343, 791, + 48378, 2203, 1365, 77255, 52391, -3343, -3343, -3343, -3343, 462, + 1254, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + 1156, 51373, -3343, 3341, 47249, 1690, 20321, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, 1704, 2044, + -3343, -3343, 6422, 1707, 47326, 1708, 25661, 25661, 815, 2851, + -3343, -3343, 25661, 1710, 52900, 47196, 1688, 1718, 47583, 16583, + 20321, 16583, 16583, 47720, -3343, 1719, 47772, 65071, 1698, 59981, + 29833, -3343, -3343, -3343, 20321, 20321, 3514, 58978, 1736, 1720, + -3343, 1722, 1496, -3343, 33375, -3343, 33375, -3343, 1994, 33375, + -3343, -3343, 3010, -3343, 33375, 1997, 20321, 33375, -3343, 33375, + 1938, 1943, 1723, 33375, 1496, 59981, 1729, 59981, -3343, -3343, + 48378, -3343, 1700, 866, 1716, -3343, -3343, -3343, -3343, -3343, + -3343, 1754, -3343, -3343, 1754, 1754, -3343, -3343, -3343, -3343, + 1731, 1731, 1739, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, 1743, 362, -3343, 1754, + -3343, 1731, -3343, -3343, -3343, -3343, -3343, -3343, -3343, 76254, + -3343, -3343, -3343, -3343, 726, 736, -3343, 1745, -3343, -3343, + -3343, 1746, -3343, 1726, 2200, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, 7064, 868, 1731, -3343, -3343, 1779, + -3343, -3343, 20321, 20321, -3343, -3343, 1748, 48378, 1756, -3343, + -3343, 20321, 20321, -3343, -3343, -3343, -3343, 2251, -3343, 156, + 20321, 1754, 1754, -3343, 48835, -3343, 43050, 17117, 1824, 1828, + 2251, -3343, 2251, -3343, 20321, 48835, 2266, 2266, 1751, 37959, + -3343, 1919, 47853, -3343, 1757, 1797, 8264, 1749, -3343, -3343, + 2264, -3343, 1755, 1762, 20321, 45145, 171, 815, 815, 20321, + -3343, 2251, 20321, 7993, 7993, -3343, 211, 58484, 20321, 20321, + 20321, 20321, 20321, 20321, 20321, 20321, 49337, 1853, 205, 70161, + 20321, 20321, 29319, 977, -3343, 20321, 2013, -3343, 1772, 20321, + 1861, 1143, 20321, 20321, 20321, 20321, 20321, 20321, 20321, 20321, + 20321, -3343, -3343, 28805, 249, 851, 2120, 2141, -13, 311, + 20321, 2134, 11797, -3343, 2134, -3343, -3343, -3343, -3343, -3343, + 235, -3343, -3343, 1700, 1700, 70161, -3343, 59981, 312, 55430, + 20321, -3343, -3343, 1781, 1787, 2089, 2279, 1857, -3343, -3343, + 59981, 1862, -3343, 41522, 2102, -3343, 330, 1796, -3343, 47178, + 2060, 2102, 1988, -3343, -3343, 26195, 1939, 2106, 2040, -3343, + -3343, 2021, 2022, -3343, 1806, 48707, 21389, 21389, -3343, 1585, + 48378, 1608, -3343, -3343, -3343, -3343, -3343, -3343, 855, -3343, + 59981, 139, 38468, -3343, 1807, 140, -3343, 5721, 2162, 2125, + 1946, 964, 1819, -3343, 60490, 60490, -3343, -3343, -3343, 1990, + 70161, 1418, 1823, 74742, 59981, 2123, 2092, 2140, 391, 58484, + -3343, 1840, -3343, -3343, -3343, 59981, 70161, 69143, 75251, 51882, + 59981, 2311, 2313, 49846, -3343, -3343, 2314, 2315, -3343, -3343, + 59981, 1261, 59981, 7552, -3343, -3343, -3343, -3343, 269, -3343, + -3343, -3343, -3343, -3343, 70161, 59981, -3343, -3343, 269, 70161, + 59981, 269, -3343, 1473, 59981, 59981, 70161, 59981, 1611, 59981, + 59981, 1156, 1780, -3343, 51373, -3343, -3343, 21923, 37, 37, + 2076, 2094, 2095, 1849, 12865, 157, -3343, 20321, 20321, 363, + 270, 70161, 2039, -3343, -3343, 888, 2098, 336, -3343, 70161, + 1905, 59981, 59981, 59981, 59981, 59981, 59981, 1692, -3343, -3343, + -3343, -3343, -3343, 2230, 2384, 1864, 1865, 2240, -3343, 3591, + 2241, 54427, 971, 2091, 2254, 59487, 2262, 1930, 2265, 31363, + -3343, -3343, 1889, -3343, -3343, 1891, 2385, 2145, -3343, -3343, + 2137, -3343, 70161, 2435, -3343, 92, -3343, 51373, -3343, 102, + -3343, 2146, 222, -3343, 14447, 20321, -3343, -3343, -3343, -3343, + -3343, -3343, 1359, 20321, -3343, 898, -3343, -3343, 2402, 1156, + 2402, 572, -3343, -3343, 2402, -3343, 2387, 2402, -3343, 58484, + -3343, 8571, -3343, 20321, 20321, -3343, 20321, 2270, -3343, 2434, + 2434, 58484, 25661, 25661, 25661, 25661, 25661, 25661, 668, 1520, + 25661, 25661, 25661, 25661, 25661, 25661, 25661, 25661, 25661, 26729, + 318, -3343, -3343, 902, 2407, 20321, 20321, 2283, 2270, 20321, + -3343, 58484, 1924, -3343, 1925, 1927, 20321, -3343, 58484, -3343, + 59981, 1934, -3343, -3343, -3343, 38, 1932, 1936, -3343, -3343, + 1699, -3343, 1051, 1057, 59981, 2590, 4012, 4979, -3343, -3343, + 20321, 2275, -3343, -1, -3343, 3010, 3010, 33375, -3343, 20321, + 1940, -3343, -3343, 33375, 2296, -3343, 3010, -3343, -3343, 38977, + 3010, -3343, 58484, 918, -3343, 59981, 58484, 924, 20321, -3343, + 14447, 2464, 58484, 2430, 70161, 70161, 2468, 1947, 1949, 1947, + 2251, 2037, -3343, 2042, 2045, 2049, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, 58484, -3343, -3343, 103, + -3343, -3343, -3343, -3343, -3343, -3343, 1951, 1954, 20321, 20321, + 160, -3343, 8932, 1955, 1957, 20321, 48107, -3343, 1958, -3343, + 1956, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, 1953, -3343, + 1971, -3343, 1974, 1993, 1995, 1976, 1979, 9129, 20321, 59981, + -3343, 1983, 22457, 2150, 59981, -3343, -3343, 20321, 20321, 59981, + -3343, 48378, 2360, -3343, 1985, 1991, 9262, -3343, -3343, -3343, + 247, 371, 48726, 311, 4046, 4046, 4046, 48835, -3343, -3343, + -3343, 2014, -3343, 25661, 25661, -3343, 5015, 3279, 10729, -3343, + -3343, -3343, -3343, 2343, -3343, 1263, -3343, 1999, -3343, -3343, + 3307, -3343, 43050, 6787, 20321, 214, -3343, 20321, 29319, 20321, + 2088, 4046, 4046, 4046, 355, 355, 247, 247, 247, 371, + 311, -3343, -3343, -3343, 2001, 20321, 51373, -3343, 2002, 2007, + 2381, 1525, 20321, -3343, -3343, 33375, 1736, -10, 1736, 2251, + 7993, -3343, 1113, -3343, 1113, -3343, 48378, 59981, -3343, 2016, + 822, 33375, 2055, 2504, 2488, 33375, 70161, -3343, -3343, 2023, + 2134, 2051, -3343, -3343, 2047, 20321, 2678, 2047, -3343, 2102, + 16, 2263, 1273, 1273, 1585, 2267, -3343, -3343, 2097, -3343, + -3343, -3343, 20321, 14981, 1657, -3343, 1670, -3343, -3343, -3343, + -3343, -3343, 2026, -3343, 2318, -3343, 59981, -3343, -3343, 25661, + 2502, 20321, 39486, 2510, 2300, -3343, -3343, -3343, 2093, 2093, + -3343, -3343, 2135, -3343, 2136, 1612, 20321, 2294, -3343, 125, + 2052, 2423, 448, 2373, 70161, -3343, -3343, -3343, 381, 666, + 51373, 1840, -3343, -3343, 967, 2428, 222, 2431, 222, 51373, + 51373, 51373, 939, -3343, -3343, -3343, 1156, -3343, -3343, -3343, + 2067, 628, 949, -3343, 2058, 2061, -3343, -3343, -3343, 2147, + 1636, 1612, 3591, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + 337, 1648, 1612, 2152, -3343, 2154, -3343, 2155, 1855, 1612, + -3343, -3343, 1780, 1631, 950, 17651, 48378, 219, 157, 157, + 157, -3343, -3343, -3343, 14447, -3343, 2064, 48378, 48378, 148, + -3343, -3343, -3343, -3343, 2068, -3343, 189, -3343, 70161, -3343, + -3343, -3343, 2039, 2072, 1980, 59981, 3591, 2074, 2547, 2562, + 1307, 1675, -3343, 2245, 474, 70161, -3343, 51373, 70161, 59981, + 59981, 59981, 54936, -3343, -3343, -3343, 2079, 2077, -3343, 15, + 2317, 2316, 59981, 2122, 59981, 2105, -3343, -3343, 59981, 2107, + 2576, 59981, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, 966, -3343, 58484, -3343, + 1675, 1675, 18185, 2466, 59981, 2030, -3343, -3343, -3343, -3343, + 70161, -3343, -3343, 48378, -3343, 48378, -3343, -3343, 51373, -3343, + 1156, -3343, 1156, 2340, 70161, 45654, 1156, 46163, 1156, 2101, + -3343, 48378, 9340, 48378, 2283, -3343, 274, 2434, 2607, 2607, + 2607, 1842, 2460, 207, 2108, 2607, 2607, 2607, 369, 369, + 274, 274, 274, 2434, 318, 1053, 52900, 2110, -3343, 48378, + 48378, -3343, -3343, 2111, -3343, -3343, -3343, -3343, 2114, 2115, + -3343, -3343, -3343, -3343, 70161, 208, 1736, 351, 351, 351, + 351, -3343, 59981, 59981, 59981, 48378, 2577, 2451, -3343, -3343, + 2631, 2117, -3343, -3343, 3010, 48378, 59981, -3343, 27777, -3343, + 59981, -3343, 2480, -3343, 2569, -3343, 59981, 1000, -3343, -3343, + -3343, 1010, 2127, 1947, 58484, 1036, 1049, -3343, 159, 2251, + 2128, 1791, 1250, 983, 1678, -3343, 56448, -3343, -3343, 2129, + 48184, 20321, -3343, 2507, -3343, -3343, -3343, 48378, 20321, 20321, + -3343, 43050, -3343, -3343, -3343, -3343, 452, 452, -3343, 9649, + 1983, 2130, 2138, 59981, 10729, 48298, -3343, 39995, -3343, 43, + 43567, 48378, -3343, 1919, -3343, -3343, 7993, 20321, 1883, 5617, + 20321, 2142, 20321, 2485, -3343, -3343, 2151, -3343, -3343, 58484, + 20321, 2158, 3843, 25661, 25661, 4784, -3343, 5082, 20321, 10729, + -3343, 44388, 2647, 2157, 2076, 18719, -3343, 2364, 2164, -3343, + 2275, 157, 2275, 2172, -3343, -3343, -3343, 70161, -3343, 2426, + 2175, -3343, 20321, 2337, 70161, 604, 2333, 3010, 1093, -3343, + 815, 41522, 2055, 20321, 246, -3343, -3343, 2178, -3343, 2047, + -3343, -3343, -3343, 2388, -3343, -3343, -3343, 59981, -3343, 2179, + -3343, 38468, 2500, 11263, -3343, 38468, 59981, -3343, -3343, 70161, + 59981, 43585, 2553, -3343, 70161, 70161, 70161, -3343, 70161, 2177, + 2181, 869, 2183, 1086, -3343, 1929, -3343, -3343, 869, 2534, + 293, 2107, 280, 5893, 84, -3343, -3343, -3343, 2268, 59981, + -3343, 70161, -3343, -3343, -3343, -3343, -3343, 51882, -3343, -3343, + 20321, 20321, 51373, -3343, 49846, 20321, 20321, 59981, 59981, 59981, + 59981, 70161, 59981, 59981, 59981, 59981, 59981, 1631, -3343, -3343, + 20321, 20321, -3343, 2184, 2186, 2188, 2076, -3343, 412, -3343, + 2190, -3343, -3343, 20321, -3343, -53, -3343, -3343, 189, 2194, + 2195, -3343, 54427, 2837, 59487, 1930, -3343, 1891, 2072, 748, + 69652, 1980, 20321, -3343, 1119, 1157, 3591, 2197, 2677, -3343, + -3343, -3343, -3343, 54427, -3343, -3343, -3343, 2639, -3343, 883, + 287, -3343, 2686, 814, -3343, 1307, -3343, 2837, 1675, -3343, + 31857, 2054, -3343, -3343, 2687, -3343, 2689, 2837, 48378, 70161, + 2273, -3343, 222, -3343, -3343, -3343, 70161, 2199, -3343, 2199, + -3343, -3343, 2199, -3343, -3343, -3343, -3343, 25661, 2558, 2205, + 58484, -3343, -3343, 59981, -3343, -3343, -3343, 1158, 2206, 2275, + 59981, 59981, 59981, 59981, -3343, -3343, -3343, 19253, 20321, 2248, + 20321, -3343, -3343, 2209, 13399, 2540, -3343, 27263, -3343, -3343, + 2213, 38977, 70161, -3343, -3343, -3343, -3343, 2251, -3343, -3343, + 70161, -3343, -3343, 2216, 2218, -3343, -3343, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, 20321, 48378, -3343, 48378, -3343, -3343, + -3343, -3343, -3343, 59981, -3343, -3343, 7913, -3343, 2215, 2219, + 70161, 59981, 112, -3343, 20321, -3343, 2150, -3343, 388, 20321, + 20321, 5015, -3343, 7832, 20321, 58484, 1233, 5015, 323, 20321, + 5852, 5882, 20321, 20321, 5283, 43620, -3343, 22991, 13913, -3343, + 2220, 20321, 43638, 42031, -3343, 33375, 2451, 2222, 2451, 1156, + -3343, 2223, 2221, -3343, -3343, 1779, 48378, 20321, -3343, -3343, + -3343, -3343, 2282, 401, 35411, 2463, -3343, 2280, 2250, 70161, + -3343, 2337, 48378, -3343, -3343, 43050, -3343, -3343, -3343, -3343, + -3343, 2705, 2148, 2239, 2246, -3343, 1604, -3343, -3343, -3343, + 70161, 2247, -3343, 2253, 869, -3343, 70161, 2289, -3343, 284, + 2563, 161, -3343, 20321, -3343, 2668, 2749, 1929, 2272, 70161, + 59981, 25661, -3343, 687, 199, -3343, 2564, 59981, 2289, 2702, + -3343, -3343, -3343, 1086, -3343, 2600, 2511, -3343, 269, -3343, + 20321, 1086, 2513, 138, 70161, -3343, -3343, 2491, -3343, 58484, + 222, 222, -3343, 48378, 48378, 2285, -3343, 2278, 1239, -3343, + -3343, 2368, -3343, 2372, -3343, -3343, -3343, -3343, -3343, -3343, + 2286, 2287, -3343, -3343, -3343, 157, 2288, 2290, 70161, 43673, + 1359, 124, 51373, 70161, 2291, 2122, -3343, 2774, 729, 2538, + 2293, 2297, -3343, 48378, -3343, 51373, 1930, -3343, 54427, 3433, + 781, 862, 58484, -3343, 193, 2122, -3343, 2716, 59487, -3343, + 2301, 2302, 1930, 2336, -3343, 1891, -3343, -3343, 20321, 20321, + 2405, 20321, 150, -3343, 2543, 70161, 2305, -3343, 2199, 6031, + 25661, 58484, 1251, 1253, -3343, 2820, 2482, 2451, -3343, -3343, + -3343, -3343, -3343, 2321, 407, 2322, 10195, 2323, -3343, -3343, + -3343, -3343, -3343, -3343, 48378, 48378, 70161, 2501, 48378, -3343, + -3343, 2325, 2324, 40504, 2785, 2329, -3343, -3343, 2645, -3343, + 30854, -3343, 1947, 2327, 1947, 58484, 1947, -3343, -3343, 48378, + 1983, 20321, -3343, -3343, -3343, 2328, 2335, 70161, 44589, 2674, + -3343, 5015, 5015, 7832, 1255, -3343, 5015, 20321, 20321, 5015, + 5015, 20321, -3343, 19787, 242, -3343, 1257, -3343, 43715, -3343, + 76748, -3343, -3343, 2248, 1156, 2248, -3343, -3343, 70161, 2347, + 2346, -3343, -3343, -3343, 2397, -3343, -3343, 1259, 2787, 2337, + 685, -3343, -3343, 2280, 2337, 20321, -3343, -3343, 2351, 38468, + -3343, -3343, -3343, -3343, 38468, 869, -3343, 2531, 2289, 2358, + -3343, -3343, -3343, -3343, -3343, -3343, 43985, -3343, 83, 20321, + -3343, 1013, 1842, -3343, -3343, -3343, -3343, 2289, 1307, -3343, + 59981, 2846, 2734, -3343, -3343, 48378, -3343, -3343, 2251, 2251, + -3343, -3343, 2569, -3343, -3343, 42540, -3343, -3343, 59981, 59981, + -3343, -3343, 2363, -3343, -3343, -3343, -3343, -3343, -3343, -53, + 2769, 1264, 1266, -3343, -3343, 2837, 59981, 2741, 54427, 51373, + -3343, 2855, 2369, 59981, 2122, 379, 379, 2839, 2840, -3343, + 2316, 2522, -3343, 2526, -3343, -3343, -3343, -3343, 1156, 2862, + 313, -3343, 48378, 48378, 1506, 59981, -3343, -3343, 34902, 6031, + 1271, -3343, -3343, 2378, 2380, -3343, 2248, 20321, 2386, 20321, + -3343, 23525, 2865, 2383, -3343, 20321, 2442, 28291, -3343, 20321, + -3343, 59981, 65071, 2390, 65071, -3343, -3343, -3343, -3343, 59981, + -3343, -3343, -3343, 20321, -3343, 5015, 5015, 5015, 20321, 20321, + -3343, -3343, -3343, -3343, 2597, 2501, -3343, 2501, -3343, -3343, + 20321, 2837, 815, 2792, 70161, 3, -3343, 2879, 2666, -3343, + -3343, 48378, -3343, -3343, -3343, 59981, -3343, 51373, -3343, 869, + 390, 2396, 20321, 44196, 2641, -3343, -3343, 2675, -3343, 2736, + -3343, 2469, 1716, 2400, 2403, 2409, 2411, 2412, 2413, 2418, + 2420, 2421, 2424, 2432, 2438, 2439, 2440, 2444, 2446, 2449, + 2450, 2454, 2457, 1743, 2458, -3343, 2459, 2178, 2465, 2467, + 2470, 2471, 2472, 75760, 2473, 2474, 2475, 2476, 1745, 2477, + 2478, 462, 1254, -3343, -3343, -3343, -3343, -3343, -3343, 1331, + 2479, -3343, -3343, -3343, -3343, 1359, 1156, -3343, 1930, 862, + 2336, 2436, 59981, 1272, 2837, -3343, 883, -3343, -3343, -3343, + -3343, -3343, -3343, -3343, -3343, -3343, -3343, -3343, 2437, 2453, + -3343, -3343, -3343, -3343, 2837, 2860, 2660, 2921, -3343, 2273, + 20321, 88, -3343, 1277, 2856, -3343, -3343, 2990, 2501, 2483, + 23525, 2484, -3343, 2486, 70161, 48378, 2638, -3343, -3343, 2487, + -3343, -3343, 20321, -3343, -3343, 44640, 2492, 2494, 2964, 2076, + 2442, 2442, -3343, 401, -3343, -3343, 2942, 34902, 2903, 20321, + 2604, 2981, 1307, 869, 2525, 1278, -3343, -3343, -3343, -3343, + -3343, 3591, -3343, 44237, 2765, 188, 2750, 2396, 20321, -3343, + 2514, 1331, 721, -3343, -3343, 3006, 2316, -3343, 54427, 2521, + -3343, 2336, 862, 2122, 20321, 20321, 2336, 2752, -3343, 2753, + 2530, 44286, 70161, 70161, 1930, 34902, 70161, 2532, 2442, -3343, + 2533, -3343, -3343, -3343, 29833, -3343, 2537, -3343, -3343, -3343, + 20321, 201, -3343, -3343, 2582, 59981, 1279, 110, 48378, 191, + 378, 2879, 2675, 42540, -3343, 51373, 1671, 390, 2848, -3343, + -3343, -3343, -3343, 144, 2764, -3343, 2768, -3343, 48378, 783, + 2609, 2837, -3343, 54427, -3343, 2316, -3343, 2539, 2541, -3343, + -3343, -3343, 34902, 2856, -3343, 330, -3343, 1736, -3343, 330, + -3343, -3343, -3343, -3343, -3343, 1688, 24059, 24059, 24059, 2542, + 2837, -3343, 1736, -3343, 2679, -3343, 2788, 20321, 104, 341, + -3343, -3343, -3343, 2636, 2750, -3343, -3343, -3343, -3343, -3343, + 504, 504, 2950, -3343, 2612, -3343, 2627, -3343, 2336, -3343, + -3343, -3343, 1285, 70161, 2047, -3343, 2047, 25127, 2707, 173, + 47231, 2932, -3343, 2932, 2932, -3343, -3343, -3343, 41522, -3343, + -3343, 48378, 2613, 70161, 2566, 2615, 41013, -3343, 191, -3343, + -3343, 3059, -3343, 226, -3343, -3343, -3343, -3343, 1930, 330, + -3343, -3343, 3052, -3343, -3343, -3343, -3343, -3343, 272, -3343, + -3343, -3343, 1736, -3343, 1291, -3343, -3343, 2565, -3343, -3343, + -3343, 869, -3343, -3343, -3343, 1736, 2047, 24593, 2717, -3343, + 2791, -3343, -3343, -3343, 20321, -3343, -3343, -3343, -3343, -3343, + 2567, -3343 }; /* YYPGOTO[NTERM-NUM]. */ static const yytype_int16 yypgoto[] = { - -3295, -3295, -3295, 2140, 84, -3295, -3295, 258, -3295, -3295, - 692, -1729, -1733, 1193, -3295, 251, -758, 691, -3295, 87, - 4693, 2849, 4942, 617, -531, -916, -1266, 18, 89, -1171, - 3, -3295, -3295, -1872, -3295, -1556, -451, 320, -3295, -3295, - -595, -2703, -545, -3295, -3200, -3232, -711, -3295, -2677, -3165, - -2165, 100, -2587, -3295, -3295, 106, 17, -2228, -3295, -1768, - 64, -2183, -3295, -144, -2859, 109, 114, 1095, -3295, -2738, - 117, -910, -1248, -972, -1243, -3295, -40, -3295, -3295, 548, - 126, 1319, 2183, -3295, 19, -2283, -3037, -557, -3295, -673, - -3295, -299, -3295, -611, -3295, -901, -619, -660, -2977, -1186, - -3295, 1823, -351, -3295, 736, -3295, -2742, -3295, -3295, 719, - -3295, 1251, 1252, -3295, -3295, -2366, 222, -594, -2789, -2736, - -2297, -914, 313, -602, 286, -2221, -1299, -3295, 753, -3295, - -586, -3295, -923, -1975, 130, -3295, -3295, 1707, -954, -3295, - 132, -580, -3295, -3295, -677, -3295, -3295, -3295, -3295, -3295, - -242, 135, -3295, 592, -3295, -2263, 595, -2217, 1748, -642, - -3295, 233, 7, 10, -3295, -3295, -3295, -3295, -799, 671, - -1916, -3295, -3295, -3295, -3295, 277, 4, 3275, -41, -32, - -3295, -28, -3295, -3295, -3295, 793, -3295, -3295, 2, 51, - 1915, -3295, -3295, -3295, -3295, -1046, -3295, -1893, 566, -3295, - 2070, 2075, -1821, -891, -33, 315, 837, -1734, -2199, -620, - 1312, 1895, 1902, -3295, 543, -2735, -3295, -528, -3295, -721, - -3295, -3295, -3295, 2065, -3295, 828, 1359, -1552, -1550, -3295, - -2327, -3295, -443, -321, -3295, -3295, -3295, -3295, -3295, -2437, - -3063, -599, 1327, -3295, 1908, -3295, -3295, -3295, -3295, 62, - -1599, 3105, 871, -3295, 203, -3295, -3295, -3295, -3295, 212, - -3295, 1060, -133, -3295, -478, -702, -809, 2122, 147, 217, - -1911, -9, -375, 584, -3295, -3295, 586, -2160, -1466, 538, - -237, 1062, -3295, -2373, -1602, -3295, -1527, -1211, -3295, -3295, - -783, 1498, -3295, -3295, -3295, 2882, 2887, -3295, -3295, 3069, - 3471, -3295, -931, 3592, 1076, -1058, 2135, -973, 2141, -941, - -958, -955, 2143, 2145, 2146, 2147, 2149, 2151, 2153, -1581, - 5816, -959, 3798, -2280, -3295, -1447, -1624, -3295, -3295, -3295, - 50, -3295, -1430, 127, -3295, -3295, -3295, -3295, -2924, -3295, - -424, -3295, -420, -3295, -3295, -3295, -1845, -3294, -1884, -3295, - 4395, 981, -3295, -3295, 524, -3295, -3295, -3295, -3295, -1588, - -3295, 7216, 889, -3295, -2115, -3295, -3295, -1005, -874, -473, - -1035, -1256, -2000, -3295, -3295, -3295, -3295, -3295, -3295, -1188, - -1839, -234, 946, -3295, -3295, 1046, -3295, -3295, -147, -1519, - -1823, -2190, -3295, -3295, -3295, 953, 1682, 158, -848, -1680, - -3295, -1586, -3295, -3295, 1004, -2531, -3295, -3295, 510, -2806, - -3295, -3295, 215, -3295, -694, -1158, -2593, 46, 26, -3295, - 1121, -2691, -3295, -3295, -733, -2851, -1150, -951, -3295, 136, - -3295, 173, 138, -1757, -3295, 23, -3295, -372, -3295, -3295, - -2754, -3295, 142, 149, 2386, -3295, 1290, -3295, -3295, -3295, - -3295, -555, -3295, -652, 2198, -3295, -3295, 30, -3295, 1806, - -3295, 165, 394, -3295, 1116, -3295, 689, 170, -3295, 2312, - -444, 171, 1457, -3295, -3295, -3295, 11, -541, 481, -3295, - 1466, -3295, -3295, -662, -1724, -3295, 695, 1339, -2168, 175, - -3295, 447, 15, -3295, -3295, -3295, 76, 176, 24, -3131, - 177, -2845, -1759, -7, -3295, -3295, -3295, -635, -3295, -2694 + -3343, -3343, -3343, 2207, 82, -3343, -3343, 321, -3343, -3343, + 757, -1714, -1739, 1258, -3343, 315, -838, 756, -3343, 87, + 4288, 2915, 4447, 11, -530, -902, -1279, 5, 91, -1179, + 7, -3343, -3343, -1636, -3343, -1551, -341, 383, -3343, -3343, + -540, -2744, -487, -3343, -3191, -3290, -666, -3343, -2748, -3146, + -2173, 96, -2527, -3343, -3343, 100, 6, -2233, -3343, -1755, + 64, -2226, -3343, -37, -2831, 106, 109, 1155, -3343, -2752, + 117, -921, -1235, -925, -1245, -3343, 17, -3343, -3343, 606, + 127, 1197, 2269, -3343, 10, -2244, -556, -499, -3343, -609, + -3343, -178, -3343, -543, -3343, -828, -551, -595, -3075, -1170, + -3343, 1901, -226, -3343, 810, -3343, -3029, -3343, -2996, -3343, + -3343, 793, -3343, 1327, 1328, -3343, -3343, -2362, 296, -523, + -2772, -2740, -2321, -938, 392, -521, 360, -2222, -1216, -3343, + 837, -3343, -505, -3343, -920, -1813, 128, -3343, -3343, 1792, + -954, -3343, 134, -502, -3343, -3343, -607, -3343, -3343, -3343, + -3343, -3343, -111, 143, -3343, 675, -3343, -2245, 676, -2241, + 1830, -406, -3343, 306, 18, 23, -3343, -3343, -3343, -3343, + -667, 759, -1906, -3343, -3343, -3343, -3343, 354, 8, 516, + -41, -24, -3343, -19, -3343, -3343, -3343, 870, -3343, -3343, + 19, 58, 1987, -3343, -3343, -3343, -3343, -1077, -3343, -1887, + 659, -3343, 2149, 2161, -1820, -900, -2, 394, 911, -1702, + -2230, -478, 1386, 1970, 1972, -3343, 629, -2449, -3343, -451, + -3343, -641, -3343, -3343, -3343, 2159, -3343, 914, 1442, -1631, + -1618, -3343, -1857, -3343, -362, -192, -3343, -3343, -3343, -3343, + -3343, -2582, -3005, -455, 1410, -3343, 1989, -3343, -3343, -3343, + -3343, 233, -1600, 3188, 952, -3343, 136, -3343, -3343, -3343, + -3343, 289, -3343, 1145, -3, -3343, -500, -715, -815, 2208, + 265, 334, -1934, -12, 325, 667, -3343, -3343, 671, -2202, + -1474, 616, -105, 1144, -3343, -2378, -1582, -3343, -1531, -1228, + -3343, -3343, -778, 849, -3343, -3343, -3343, 1609, 1897, -3343, + -3343, 2527, 2777, -3343, -948, 2876, 1488, -1062, 2224, -972, + 2225, -968, -959, -956, 2226, 2229, 2232, 2233, 2235, 2237, + 2242, -1594, 5407, -958, 2271, -2343, -3343, -1449, -1628, -3343, + -3343, -3343, 60, -3343, -1447, 85, -3343, -3343, -3343, -3343, + -2809, -3343, -346, -3343, -343, -3343, -3343, -3343, -1608, -3342, + -1644, -3343, 4225, 1064, -3343, -3343, 592, -3343, -3343, -3343, + -3343, -1587, -3343, 6518, 973, -3343, -2111, -3343, -3343, -1008, + -863, -454, -1035, -1256, -2014, -3343, -3343, -3343, -3343, -3343, + -3343, -1571, -1875, -164, 1032, -3343, -3343, 1133, -3343, -3343, + -17, -1543, -1808, -2190, -3343, -3343, -3343, 1040, 1763, 243, + -853, -1683, -3343, -1588, -3343, -3343, 1084, -2531, -3343, -3343, + 594, -2784, -3343, -3343, 285, -3343, -698, -1168, -2616, 632, + 27, -3343, -911, -3036, -3343, -3343, -737, -2436, -1157, -946, + -3343, 151, -3343, 248, 165, -1765, -3343, 13, -3343, -297, + -3343, -3343, -2717, -3343, 170, 172, 2462, -3343, 1377, -3343, + -3343, -3343, -3343, -550, -3343, -648, 2274, -3343, -3343, 28, + -3343, 1874, -3343, 174, 468, -3343, 1191, -3343, 945, 178, + -3343, 2361, -191, 179, 1533, -3343, -3343, -3343, 24, -604, + 550, -3343, 1534, -3343, -3343, -674, -1731, -3343, 758, 1403, + -2185, 180, -3343, 916, 20, -3343, -3343, -3343, 101, 183, + 14, -3188, 185, -2914, -1771, -7, -3343, -3343, -3343, -655, + -3343, -3061 }; /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If zero, do what YYDEFACT says. If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -2183 +#define YYTABLE_NINF -2189 static const yytype_int16 yytable[] = { - 536, 934, 79, 53, 72, 887, 1194, 70, 1162, 732, - 71, 96, 1270, 1230, 1476, 101, 536, 57, 1290, 66, - 1861, 1056, 79, 84, 105, 2277, 983, 1862, 1402, 873, - 1533, 1385, 1348, 534, 731, 799, 1345, 1446, 1391, 1744, - 2244, 871, 900, 2039, 2014, 1845, 2513, 904, 2149, 534, - 793, 905, 1449, 2109, 2396, 1450, 1643, 533, 1469, 569, - 2767, 2077, 1834, 2161, 2405, 763, 985, 2089, 2200, 1448, - 536, 536, 1880, 832, 1828, 2179, 841, 2719, 2729, 3183, - 2328, 758, 2610, 1803, 50, 825, 2699, 51, 2701, 52, - 884, 884, 2177, 2178, 3180, 3150, 885, 2680, 3148, 2348, - 55, 2718, 1866, 534, 534, 924, 56, 915, 3197, 59, - 866, 1946, 1290, 2758, 60, 993, 1721, 61, 1657, 3201, - 2825, 1724, 2965, 1034, 2869, 2248, 64, 832, 832, 1059, - 67, 2423, 68, 1002, 1415, 69, 82, 2384, 83, 825, - 825, 2422, 85, 2427, 2591, 2592, -1428, 3038, 2392, 86, - 834, 3043, 2581, 2582, 2583, 2598, 1619, 1620, 920, 2602, - -505, 1080, 1080, 3280, 1269, 92, 1275, 2834, 1279, 3283, - 93, 95, -2021, 2202, 1633, 100, 104, 106, 2560, -926, - 548, 2818, -395, 836, -2021, -572, -1369, 1379, 1081, 2714, - 2032, 3635, -2169, -2169, -931, 2033, 1081, 2829, -931, -1369, - -1350, 1729, 1460, -2012, 834, 834, -2012, -1366, -1366, -934, - -2029, -2160, -2160, 2835, -576, 2125, 2843, 2339, -2178, -2178, - 3416, -934, -2155, -2155, 2806, 2297, -1370, 2809, 937, 2300, - -2029, -1370, 836, -893, -1367, -1367, 1080, -906, 1003, -921, - 2827, -1189, 836, 836, 1824, 3182, -535, 3756, 1653, -1189, - 3475, 2768, -2180, -2180, 938, 1864, 1395, 1878, 1725, 1395, - 836, 1080, 2630, 1290, 1080, 1677, 1281, 877, 1879, 2192, - 1679, 1991, 3507, 1824, 2972, 2192, 1993, 3350, 1804, 1219, - 901, 902, 1664, 895, 2797, 1846, -572, 3365, 1849, 1850, - 1370, 1028, 2419, 1752, -249, 1182, 2231, 3383, 549, -249, - 1222, 1687, 2885, 2887, 2232, 2890, 2714, 3592, 1624, 1379, - 1059, 552, 1766, 1493, 3172, -576, 2310, 2926, 1500, 3400, - 1503, 939, 1034, 2456, -1210, 1635, 3333, 3, 4, 1371, - -721, 2031, -1210, 897, 1181, 1689, 3403, 1284, 1179, 1528, - 2852, 836, 1026, 2241, 1991, 1881, 2570, 3520, 1992, 1993, - 940, 1409, 1035, 897, 896, 3705, 3420, 2761, 1802, 836, - 3639, 1767, 2769, 3712, 3729, 1002, 3551, 3202, 2083, 2031, - 1831, 1851, 3004, 1726, 3006, 553, 3552, 2528, 974, 3777, - 1798, 1799, 2896, -863, 854, 3481, 3796, 3483, 961, 2534, - 3347, 3053, 3361, 2272, 941, 1748, 1648, 3082, 3622, 3714, - 1215, 1209, 2571, 2303, 1812, 1856, 3359, 3698, 1629, 1677, - 3715, 1638, 2691, 1678, 1679, 2907, 3031, 2587, 3586, 2562, - 3587, 3318, 3716, 1677, 2333, 3603, 2567, 962, 3659, 1857, - 1768, 1520, 1677, 1639, 1012, 897, 1678, 1679, 3410, -2154, - -2154, 3382, 1885, 546, 3493, 1687, 891, 3775, 1958, 1927, - 891, 1991, 1041, 1080, 3425, 1992, 1993, 2588, 3411, 1687, - 1832, 3319, 1649, 1677, 2838, 1183, 3348, 1184, 1687, 1348, - 2603, 3494, 3083, 3052, 2603, 1763, 1560, 1217, 2273, 1689, - -572, 1769, 3360, 1521, 3032, 2334, 855, 2203, 1379, 1380, - 3604, 3717, 3737, 1689, 2762, 3685, 1036, 2242, 3688, 1727, - 1815, 3641, 1689, 1210, 2624, 3772, 3810, 1989, 1990, -576, - 1346, 3220, 1372, 2010, 1882, 3706, 2204, 965, 3564, 1852, - -863, 2304, 1243, 1246, 942, 2957, 3736, 1643, 1244, 3034, - 1853, 3518, 2758, 1689, 2758, 943, 1285, 3203, 892, 2897, - 3593, 3778, 892, 804, 3707, 3553, 3713, 1770, 1175, 3532, - 2572, 3621, -572, 3797, 949, 3502, 2612, 3362, 2420, 3084, - 1499, 1749, 1637, 557, 1884, 992, 1960, 3309, 3536, 3311, - 803, 1080, 944, 2649, 3512, 1833, 2811, 2812, 2813, 893, - 3233, -576, 1833, 1805, 2080, 3173, 1764, 2770, 3397, 2771, - 898, 560, 2819, 2820, 2200, 1009, 945, 3764, 732, 1668, - 2311, 1865, -475, 3210, 3770, 1384, 2023, 3508, 2119, 2606, - 1800, 1380, 969, 1619, 1620, -1189, 3193, 3422, 1871, 2772, - 878, 2411, 3492, 971, 2149, 946, 3351, 3496, 2404, 3724, - 2798, 1801, 1373, 1245, 2205, 1739, 932, 3165, 1633, 2408, - 933, 3760, 838, 983, 2207, 2926, 2040, 2193, 1948, 3211, - 3686, 1615, 550, 2682, 1952, 1381, 3187, 3757, 2652, 3580, - 3528, 835, 1747, 3224, 1817, 1751, 2839, 2805, 2064, 2703, - 2233, 2721, 3374, 3375, 2836, -572, 1862, -1428, 2984, 2940, - 2846, 2507, 2920, 2908, 2909, 2910, 2911, 2247, 2727, 1949, - 3150, -505, -505, 3148, 2894, -2021, 1638, 975, -1210, 2202, - 2131, 2132, -926, 1630, -576, 3730, 2821, -2021, 1638, -1369, - 1344, 1124, 1125, -395, -572, 1630, -572, -931, 1639, 1124, - 1125, 932, -1369, -1350, 3378, 933, -2012, 887, 1384, -2012, - 1639, 2297, 1640, -2029, 2732, 2810, 929, 1621, 2116, 1653, - 3718, 1956, 3499, -576, 1642, -576, 3464, 3500, 1653, -1370, - 1290, 2173, 1290, -2029, -1370, 1672, 1622, 2825, 3476, 1002, - 1627, 1001, -921, 2152, 3341, 1722, 2249, 1022, 1624, 79, - 1185, 1399, 1400, 3620, 1399, 1400, 3673, 1384, 1710, 887, - 1856, 2054, 799, 3687, 2008, 2029, 1818, 894, 1635, 932, - 1380, 2625, 3627, 1665, 1246, 2174, 3442, 3628, 998, 2533, - 1243, 2208, 536, 2071, 1857, 3025, 1244, 988, 2333, -249, - -249, 3765, 2209, 536, 1176, 3414, 2522, 116, 1040, 1079, - 536, 2523, 1991, 2107, 2404, 880, 1992, 1993, 3018, 107, - 2561, -2183, -2183, -2183, 2789, 534, 3444, 2707, 2771, 2339, - 904, 3720, 1638, 951, 905, 952, 534, 2790, 3062, 536, - 536, 3655, 3656, 534, 2005, 2006, 2007, 2008, 1248, 832, - 3417, 1766, 3332, 2708, 1639, 3721, 1180, 3415, 3095, 2755, - 832, 1231, 2568, 536, 3063, 3418, 2372, 832, 1640, 3005, - 108, 2524, 1024, 3696, 3019, 1180, 2375, 3180, 889, 2378, - 1249, 1177, 79, 53, 72, 2870, 110, 70, 3228, 3766, - 71, 96, 117, 1331, 1074, 101, 3700, 57, 1186, 66, - 1767, 1245, 1064, 84, 105, 3674, 111, 2568, 3334, 1707, - 1708, 1709, 1710, 1065, 3519, 536, 732, 884, 3767, 1337, - 536, 1947, 1195, 2371, 866, 866, 834, 866, 1824, 866, - 1705, 1706, 1707, 1708, 1709, 1710, 2541, 834, 3411, 1825, - 1215, 953, 874, 954, 834, 1216, 2195, 1505, 3401, 2003, - 2004, 2005, 2006, 2007, 2008, 1250, 2730, -741, 2824, 1824, - 2692, 1080, 3150, 2927, 50, 3148, 890, 51, 2497, 52, - 1827, 906, 1337, 3290, 2433, 3166, 3167, 2397, 2398, 2399, - 55, 2506, 111, 1001, 2575, 2508, 56, 887, 2510, 59, - 536, 536, 3675, 1391, 60, 79, 536, 61, 118, 536, - 536, 2936, 536, 536, 536, 536, 64, 3798, 799, 1347, - 67, 3050, 68, 1025, 907, 69, 82, 1217, 83, 536, - 1769, 536, 85, 2535, 2536, 2537, 2538, 2539, 2540, 86, - 536, 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, - 2553, 3099, 2149, 2325, 909, 92, 3801, 536, 1337, 1607, - 93, 95, 534, 3505, 534, 100, 104, 106, 928, 1256, - 3159, 3419, 1246, 534, 2765, 3785, 3066, 1215, 1218, 536, - 1631, 1632, 887, 3792, 2975, 2370, 832, -659, 832, 1257, - 112, 932, -659, 2542, 1045, 933, 1770, 832, 825, 536, - 1024, 113, 2704, 2543, 2705, 2381, 3367, 927, 1999, 825, - 2388, 536, 536, 536, 3372, 536, 536, 1243, 732, 3069, - 836, 2373, 1900, 1244, 1668, 2014, 2376, 2039, 1862, 23, - 1046, 3488, 1247, 2215, 3802, 1258, 1248, 1638, 114, 959, - 2117, -2149, -2149, 1658, 3056, 1835, 1506, 2814, 2738, 2123, - 1243, 536, 2566, 3616, 1217, 1393, 1244, 1048, 1394, 1639, - 1947, 1901, -2021, 834, -659, 834, 112, 552, 1249, 536, - 536, 2521, 3300, 1642, 834, 2525, 1505, 113, 2527, 1754, - 1755, 932, 1761, 905, 905, 1665, 905, 3146, 930, 2672, - 1508, 115, -1414, 936, 1180, 2235, 1515, 1180, 3405, 2236, - 948, 2727, 1432, 1433, 1737, 1218, 536, 1738, 2799, 3537, - 536, 536, 960, 1836, 114, -659, -2150, -2150, 2673, 3599, - 536, 536, 536, 1953, 552, 536, 1954, 3436, 1245, 3803, - 2456, 553, 1259, 3057, 2667, 2668, 932, 1657, -1350, 1496, - 933, 1025, 884, 1250, 2628, 2022, 955, 2024, 2025, 1607, - 1512, 1904, 1169, 1170, 967, 1172, 2079, 1174, 2216, 2080, - 3396, 1245, 2853, 1863, 3538, 1513, -225, 115, 2105, 1518, - 972, 2106, 2864, 3539, 973, 2217, 26, 27, 28, 2416, - 2218, 3510, 2417, 1260, 958, 1337, 3073, 991, 553, 1052, - 1068, 1069, 1070, 976, 1261, 1073, 1337, 3540, 1613, 977, - 46, 2927, 3058, 1837, 3059, 978, 1262, 2516, 1507, 2554, - 2517, 979, 2555, 1045, 961, 3342, 2448, 2604, 2449, 2219, - 2605, 1337, 1438, 1439, 2670, 120, -2183, -2183, -2183, 547, - 2003, 2004, 2005, 2006, 2007, 2008, 3074, 762, 1263, 2607, - 989, 2674, 2605, 33, 2785, 2791, 2675, 2786, 2792, 1046, - 3391, 853, 1007, 962, 3075, 867, 2700, 1838, 1009, 2807, - 2867, 732, 2517, 2868, 1008, 1514, 556, 1908, 1010, 1909, - 732, 3541, 1013, 1911, 1912, 3276, 1048, 2933, 959, 2824, - 2605, 2576, 38, 2577, 3542, 1016, 1941, 1001, 3804, 1246, - 963, 1017, 2779, 1265, 2781, 79, 2934, 2937, 2939, 2106, - 2938, 2938, 3026, 3190, 732, 3027, 3191, 3268, 799, 536, - 3270, 836, 3272, 3192, 964, 1018, 2417, 40, 1266, 557, - 1005, 992, 1246, 3230, 998, 1833, 3231, 1019, 43, 1963, - 1950, 3291, 1951, 3386, 2106, 3229, 2275, 2921, 2578, 1268, - 2579, 2928, 1020, 965, 559, 2149, 895, 560, 2782, 1273, - 2784, 960, 1063, 1248, 3049, 1021, 3051, 2109, 3076, 536, - 536, -660, 1212, 2741, 1214, 536, -660, 536, 3077, 1022, - 2658, 1027, 536, 536, 536, 536, 557, 1171, 992, 2220, - 3794, 3437, 1277, 46, 2106, 1274, 1248, 536, 536, 3438, - 3470, 1029, 2605, 2106, 1061, 2870, 1066, 536, 3477, 536, - 534, 2080, 536, 2676, 560, -2151, -2151, 536, 1052, 536, - 536, 1071, 536, 1072, 2677, 2833, 536, 896, 1278, 3489, - -2152, -2152, 3490, 3086, 832, 3526, 838, 1507, 3191, 3093, - 534, 1075, 534, 14, 15, 534, 3739, 1074, -660, 3773, - 534, 3774, 1173, 534, 3527, 534, 1196, 2417, 1189, 534, - 1835, 3751, 3561, 1900, 832, 2106, 832, 3726, 3625, 832, - 1250, 3191, 3637, 1197, 832, 3638, 825, 832, 825, 832, - 1199, 825, 1607, 832, 3667, 3176, 825, 3668, 1203, 825, - 23, 825, -2156, -2156, 3085, 825, 3094, 2958, 2959, -660, - 1200, 3543, 1901, 1250, 3544, 1201, 2339, 1213, 897, 1204, - 3809, 834, 2456, 1206, 3711, 536, 536, 3638, 3618, -2157, - -2157, 79, 2108, 2112, 536, 536, 2110, 1401, 1836, 2111, - 2114, -2158, -2158, 536, 2115, 3805, 1232, 1444, 1235, 1902, - 536, 834, 3771, 834, 1237, 3638, 834, 536, 3808, 3806, - 1238, 834, 3490, 1239, 834, 1240, 834, 2944, 1657, -1902, - 834, 3582, 3583, 1903, -2159, -2159, 1242, 536, 732, -2161, - -2161, 116, 536, 2946, 2948, 536, 2947, 2949, 2950, 3463, + 536, 1270, 934, 1162, 1230, 887, 57, 53, 72, 732, + 66, 1476, 1345, 84, 105, 1056, 536, 1194, 70, 79, + 101, 731, 983, 71, 96, 1862, 873, 2014, 1845, 1744, + 1533, 1385, 1290, 1861, 534, 1348, 838, 2244, 1446, 79, + 799, 2039, 1448, 1391, 2700, 871, 2702, 2730, 793, 2149, + 534, 1449, 1643, 2077, 1450, 904, 2514, 2277, 2109, 1469, + 905, 2161, 985, 2089, 2200, 2406, 1828, 533, 2611, 2397, + 536, 536, 1880, 900, 2328, 1402, 1803, 2720, 1834, 2177, + 2178, 758, 50, 832, 1269, 1721, 1275, 51, 1279, 1404, + 1724, 52, 3134, 2719, 1866, 2179, 55, 2827, 1946, 2768, + 56, 2681, 924, 885, 534, 534, 59, 3155, 834, 60, + 1034, 915, 2759, 1002, 2348, 1657, 1059, 61, 3137, 993, + 2871, 2592, 2593, 2967, 2248, 3040, 1290, 64, 67, 3045, + 929, 2428, 2599, 2423, 68, 866, 2603, 832, 832, 1619, + 1620, 2393, 2561, 69, 2424, 1415, 2297, 1080, -1434, 2202, + -511, 82, 2385, 3237, 548, 3370, 1379, 1633, 2582, 2583, + 2584, 2300, 834, 834, 2715, 83, 1379, -399, 1080, 3642, + 85, -2027, 86, -937, 92, 2125, -1356, -937, 93, 95, + 100, -578, -582, 104, 877, 106, 2836, 3234, -2161, -2161, + 2837, -1375, 2820, 2831, 836, -2027, 1460, -1375, 2829, 1081, + 1812, -2018, -2018, -2175, -2175, -1372, -1372, -2035, 2808, -2166, + -2166, -2035, 2032, 901, 902, -1376, 2845, 2033, 1081, -2184, + -2184, 3354, 3772, -1373, -1373, 836, 891, 1175, -940, 1080, + -1376, 1674, -932, -899, -912, -927, 1664, 2339, 2811, 836, + 836, 3374, -1195, 1003, 2974, -940, 14, 15, 1729, -541, + -1195, 2192, -2186, -2186, 1281, 2928, 825, 1878, 1677, 1653, + 2192, 3429, 1404, 1679, 1725, 1395, 836, 3740, 1879, 1752, + 1080, 1181, 549, 1395, 3521, 836, 3461, 1290, 1080, 111, + 2231, 3304, -578, -582, -249, 1991, 1379, 3287, 2232, -249, + 1993, 897, 1028, 23, 1687, 3550, 1815, 1059, 3596, 3519, + 2631, 3351, 2887, 2889, 116, 2892, 3319, 3136, 2854, 1034, + 825, 825, -727, 1624, 3725, 1182, 3371, 1831, 892, 3315, + 1026, 2031, 1677, 2310, 3529, 3726, 1678, 1679, 1689, 1991, + 1635, 3372, 1846, 1992, 1993, 1849, 1850, 3727, 897, 1179, + 2898, 3794, 3627, 2457, 3813, 1002, 1404, 3, 4, 1404, + 1404, 2083, 1881, 1748, -1216, 1409, 3709, 2571, 1687, 2031, + 1035, 2241, -1216, 3680, 1370, 1284, 1677, 891, 836, 1802, + 1678, 1679, 2272, 3646, 2909, 1798, 1799, 3818, 3555, 1726, + 1991, 1763, 1677, 1824, 1992, 1993, 974, 3716, 3556, 117, + 546, 3723, 1689, 1493, 1864, 3156, 3055, 2529, 1500, 1677, + 1503, 2715, 1687, 1371, 1629, 3301, 3728, 1832, 3362, 2535, + 3538, 3084, 3033, 2572, 1215, 3792, 2534, 1648, 1687, 1528, + 1824, 1219, 2762, 2303, 3263, 1927, 3265, 2692, 1804, 3361, + 3590, 2799, 3591, 1885, 1631, 1632, 1689, 1856, 2588, 2563, + 26, 27, 28, 3694, 1222, 3379, 2568, 2562, 3699, 2772, + 3537, 3666, 1689, 112, 3435, 3819, 3437, 2273, 1380, 892, + 1817, 1857, 1064, 3789, 113, 3539, 1958, 3621, 1380, 1689, + 803, 1080, 1348, 1065, 3540, 3827, -578, -582, 2589, 3097, + 3034, 3302, 1560, 1649, 3316, 1183, 3085, 1184, 1959, 1961, + 2604, 1217, 1764, 1176, 2604, 118, 2203, 2899, 3541, 3036, + 893, 114, 3681, 3795, 1036, 1727, 3632, 33, 1989, 1990, + 2420, 3814, 3753, 3054, 2010, 2242, 73, 3174, 35, 1749, + 3126, 1882, 1884, 1643, 2625, 2204, 3456, 3373, 3533, 1833, + 2959, 3597, 2759, 3626, 2759, 3446, 73, 878, 1499, 824, + 3450, 2304, 37, 1833, 1637, 3466, 38, 3717, -578, -582, + 3820, 3692, 2613, 73, 115, 2412, 3752, 3557, 949, 2763, + 3787, 2573, 886, 3648, 1285, 3157, 804, 2626, 3780, 2080, + 1177, 2650, 3542, 3086, 3724, 1384, 3718, -481, 2813, 2814, + 2815, 40, 1818, 1074, 2928, 3543, 1372, 3568, 1380, 3682, + 2200, 3348, 43, 824, 824, 903, 1619, 1620, 732, 1747, + 1668, 2607, 1751, 2821, 2822, 3396, 1871, 2311, 3741, 44, + 971, 3462, 3521, 3147, 932, 3141, -1195, 2023, 933, 73, + 3749, 1633, 3119, 3164, 1381, 2149, 550, 3165, 2405, 2193, + 3305, 3376, 3773, 45, 1384, 3584, 3695, 3519, 2683, 983, + 1739, 2040, 2653, 2205, 1948, 569, 2119, 46, 2409, 835, + 1952, 763, 2297, 2207, 2233, 3729, 2704, 3328, 3329, 2896, + 2922, 2807, 841, 2064, 3178, 2986, 2733, 2838, 2508, 2848, + 2722, -578, -582, 3453, 1862, 2202, 884, 884, 3454, -1434, + 2841, -511, -511, 2131, 2132, 1949, 2942, 2247, 1384, 2728, + 2910, 2911, 2912, 2913, -2027, 1344, -937, 932, -399, -1356, + 3418, 933, 1630, 1621, 1615, 975, 1373, -869, 894, 3821, + -578, -582, -578, -582, -1375, 1638, 2124, 2823, -2027, 3696, + -1375, 3332, 1124, 1125, -2018, -2018, 1630, 887, -1216, 2155, + -2035, 2156, 1638, 1805, -2035, 2827, 3776, 1639, -1376, 1002, + 1865, 1124, 1125, 932, 920, 1956, 2812, 1665, 1672, 2116, + 1653, 1640, 1800, -1376, 1639, -932, 1622, 1627, -927, 1653, + 2175, 1001, 1722, 2249, 1290, 2173, 1290, 1022, 1642, 3430, + 1856, 1710, 2029, 1624, 2152, 1801, 2421, 2800, 874, 887, + 1399, 1400, 3781, 3027, 3633, 3731, 79, 799, 1399, 1400, + 1185, 3127, 3544, 1635, 1857, 3545, 998, 895, 2008, -249, + -249, 2542, 536, 1520, 3398, 3295, 2174, 3607, 3313, 3732, + 2208, 3625, -666, 536, 1005, 1040, 854, -666, 1215, 836, + 536, 2209, 880, 1216, 2405, 961, 1851, 3272, 2107, 1760, + 1705, 1706, 1707, 1708, 1709, 1710, 534, 2003, 2004, 2005, + 2006, 2007, 2008, 3006, -869, 3008, 1063, 534, 904, 536, + 536, 890, 2523, 905, 534, 1521, 3286, 2524, 2333, 110, + 2339, 2054, 2569, 1180, 962, 2296, 2296, 3273, 896, 832, + 3782, 1171, 3608, 536, 895, 3020, 1707, 1708, 1709, 1710, + 832, 3007, 1180, 2071, 3314, 889, 3182, 832, 3134, -666, + 2005, 2006, 2007, 2008, 834, 1217, 57, 53, 72, 3783, + 66, 2840, 1231, 84, 105, 834, 1186, 2569, 70, 79, + 101, 3352, 834, 71, 96, 2333, 2872, 2525, 855, 2334, + 838, 906, 2372, 2373, 3288, 536, 732, 3707, 552, 1337, + 536, 3021, 3365, 2376, 1331, -747, 2379, 1404, 3447, 1195, + -666, 14, 15, 23, 1638, 896, 1218, 1404, 2543, 897, + 1404, 907, 2195, 3362, 965, 111, 1025, 2693, 2544, 866, + 866, 909, 866, 2576, 866, 3448, 1639, 2826, -2160, -2160, + 2929, 3244, 50, 2325, 1852, 1209, 2756, 51, 2398, 2399, + 2400, 52, 1337, 2498, 3366, 1853, 55, 2434, 23, 3058, + 56, 2507, 553, 1001, 2769, 2509, 59, 887, 2511, 60, + 536, 536, 3120, 3121, 927, 2371, 536, 61, 1391, 536, + 536, 1401, 536, 536, 536, 536, 3052, 64, 67, 1347, + 3802, 1444, 79, 799, 68, 2382, 897, 1505, 3809, 536, + 2389, 536, 2938, 69, 2536, 2537, 2538, 2539, 2540, 2541, + 536, 82, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, + 2553, 2554, 3187, 1024, 2149, 83, 3459, 536, 1337, 1607, + 85, 2766, 86, 534, 92, 534, 73, 3101, 93, 95, + 100, 3815, 2977, 104, 534, 106, 2708, 1210, 3059, 536, + 1900, 928, 887, 3622, 1766, 3442, 1505, 3113, 3068, -665, + 26, 27, 28, 107, -665, 2705, 832, 2706, 832, 536, + 1393, 1042, 2709, 1394, 898, 2770, 1043, 832, 1243, 2014, + 2203, 536, 536, 536, 1244, 536, 536, 2374, 732, 1901, + 3064, 834, 2377, 834, 1009, 1668, 2039, 1862, 1215, 112, + 1658, 3071, 834, 1767, 1012, 26, 27, 28, 2739, 2204, + 113, 3662, 3663, 1670, 108, 2791, 3065, 3060, 2816, 3061, + 937, 536, 1041, 1673, 1243, 1766, 3356, 33, 2792, 2117, + 1244, 836, 1824, 2567, 1045, 1044, -665, 3390, 2123, 536, + 536, 930, 1496, 1825, 1025, 1723, 938, 114, 3367, 2620, + 557, 898, 992, 1512, 1728, 3689, -2027, 1754, 1755, 3254, + 1761, 1180, 905, 905, 1180, 905, 38, 2215, 969, 3711, + 1046, 2801, 33, 120, 1767, 1217, 536, 547, 560, 1904, + 536, 536, 3603, 35, 936, 762, 1506, -665, 1638, 1245, + 536, 536, 536, 1045, 3347, 536, 948, 1048, 1638, 853, + 115, 40, 955, 867, 1657, 2668, 2669, 37, 1045, 1243, + 1639, 38, 43, 939, 3690, 1244, 1226, 1432, 1433, 1607, + 1639, 1947, 2457, 1769, 1640, 2629, 1218, 2205, 1960, 1046, + 1863, -225, 2206, 1080, 1642, 1245, 1246, 2207, 3368, 825, + 3321, 1024, 940, 1768, 1046, 1514, 40, 2731, 3326, 2855, + 825, 1835, 1080, 73, 886, 1337, 1048, 43, 1243, 2866, + 1047, 1824, 1872, 3464, 1244, 958, 1337, 46, 3075, 2929, + 967, 1048, 1827, 2522, 44, 3342, 3746, 2526, 1508, 1737, + 2528, 3296, 1738, 1947, 1515, 2022, 941, 2024, 2025, 1770, + 1953, 1337, 2216, 1954, 1769, 1011, 1169, 1170, 45, 1172, + 2771, 1174, 2772, -2155, -2155, 2671, 1023, 1049, 2703, 2217, + 972, 932, 46, 1039, 2218, 933, 1835, 2701, 3076, 1836, + 1245, 932, 2449, -1356, 2450, 933, 1908, 973, 1227, 1052, + 1909, 732, 2773, 1911, 1912, 932, 3077, 1438, 1439, 1665, + 732, 2732, 2732, 1941, 951, 3230, 952, 2235, 1507, 2826, + 1246, 2236, 1513, 2219, 1050, 976, 1518, 1001, 903, 978, + 1770, 1051, 2780, 988, 2782, 2079, 2673, 2105, 2080, 1245, + 2106, 953, 977, 954, 732, 3222, 73, 979, 3224, 536, + 3226, 989, 79, 799, 1836, 1007, 1963, 2417, 1052, 1008, + 2418, 1962, 998, 1010, 2208, 2674, 1246, 2517, 2923, 3183, + 2518, 2555, 2930, 1052, 2556, 2209, 1613, 1507, 46, 1837, + 1247, 1424, 1425, 1009, 1248, 1243, 942, 2605, 2149, 1013, + 2606, 1244, 1053, 2608, -2156, -2156, 2606, 943, 2742, 536, + 536, 2449, 1016, 2450, 2109, 536, 2659, 536, 2786, 1017, + 3078, 2787, 536, 536, 536, 536, 1249, 1860, 2793, 2809, + 3079, 2794, 2518, 2577, 1018, 2578, 1273, 536, 536, 2579, + 1248, 2580, 2835, 1838, 944, 2869, 1019, 536, 2870, 536, + 1243, 534, 536, 1020, 1837, 3755, 1244, 536, 1021, 536, + 536, 1246, 536, 884, 1432, 1433, 536, 2872, 945, 73, + 3767, 2783, 1274, 2785, 3790, 1054, 3791, 1022, 3095, 2935, + 1228, 534, 2606, 534, 832, 3811, 534, 3088, 3051, 2936, + 3053, 534, 2106, 2220, 534, 552, 534, 946, 2675, 1027, + 534, 1250, 824, 2676, 1023, 1212, 1245, 1214, 1838, 834, + 1246, 1833, 1029, 824, 832, 2939, 832, 1061, 2940, 832, + 2339, 1277, 1607, 1066, 832, 1248, 2457, 832, 2941, 832, + 1071, 2940, 1072, 832, 2960, 2961, 3826, -2157, -2157, 834, + 3130, 834, 1074, 1835, 834, -2158, -2158, 1250, 1614, 834, + 3822, 3087, 834, 3096, 834, 536, 536, 1278, 834, 553, + 1626, 1245, 1075, 3825, 536, 536, 2108, 2112, 1173, 3623, + 3586, 3587, 3028, 536, 1248, 3029, 1833, 2110, 79, 2115, + 536, 1189, 2111, 2114, 1438, 1439, 1196, 536, 1243, 1655, + 2055, 1197, 2056, 3417, 1244, 2058, 1657, 1199, 3144, 2946, + 2062, 3145, 1200, 2065, 2947, 2066, 1249, 536, 732, 2070, + 1201, 1836, 536, 2948, 2950, 536, 2949, 2951, 2952, 1203, 1607, 536, 536, 536, 536, 536, 536, 536, 536, 732, - 2945, 1860, 1904, 536, 536, 536, -2162, -2162, 536, 1331, - 1241, 552, 536, -2163, -2163, 536, 536, 536, 536, 536, - 536, 536, 536, 536, 2189, 1254, 536, 2055, 1837, 2056, - -2164, -2164, 2058, 536, 1255, 1337, -1414, 2062, 534, 1272, - 2065, 1276, 2066, 2988, 2989, 1835, 2070, 26, 27, 28, - 2279, -2165, -2165, 536, 905, 1424, 1425, -2166, -2166, -2167, - -2167, -2168, -2168, -2170, -2170, -2171, -2171, 2298, 2299, 1670, - -1902, 1835, 1280, 898, 1282, 553, -2172, -2172, 536, 1673, - 1340, 1243, 1838, -2173, -2173, 1344, 2133, 1244, 1186, 536, - 536, -716, -716, 2134, 2135, 1343, 2880, 1349, 2136, 2137, - 2138, 1723, 3146, -2174, -2174, -2175, -2175, -2177, -2177, 1354, - 1728, 1243, 1366, 1836, 33, 1369, 2727, 1244, -1902, -2179, - -2179, -2182, -2182, 2173, 1368, 35, 2244, 1376, 1432, 1433, - 2203, 2432, 1607, -1902, 1887, 1888, -720, -720, -1902, 1836, - -719, -719, 732, -1902, 1434, 1435, 732, 1438, 1439, 37, - 1833, 1387, -1902, 38, 3214, 3215, 1377, -1902, 1383, 2204, - 1386, 1079, 3338, 3339, 1991, 3758, 3761, 2354, 1992, 1993, - 1392, 2360, 3093, 1994, 1995, 1996, 1867, 2872, 2874, 1410, - 2329, 3747, 3748, 3783, 3784, 1733, 1734, 732, 40, -1902, - 536, 2343, 1245, 2346, 2746, 2747, 2357, 1337, 1411, 43, - 536, 536, 1870, 1837, 1416, 1474, 2365, 1487, 2367, 552, - -1902, 1489, 1963, 1490, 3042, 1501, 44, 1497, 1872, 1509, - 1510, 2374, 1245, 1760, 1516, 1517, 2377, 1527, 1523, 1837, - 2382, 2383, 1529, 2385, 3184, 2389, 2390, 2497, 1607, 3153, - 45, 2083, 2498, 3171, 1609, -897, 3223, 2452, 1438, 1439, - 1610, 1612, -904, 1243, 46, 1621, 3225, 1838, 1625, 1244, - 732, -1902, 46, 557, -1902, 992, -741, 1337, 536, 3208, - -1902, -742, -894, 553, -895, 1636, 536, 2205, -898, 1637, - 3738, 3302, 2206, 1838, 3740, -896, 1644, 2207, 559, 1669, - 1659, 560, 1607, 1835, 1716, 1671, 536, 536, 1718, 536, - 1720, 1732, 1740, 1741, 1607, 536, 536, 536, 536, 536, - 536, -1902, 1745, 536, 536, 536, 536, 536, 536, 536, - 536, 536, 536, 1750, 3560, 1833, 1753, 1216, 536, 536, - 1788, 1218, 536, 1790, 1607, 1792, -1902, 23, 1808, 536, - 1810, 1607, 1829, 1830, 1840, 1841, 1842, 1962, 1847, 555, - 1854, 1833, 1855, 1246, 1997, 1877, 1859, 1869, 3799, 1890, - 1835, 1836, 1874, 536, 1245, 1891, 1079, 1896, 1899, 1991, - 536, 1906, 536, 1992, 1993, 2726, 536, 1998, 1994, 1995, - 1996, 1892, 1913, 1246, 3146, 1607, -585, 1907, 1914, 1607, - 1917, 536, 1923, 1337, 11, 1607, 874, 1920, 2727, 1921, - 1924, -585, 1925, 534, 1926, 1928, -585, 1929, 1346, 534, - 1942, 1947, 1943, 2324, 1955, -224, 1983, 1248, 2019, 1607, - 1980, 1982, 14, 15, 2796, -1902, 1985, 832, 1836, 2030, - 3358, 536, 536, 832, 3370, 2050, -1902, 1988, 536, 825, - 2011, 1404, 2020, 2379, 2208, 825, 2057, 1248, 2027, 1249, - 1999, 1837, 2052, 2067, 2053, 2209, -1902, -585, -1902, -1902, - 2063, 557, 1604, 558, 3379, 3380, 2068, 2069, 2075, 23, - 3524, 536, 1622, 2081, 2078, 536, 1615, 887, -585, 2380, - 536, 536, 1627, 3560, 26, 27, 28, 2082, 2084, 560, - 2085, 2800, 2088, 2086, 2119, -1902, 2118, 1080, -1902, -1902, - -1902, 1677, 2153, 1835, 834, 1838, 536, 536, 2158, 2154, - 834, 536, 2162, 2165, 2168, 2167, 2169, 3267, 1837, 2191, - 2039, 2211, 2170, 2214, 1250, 1246, 2238, 536, 3560, -585, - 536, 536, 536, 2212, 2239, 2257, 2245, 2259, -585, 2258, - 2260, 2261, 2265, 896, 2275, 2278, 2287, 2288, 536, 732, - 2289, 33, 2292, 2290, 1250, 536, -1904, 1657, 536, 2312, - 2291, 2313, 1042, 2309, 534, 2317, 2314, 1043, 2322, 1730, - 2326, 1836, 1838, 1833, 536, 2330, 2331, 2332, 536, 2340, - 2593, 3560, 1998, 1674, 897, 2386, 2596, 3435, 536, 1248, - 38, 534, 2358, 2139, 2140, 2141, 2359, 2142, 2143, 2144, - 2145, 2146, 2147, 2400, 2363, 536, 536, 534, 2364, 2401, - 2414, 534, 2418, 2424, 1404, 832, 26, 27, 28, 3576, - 2402, 2387, 536, 1950, 536, 40, 1044, 825, 2434, 2435, - 2438, 832, 2436, 2437, 2804, 832, 43, 2439, 2453, 536, - 1833, 2457, 2458, 825, 2501, 2460, 2499, 825, 2500, 2503, - 2502, 2505, 1604, 732, 3356, 1999, 2518, -1904, 2509, 2526, - 2016, 1837, 732, 732, 732, 1991, 2556, 2250, 2000, 2001, - 2002, 2015, 2003, 2004, 2005, 2006, 2007, 2008, 2563, 2564, - 2585, 2597, 2573, 33, 2565, 2569, 2609, 2354, 2354, 2354, - 2574, 46, 834, -585, 35, 2595, 1250, 2611, 1404, 1045, - 2616, 1404, 1404, 2617, 3020, -1904, 2618, 536, 834, 2627, - 2626, -585, 834, 2634, 2635, 1838, 1337, 23, 37, 2620, - -1904, 2638, 38, 2639, 2621, -1904, -585, 2622, 2640, 2623, - -1904, -585, 2643, 2641, 2642, 1046, 2644, 2645, 2656, -1904, - 2646, 2319, 2321, 39, -1904, 1676, 1862, 1649, 1677, 732, - 2652, 1047, 1678, 1679, 1607, 2666, 2663, 40, 2664, 1908, - 23, 1909, 1048, 932, 2671, 1911, 1912, 933, 43, 2687, - 3513, 2678, 2711, 2688, 2840, 2695, -1904, 2693, 2714, 2694, - 2706, 2713, -585, 1833, 1687, 44, 2737, 2740, 2716, 2720, - 2723, -2183, -722, 2722, 2733, 2734, 2736, -1904, 1049, 2744, - 2745, 3066, 2751, -585, 1805, 2748, 2749, 3067, 2391, 45, - 1607, 2757, 2754, 2778, 536, 2780, 2795, 2857, 1689, 1229, - 3068, 2753, 2793, 46, 2801, 2794, 2409, 2409, 2802, 1668, - 732, 2803, 2815, 2816, 2830, 2831, 2832, 2855, 2837, 2850, - 1959, 1961, 2854, 2851, 3069, 1050, 3070, 2858, -1904, 2861, - 2865, -1904, 1051, 1042, -585, 1963, 1833, -1904, 1043, 2877, - 2884, 2892, 2895, -585, 26, 27, 28, 2898, 536, 2901, - 2915, 2902, 2916, 2000, 2001, 2002, 2903, 2003, 2004, 2005, - 2006, 2007, 2008, 2918, 1596, 2904, 2929, 2930, 2919, 3565, - 2935, 3567, 2173, 2954, 1052, 3021, 2943, 2951, -1904, 2982, - 2983, 534, 2962, 2961, 2980, 2995, 2520, 26, 27, 28, - 536, 2986, 3003, 1053, 2996, 3001, -2183, 1044, 3007, 3012, - 3013, 3015, 3033, -1904, 3035, 832, 1607, 3575, 3037, 3039, - 3048, 33, 887, -2183, 3054, 3071, 1180, 3055, -2183, 3061, - 3081, 3168, 3169, 536, 3097, 3170, 3178, 3174, 3179, 3194, - 536, 536, 3195, 3200, 3204, 3216, 3217, 2417, 3226, 3221, - 3227, 3252, 3232, 3255, 3259, 3263, 536, 887, 3704, 3577, - 38, 3579, 3273, 3274, 33, 1604, 3277, -2183, 3278, 536, - 2998, 3317, 536, 874, 536, 3303, 1054, 3310, 3313, 3314, - 1045, 1607, 536, 3324, 3335, 536, 536, 3326, 3331, 3336, - 536, 536, 834, 3345, 3665, 40, 3072, 536, 3337, 3343, - 3349, 3073, -1904, 38, 3654, 3353, 43, 3669, -585, 3354, - 3363, 3041, 3355, -1904, 536, 3366, 1046, 3368, 3369, 3344, - 3373, -2148, 3384, 44, 1698, 536, -2149, -2150, 3385, 3024, - -2151, 3387, 1047, -1904, -2152, -1904, -1904, -2153, 40, -2154, - 3649, -2155, 3388, 1048, 3389, 536, -2156, 45, -2157, 43, - -2158, 3074, 3404, -2159, -2161, -2162, 3406, -2163, 2124, 3407, - -2164, 46, 3421, 1604, 1596, -2165, 44, -2166, 3390, 3075, - -2167, 2155, -1904, 2156, 3392, -1904, -1904, -1904, 932, 1049, - -2168, 1199, 933, -2170, -2171, -2172, -2173, -2174, -2175, 732, - 45, -2176, 3149, 732, -2177, 732, 536, 536, -2178, -2179, - -2180, 3044, 2175, -2181, 3022, 3046, 3424, -2182, -1367, 3426, - 3393, 536, 536, 3402, 2354, 3423, 3408, 3430, 3151, 3431, - 2360, 1256, 3434, 3439, 536, 3440, 1050, -2183, 3443, 3445, - 887, 3451, 3454, 1051, 3098, 1607, 3447, 3457, 3453, 3458, - 3459, 1257, 3466, 536, 3219, 3181, 3465, 3462, 3487, 3469, - 3485, 3155, 3156, 3157, 3158, 3486, 3160, 3161, 3162, 3163, - 3164, 3491, 3498, 1908, 3501, 1909, 532, 543, 3503, 1911, - 1912, 2498, 567, 3076, 3515, 1052, 3516, 3525, 567, 3209, - -1366, 3523, 822, 3077, 837, 3531, 3533, 1258, 840, 567, - 849, 887, 3534, 849, 1053, 3547, 869, 869, 536, 3550, - 869, 1607, 3548, 567, 567, 1604, 3562, 2296, 2296, 3563, - 3566, 3569, 3693, 3572, 3578, 3570, 3595, 3584, 536, 536, - 3597, 536, 3607, 3362, 3611, 536, 3613, 3614, 536, 3617, - 3623, 3630, 3631, 3635, 3640, 3632, 822, 822, 3642, -2183, - 3644, 3306, 3647, 3813, 3653, 3651, 1705, 1706, 1707, 1708, - 1709, 1710, 3648, 3652, 3660, 536, 3658, 3662, 3089, 3663, - 3666, 3671, 869, 3682, 3676, 3683, 3684, 1054, 3689, 917, - 869, 567, 869, 869, 869, 536, 3690, 3691, 3709, 1404, - 536, 536, 3728, 2787, 1259, 536, 1607, 3699, 3701, 1404, - 536, 887, 1404, 536, 536, 3731, 3703, 3733, 536, 1337, - 3749, 3752, 536, 3762, 3753, 3729, 536, 3730, 3786, 1676, - 3776, 1604, 1677, 3781, 3790, -1919, 1678, 1679, 536, 3788, - 3795, 1682, 1683, 1684, 3800, 79, 2108, 2112, 3812, 3807, - 2110, 3811, 1256, 2111, 2114, 1260, 934, 3814, 2115, 534, - 1202, 3096, 2822, 2766, 2366, 2776, 1261, 3100, 1687, 3591, - 3028, 1256, 1257, 3697, 3657, 1688, 3787, 3409, 1262, 2511, - 1178, 3376, 2879, 832, 536, 1604, 3680, 3769, 3511, 3727, - 3734, 1257, 536, 3763, 3546, 825, 1822, 1604, 2756, 2783, - 2336, 2337, 1689, 3199, 3725, 3732, 3065, 1596, 3152, 3723, - 1263, 536, 2752, 1945, 3722, 3793, 1079, 3495, 1258, 1991, - 1607, 2871, 2826, 1992, 1993, 2873, 1905, 1604, 1994, 1995, - 1996, 3213, 2739, 3177, 1604, 1494, -1919, 1258, 3087, 3154, - 1495, 1742, 2725, 2316, 3357, 2977, 1785, 2906, 3088, 3702, - 2735, 1524, 1784, 3643, 2284, 3149, 3568, 2315, 826, 2601, - 834, 1789, 2710, 3461, 1461, 1265, 2882, 3262, 2883, 2900, - 2899, 3517, 2888, 2932, 2891, 1445, 3646, 2615, 1604, 3645, - 2661, 1447, 1604, 1451, -1919, 1452, 1453, 1454, 1604, 1455, - 1266, 1456, 2956, 1457, 2685, 2728, 2631, 3484, 2683, -1919, - 1690, 732, 2974, 3316, -1919, 1596, 2662, 2041, 3089, -1919, - 2412, 1268, 1604, 3633, 732, 1259, 3315, 1691, -1919, 3286, - 1006, 1607, 1692, -1919, 2608, 2253, 2840, 1607, 1406, 3413, - 1957, 887, 3029, 552, 1259, 2255, 1496, 536, 536, 2840, - 536, 2619, 2881, 2393, 0, 1693, 1694, 0, 0, 536, - 1607, 1234, 0, 0, 0, -1919, 0, 0, -1414, 0, - 0, 1695, 0, 0, 0, 536, 1260, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -1919, 1261, 0, 0, - 0, 0, 0, 0, 0, 1260, 0, 0, 0, 1262, - 0, 0, 0, 0, 1607, 0, 1261, 553, 0, 1079, - 536, 1696, 1991, 0, 1697, 73, 1992, 1993, 1262, 0, - 3090, 1994, 1995, 1996, 0, 0, 536, 536, 1698, 0, - 536, 1263, 536, 0, 0, 73, 0, -1919, 824, 0, - -1919, 0, 1998, 0, 0, 0, -1919, 0, 0, 0, - 1263, 0, 73, 0, 0, 0, 0, 1596, 0, 0, - 0, 886, 0, 554, 536, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1676, 0, 0, 1677, 0, 0, - 0, 1678, 1679, 555, 0, 0, 1265, -1919, 536, 0, - 0, 0, 824, 824, 903, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1265, 0, 0, 0, 0, - 2702, 1266, -1919, 1687, 0, 1999, 0, 3149, 73, 1676, - -2183, 0, 1677, 1966, 0, 0, 1678, 1679, 0, 0, - 1266, 1700, 1268, 0, 0, 0, 0, 0, 0, 0, - 869, 732, 556, 2731, 2731, 869, 3142, 1689, 3529, -224, - 0, 1268, 3514, 3091, 0, 567, 3092, 0, 1687, 0, - 0, 0, 0, 1596, 0, -2183, 2840, 536, 0, 0, - 1967, 0, 874, 3521, 3522, 0, 536, 0, 536, 0, - 536, 0, 0, 2822, 536, 0, 536, 0, 536, 0, - 0, 1968, 1689, 0, 0, 557, 0, 558, 3535, 0, - 534, -1919, 536, 0, 0, 0, 2451, 536, 536, 1969, - 0, 0, -1919, 2669, 1970, 0, 0, 1596, 3205, 536, - 559, 0, 0, 560, 832, 1998, 0, 23, 0, 1596, - 0, 3588, -1919, 3590, -1919, -1919, 732, 1971, 0, 0, - 1972, 536, 0, 1701, 0, -2183, 1702, 1703, 1704, 0, - 1705, 1706, 1707, 1708, 1709, 1710, 1973, 1604, 2679, 1596, - 0, 3600, -2183, 0, 0, 0, 1596, -2183, 1833, 0, - 0, -1919, 0, 0, -1919, -1919, -1919, 3626, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 536, - -2183, 0, 0, 0, 3629, 0, 0, 0, 1999, 536, - 0, 834, 0, 0, 0, 0, -2183, -2183, 0, 0, - 1596, 536, -2183, 1604, 1596, 0, 0, 0, 0, 0, - 1596, 0, 0, 0, 0, 0, 536, 0, 536, 0, - 0, 0, 0, 2000, 2001, 2002, 0, 2003, 2004, 2005, - 2006, 2007, 2008, 0, 1596, 0, 0, 536, 981, 567, - 567, -2183, 1974, 0, 0, 0, 0, 0, 0, 534, - 1975, 0, 0, 1698, 3312, 0, 0, 0, 0, 0, - 0, 536, 0, 0, 26, 27, 28, 0, 0, 0, - 0, 0, 1976, 832, 0, 0, 536, 0, 0, 0, - 0, 0, 1004, 543, 0, 0, 0, 0, 532, 3149, - 869, 732, 0, 0, 534, 0, 0, 0, 1698, 822, - 0, 0, 1977, 1031, 1031, 0, 822, 0, 0, 1031, - 1058, 0, 0, 0, 536, 0, 3600, 3735, 832, 1604, - 0, 0, 849, 849, 849, 0, 0, 849, 536, 536, - 536, 33, 0, 0, 3710, 1128, 1128, 849, 849, 536, - 849, 0, 849, 3750, 0, 0, 0, 534, 0, 0, - 834, 0, 0, 0, 869, 0, -2183, 0, 0, 0, - 567, 0, 0, 0, 536, 0, 0, 0, 2941, 2942, - 38, 832, 0, 869, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1604, 0, 0, 869, 837, 0, - 0, 0, 0, 0, 0, 834, 0, 0, 0, 0, - 0, -2183, 0, 0, 0, 40, 2000, 2001, 2002, 0, - 2003, 2004, 2005, 2006, 2007, 2008, 43, 0, 0, 3412, - 0, 0, 0, 536, 0, 0, 869, 1342, 0, 0, - 536, 0, 0, 44, 0, 0, 0, 1352, 0, 0, - 23, 869, 869, 869, 869, 869, 0, 0, 834, 0, - 23, 0, 0, 0, 0, 73, 0, 45, 1375, 735, - 0, 0, 0, 0, 0, 0, 0, 0, -2183, 0, - 0, 46, 0, 0, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1031, 1058, 0, 869, 0, 1604, 1468, 0, 0, 0, - 0, 0, 1031, 1031, 0, 0, 0, 0, 0, 567, - 0, 0, 0, -2183, 0, 822, 736, 822, 0, 0, - 1705, 1706, 1707, 1708, 1709, 1710, 822, 1676, 0, 0, - 1677, 0, 737, 0, 1678, 1679, 567, 0, 1604, 0, - 1404, 0, 0, 0, 0, 0, 0, 1676, 0, 0, - 1677, 0, 0, 1611, 1678, 1679, 0, 3482, 0, 1682, - 1683, 1684, 0, 0, 0, 0, 1687, 0, 0, 1596, - 0, 0, 0, -2183, 0, 0, 1685, 0, 1598, 0, - 0, 567, 738, 1599, 0, 3589, 1687, 26, 27, 28, - 0, 0, 739, 1688, 0, 0, 0, 26, 27, 28, - 1689, 0, 0, 0, 1604, 740, 567, 0, 0, 0, - 741, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1689, 0, 0, 0, 0, 1596, 0, 0, 0, 0, - 0, 3142, 0, 0, 0, 0, 0, 0, 1676, 742, - 0, 1677, 0, 0, 0, 1678, 1679, 0, 0, 0, - -2183, -2183, -2183, 0, 33, 0, 0, 0, 0, 1736, - 0, 0, 0, 0, 33, 0, 2987, 0, 0, 0, - 0, 3549, 73, 886, 0, 567, 567, 1687, 0, 0, - 0, 0, 869, 743, 1688, 869, 3269, 0, 744, 1604, - 0, 0, 0, 38, 0, 0, 0, 0, -2183, 0, - 0, 0, 0, 38, 0, 0, 1468, 1128, 1128, 0, - 0, 1689, 0, 0, 1011, -2183, 869, 0, 1690, 1809, - -2183, 869, 1821, 0, 0, 1023, 0, 0, 40, 0, - 0, 0, 1039, 0, 869, 1691, 0, 0, 40, 43, - 1692, 1596, 0, 0, 0, 0, 0, 0, 0, 43, - 0, 869, 0, 0, 555, 869, 44, 0, 0, -2183, - 745, 1873, 0, 1693, 1694, 1601, 44, 0, 1598, 0, - 0, 0, 3619, 1599, 0, 746, 0, 903, 0, 1695, - 45, 0, 0, 0, 0, 14, 15, 0, 0, 0, - 45, 0, 0, 0, 46, 73, 0, 0, 0, 0, - 0, 0, 0, 1604, 46, 0, 1596, 0, 0, 1690, - 747, 0, 0, 748, 0, 0, 1698, 0, 0, 1696, - 0, 0, 1697, 1893, 749, 869, 1691, 750, 0, 0, - 0, 1692, 23, 869, 0, 0, 1698, 1404, 1604, 1699, - 0, 0, 1404, 0, 0, 0, 1938, 751, 0, 0, - 0, 0, 0, 0, 0, 981, 0, 0, 0, 0, - 981, 752, 567, 567, 0, 567, 981, 0, 753, 754, - 1695, 0, 0, 0, 0, 0, 0, 0, 0, 755, - 0, 0, 0, 0, 0, 756, 0, 0, 0, 0, - 0, 1959, 1961, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1604, 0, 0, 0, 73, 0, - 1604, 0, 0, 3142, 757, 0, 0, 1596, 0, -2183, - 0, 0, 0, 0, 0, 0, 0, 1698, 0, 0, - 0, 0, 0, 1604, 0, 0, 0, 0, 0, 1700, - 0, 824, 0, 1023, 0, 1468, 1468, 0, 0, 0, - 0, 1468, 824, 532, 0, 1601, 0, 0, 0, 0, - 1596, 0, 0, 0, 0, 0, 1031, 0, 567, 2034, - 0, 0, 0, 1128, 1128, 0, 869, 1604, 0, 26, - 27, 28, 0, 822, 1042, 822, 0, 1614, 822, 1043, - 0, 0, 0, 822, 0, 1128, 822, 0, 822, 1626, - 0, 0, 822, 0, 567, 0, 567, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1596, 0, 1655, 0, - 1700, -2183, 0, 0, 0, 0, 0, 0, 1705, 1706, - 1707, 1708, 1709, 1710, 0, 0, 33, 0, 1044, 0, - 0, 1701, 0, 0, 1702, 1703, 1704, 35, 1705, 1706, - 1707, 1708, 1709, 1710, 1676, 0, 0, 1677, 0, 0, - 0, 1678, 1679, 0, 0, 0, 0, 0, 0, 0, - 0, 37, 0, 0, 0, 38, 0, 0, 0, 0, - 1604, 1598, 0, 0, 0, 0, 1599, 1676, 0, 0, - 1677, 0, 0, 1687, 1678, 1679, 0, 0, 0, 0, - -2183, 1596, 0, 0, 0, 2148, 903, 903, 0, 903, - 40, 1045, 0, 0, 0, 1959, 1961, 0, 567, 1226, - 0, 43, 0, 0, 0, 1404, 1687, 1689, 0, 0, - 0, 0, 1701, -2183, 0, -2183, -2183, -2183, 44, 1705, - 1706, 1707, 1708, 1709, 1710, 0, 0, 1046, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1602, 981, 0, - 1689, 1468, 45, 1047, 1042, 0, 0, 0, 0, 1043, - 0, 0, 0, 0, 1048, 0, 46, 0, 0, 1598, - 0, 0, 0, 0, 1599, 0, 0, 0, 0, 1128, - 0, 0, 0, 2990, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2251, 0, 869, 0, 869, 0, - 1049, 0, 0, 0, 0, 1596, 0, 0, 0, 869, - 0, 0, 2267, 0, 0, -2183, 2991, 0, 1044, 0, - 0, 1227, 1079, 0, 1468, 1991, 0, 0, 0, 1992, - 1993, 0, -2183, 0, 1994, 1995, 1996, -2183, 0, 0, - 1596, 0, 0, 0, 0, 0, 0, 1050, -2183, 869, - 0, 567, 0, 0, 1051, 0, 0, 0, 1601, 0, - 0, 0, 0, 2318, 2320, -2183, 0, 0, 1603, 2323, - -2183, 0, 1821, 567, 0, 0, -2183, 0, 73, 0, - 0, 0, 0, 0, 567, 2344, 567, 1821, 0, 567, - 0, 1045, 0, 0, 0, 0, 1052, 0, 0, 567, - 0, 567, 0, 0, 0, 0, 1596, 0, 0, -2183, - 0, 1598, 1596, 981, 567, 1053, 1599, 0, 981, 567, - 0, 0, 0, 567, 567, 1821, 567, 1046, 567, 567, - 0, 0, 0, 1698, 0, 1596, 0, 1602, 0, 0, - 868, 0, 0, 1047, 876, 0, 0, 0, 0, 0, - 2413, 0, 1604, 0, 1048, 0, 1601, 0, 1352, 0, - 869, 869, 869, 869, 869, 869, 1698, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1596, - 2441, 0, 0, 0, 0, 0, 0, 0, 1054, 824, - 1049, 824, 0, 1228, 824, 0, 0, 1404, 0, 824, - 0, 2504, 824, 0, 824, 0, 914, 0, 824, 0, - 0, 2059, 0, 0, 919, 0, 922, 1598, 926, 0, - 0, 0, 1599, 0, 0, 1470, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, -2183, 1050, -2183, 0, - 0, 0, 0, 0, 1051, 0, 0, 0, 0, 0, - 0, 1468, 1468, 1468, 1468, 1468, 1468, 0, 1603, 1468, - 1468, 1468, 1468, 1468, 1468, 1468, 1468, 1468, 1468, -2183, - 0, 1598, 0, 0, 0, 0, 1599, 0, 0, 0, - 0, 0, 0, 1598, 0, 0, 1052, 0, 1599, 567, - 0, 0, 1596, 0, 73, 0, 0, 0, 1601, 0, - 0, 0, 0, 869, 0, 1053, 0, 0, 0, 0, - 0, 1999, 0, 1598, 0, 0, 822, 0, 1599, 0, - 1598, 0, 822, 0, 0, 1599, 0, 0, 567, 0, - 0, 0, 0, 0, 567, 0, 0, 0, 0, 0, - 0, 0, 0, 2613, 2613, 0, 0, 0, -2183, 0, - 0, 0, 0, 0, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 0, 0, 0, 1598, 568, 0, 0, 1598, 1599, - 0, 568, 0, 1599, 1598, 823, 0, 2199, 1054, 1599, - 0, -2183, 568, 2060, 0, 0, 0, 0, 1705, 1706, - 1707, 1708, 1709, 1710, 0, 0, 568, 568, 1598, 0, - 0, 0, 0, 1599, 1601, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 567, 0, - 0, 0, 0, 567, 0, 0, 1781, 0, 567, 823, - 823, 0, 0, 0, 0, 1470, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 903, 0, 0, - 0, 0, 1468, 1468, 0, 0, 0, 0, 1601, 0, - 1602, 0, 0, 0, 568, 0, 0, 0, 0, 0, - 1601, 2148, 0, 0, 0, 0, 0, 1468, 0, 0, + -2162, -2162, 1250, 536, 536, 536, 3146, 3184, 536, 2418, + 3185, 2189, 536, -2163, -2163, 536, 536, 536, 536, 536, + 536, 536, 536, 536, -2164, -2164, 536, 2943, 2944, 1204, + 2677, 1835, 1256, 536, 1206, 1337, 1213, 1246, 1232, 534, + 1331, 2678, -2165, -2165, 1867, 2990, 2991, 903, 903, 1235, + 903, 1250, 1257, 536, -2167, -2167, 1237, 825, 2279, 825, + 1238, 2250, 825, 905, 1346, -2168, -2168, 825, 2728, 1245, + 825, 1837, 825, 3517, 959, 1239, 825, 2244, 536, 1068, + 1069, 1070, 3245, 1241, 1073, 2106, 1186, 1240, 3337, 536, + 536, 2275, 1246, 2882, -2169, -2169, 1242, 2324, 1258, 1836, + 3391, 1248, 3392, 2106, 3424, 2606, 3431, 2106, 3443, 2080, + 1254, 3444, 1255, 3527, 1272, 3528, 3145, 557, 2418, 992, + 3565, 3630, 116, 2106, 3145, 1838, 3644, 3674, 3722, 3645, + 3675, 3645, 1607, 1249, 3788, 2319, 2321, 3645, 2173, 1276, + 3823, 1282, 732, 3444, 1340, 560, 732, 960, 884, -2170, + -2170, 1280, 2380, 1343, 2354, 1344, 1248, 1349, 2361, -2171, + -2171, 1354, 1870, 1366, 2360, -2172, -2172, -2173, -2173, 1368, + 1079, 1369, 3095, 1991, -2174, -2174, 1376, 1992, 1993, -2176, + -2176, 1377, 1994, 1995, 1996, 959, 1383, 732, 2381, 1837, + 536, 1386, 552, 1833, 1387, 1259, 1392, 1337, 11, 1963, + 536, 536, 2392, 1410, 1835, -2177, -2177, 1411, 1250, 1487, + 3044, 1079, -2178, -2178, 1991, 1416, 1835, -1420, 1992, 1993, + 2410, 2410, 1474, 1994, 1995, 1996, 14, 15, 1489, 73, + 1246, -2179, -2179, -2180, -2180, 1596, 3125, 1501, 1607, 3138, + 2979, 1497, 2499, 1838, 2498, 1490, 1260, 3162, 3177, 961, + 1509, 2453, 3107, -2181, -2181, 1510, 553, 1261, 960, 3179, + 732, 3564, 1516, 1250, -2183, -2183, -591, 1337, 536, 1262, + -2185, -2185, 1836, 23, -2188, -2188, 536, 1887, 1888, 2298, + 2299, -591, 1517, 3256, 1836, 1523, -591, 1527, 962, 1609, + 2387, 1529, 1607, 1610, 1248, 1612, 536, 536, -903, 536, + 2521, 1263, -722, -722, 1607, 536, 536, 536, 536, 536, + 536, 1833, 2433, 536, 536, 536, 536, 536, 536, 536, + 536, 536, 536, 3754, 3068, 963, 2388, 3756, 536, 536, + 3069, -910, 536, 1621, 1607, 2798, 1950, -591, 1951, 536, + 824, 1607, 824, 3070, -900, 824, 3223, 2802, 1625, 964, + 824, -726, -726, 824, 46, 824, 1265, -747, -591, 824, + 1900, -748, 1837, 536, -725, -725, -901, 3071, 1636, 3072, + 536, -904, 536, 1637, 1837, -902, 536, 1659, 965, 1434, + 1435, 1266, 1438, 1439, 1644, 1607, 1998, 3168, 3169, 1607, + 1669, 536, 1671, 1337, 1716, 1607, 3292, 3293, 1718, 1901, + 1720, 1250, 1268, 1732, 534, 1740, 2728, 3816, 1741, -591, + 534, 3517, 3774, 3777, 2874, 2876, 1838, 1750, -591, 1607, + 26, 27, 28, 1835, 1745, 1596, 1753, 1998, 1838, 3763, + 3764, 536, 536, 3312, 3525, 1216, 1902, 832, 536, 3800, + 3801, 1733, 1734, 832, 557, 73, 992, 2747, 2748, 1218, + 1788, 1792, 1808, 1790, 1810, 1829, 1830, 1840, 3073, 1999, + 1903, 1842, 834, 1847, 1841, 1854, 3333, 3334, 834, 559, + 3564, 536, 560, 1855, 1869, 536, 1859, 887, 1877, 1874, + 536, 536, 23, 3324, 1833, 1891, 1890, 33, 1892, 1904, + 1899, 1836, 1896, 1907, 1906, 1913, 1833, 1404, 35, 1917, + 1999, 1914, 1404, 1243, 1920, 1923, 536, 536, 1657, 1244, + 1921, 536, 1924, 2594, 1925, 3221, 1926, 1256, 3564, 2597, + 3737, 1928, 37, 1929, 1943, 2039, 38, 536, 2199, 3074, + 536, 536, 536, 1942, 3075, 1947, 1955, 1257, 1983, 1980, + 2019, 2057, 3389, 2050, 2063, 2067, 2030, 39, 536, 732, + 2068, 1615, 2078, 1982, 2806, 536, 1985, 1988, 536, 2011, + 2088, 40, 2119, 3580, 2452, 534, 2081, 2020, 2027, 2052, + 2053, 2069, 43, -591, 536, 3564, 2086, 2075, 536, 1622, + 1080, 1837, 2153, 1258, 3076, 23, 2154, 1627, 536, 44, + 552, 2082, 534, 2084, 2085, 2083, 2118, 1677, 903, 2158, + 2162, 2167, 3077, 2168, 2165, 536, 536, 2169, 534, 552, + 825, 2191, 534, 45, 1245, -1420, 825, -591, 2211, 2170, + 2212, 2214, 536, 2238, 536, 832, 2239, 46, 2245, 26, + 27, 28, -591, 2257, -1420, 1838, 2258, -591, 2259, 536, + 2260, 832, 896, 932, 2261, 832, 1199, 933, 2275, 2265, + 834, 2278, 3310, 732, 553, 2288, 2289, 2287, 2292, 2309, + 2290, 2291, 732, 732, 732, 2313, 834, 2314, 2317, 2322, + 834, 2326, 2330, 553, 2354, 2354, 2354, 2000, 2001, 2002, + 1259, 2003, 2004, 2005, 2006, 2007, 2008, 2788, -591, 2332, + 2340, 2358, 2331, 2359, 2364, 2365, 33, 897, 2403, 2415, + 3467, 2401, 2402, 1833, 2435, 2425, 3078, 2436, 536, -591, + 554, 2419, 2437, 2438, 2439, 2440, 3079, 1337, 2000, 2001, + 2002, 2717, 2003, 2004, 2005, 2006, 2007, 2008, 2454, 991, + 555, 1260, 26, 27, 28, 38, 2458, 1959, 1961, 2461, + 2459, 2500, 1261, 2501, 1404, 2503, 2502, 2824, 1596, 1908, + 732, 1862, 2504, 1909, 1262, 1607, 1911, 1912, 2506, 73, + -591, 2510, 2842, 2519, 2016, 1991, 2329, 2527, 2557, -591, + 40, 3022, 2015, 2564, 2565, 1246, 2566, 2343, 2586, 2346, + 2574, 43, 2357, 2570, 2575, 2598, 1263, 2610, 2596, 556, + 2612, 2617, 2366, 2618, 2368, 2619, -224, 2621, 825, 33, + 2627, 2628, 2622, 2641, 2635, 2623, 2636, 2375, 556, 2624, + 2639, 1607, 2378, 2640, 825, 536, 2383, 2384, 825, 2386, + 2642, 2390, 2391, 2643, 2644, 2646, 2645, 23, 2647, 2657, + 1649, 732, 1668, 2653, 2664, 1264, 46, 2672, 38, 1248, + 2665, 1265, 557, 1963, 558, 2667, 1596, 2679, 2688, 2689, + 2694, 2884, 1256, 2885, 3569, 2695, 3571, 2890, 2696, 2893, + 2173, 557, 2712, 992, 2707, 2714, 1266, 559, 2715, 536, + 560, 1267, 1257, 40, 1604, 2721, 3579, 552, 2737, -728, + 2724, 2735, 2741, 2734, 43, 2738, 559, 1268, 2723, 560, + 2745, 2746, 1805, 824, 2752, 2749, 2750, 2755, 2758, 824, + 2754, 44, 2779, 534, 2790, 2781, 2795, 2797, 2833, 2796, + -1908, 536, 2803, 2817, 2804, 2805, 2818, 3581, 1258, 3583, + 1959, 1961, 2832, 2834, -591, 45, 2839, 1607, 2852, 2853, + 2856, 2857, 2860, 887, 1180, 1079, 832, 2867, 1991, 46, + 2879, 553, 1992, 1993, 536, 2886, 1250, -2189, -2189, -2189, + 2894, 536, 536, 2863, 2897, 1833, 2900, 2917, 2903, 2918, + 2904, 834, 3023, 2905, 2906, 2920, 2921, 536, 887, 2931, + 2932, 2956, 3715, 2937, 26, 27, 28, 2945, 2953, 2984, + 536, 1730, 2963, 536, 3672, 536, 2997, 2964, 1596, 3091, + 3003, 2982, 1607, 536, 932, 1598, 536, 536, 933, 2985, + 3014, 536, 536, 3041, 3037, 2998, 2133, 2988, 536, 3661, + 3676, -1908, 3000, 2134, 2135, 1259, 3005, 555, 2136, 2137, + 2138, 3009, 3043, 3015, 3017, 536, 3035, 3050, 3039, 3056, + 3057, 3063, 3083, 3122, 1655, 3123, 536, 3124, 3149, 3099, + 3128, 33, 3132, 3133, 3026, 3148, 3154, 3158, 3170, 3656, + 3171, 2418, 3180, 3181, 2199, 3186, 536, 3206, 3209, -1908, + 3175, 3213, 3217, 3227, 1604, 3228, 1260, 3231, 3232, 3257, + 2690, 3264, 3267, 3268, -1908, 3271, 1346, 1261, 3278, -1908, + 38, 824, 1404, -224, -1908, 3289, 3280, 3285, 3290, 1262, + 3303, 3697, 3698, -1908, 1596, 3291, 3297, 824, -1908, 3299, + 732, 824, 3298, 536, 536, 732, 3307, 732, 536, 536, + 3308, 3320, 2354, 3317, 3322, 40, 3323, 3105, 3327, 2361, + 3309, 1263, 3335, 536, 536, 2360, 43, 3336, 3338, 557, + -1908, 558, 3339, 3340, 3341, 3355, 536, 3343, 3357, 3344, + 3353, 3358, 887, 44, 3375, 3359, 3380, 1607, 1596, 3393, + 3377, -1908, 3384, 3388, 3378, 536, 3173, 560, 3385, 2824, + 1596, 3135, 3394, 3405, 1908, 3411, 3413, 45, 1909, 3397, + 3399, 1911, 1912, 3408, 3416, 3401, 1265, 3407, 3412, 1079, + 3419, 3024, 1991, 2499, 3420, 1598, 1992, 1993, 3423, 3441, + 1596, 1994, 1995, 1996, 3159, 3163, 3439, 1596, 3440, 3445, + 3452, 1266, -1908, 887, 3455, -1908, 3457, 3469, 3470, 1950, + 536, -1908, 3524, 1607, 3526, 3532, 3534, 3551, 3535, 3548, + 3549, 3552, 1268, 3554, 1999, 3704, 3573, 3566, 3567, 3576, + 536, 536, 3588, 536, 3570, 3574, 3599, 536, 3582, 3601, + 536, 1596, 532, 543, 3611, 1596, 3316, 3615, 567, 3617, + -2154, 1596, -1908, -2155, 567, 3637, 3618, 3642, 822, -2156, + 837, -2157, -2158, -2159, 840, 567, 849, 536, -2160, 849, + -2161, -2162, 869, 869, -2163, 1596, 869, -1908, 3638, 567, + 567, 3830, -2164, 1599, 3628, 3634, 23, 536, -2165, -2167, + -2168, 2864, 536, 536, -2169, 2727, -2170, 536, 1607, -2171, + -2172, 3635, 536, 887, -2173, 536, 536, -2174, -2176, -2177, + 536, 1337, 822, 822, 536, -2178, 3639, -2179, 536, 3647, + -2180, -2181, -2182, -2183, -2184, -2185, -2186, -2187, -2188, -1373, + 536, 23, 3649, 3651, 3260, 3654, 3655, 874, 869, 3658, + 3266, 3659, 2108, 2112, 3660, 917, 869, 567, 869, 869, + 869, 934, 534, 2110, 79, 2115, 3665, 3667, 2111, 2114, + 3669, 3670, 3673, 3678, -1372, 3683, -1908, 3691, 1042, 3693, + 3700, 3701, 1997, 1043, 3720, 3739, 536, -1908, 3702, 3742, + 3747, 3710, 3712, 3744, 536, 832, 3714, 1604, 3750, 3769, + 3751, 3765, 3778, 3740, 3768, 1998, 3741, -1908, 3786, -1908, + -1908, 3793, 3798, 536, 2859, 3812, 3803, 3805, 3807, 3817, + 834, 3828, 1607, 3824, 3829, 3098, 3831, 1202, 2767, 2367, + 2777, 3593, 3102, 3595, 3030, 3708, 3664, 3804, 3360, 2512, + 3330, 2881, 1044, 26, 27, 28, -1908, 3735, 3687, -1908, + -1908, -1908, -2189, -2189, -2189, 732, 2003, 2004, 2005, 2006, + 2007, 2008, 3785, 3465, 3738, 3745, 1178, 2842, 732, 3779, + 3547, 1496, 2757, 2784, 1822, 1607, 2336, 2337, 1999, 3153, + 2842, 1607, 3736, 1599, 3106, 887, 3067, 3364, 26, 27, + 28, 536, 536, 3743, 536, 1604, 2753, 3734, 1945, 3733, + 1655, 3810, 3449, 536, 1607, 2873, 3167, 2875, 1905, 2740, + 33, 2828, 3131, 1742, 1494, 1045, 2726, 2316, 1598, 536, + 3108, 1785, 1784, 2139, 2140, 2141, 1495, 2142, 2143, 2144, + 2145, 2146, 2147, 3713, 2908, 1655, 2736, 2284, 3650, 3572, + 2315, 826, 1789, 2711, 2602, 1524, 3216, 3415, 1607, 38, + 1461, 1046, 2934, 2902, 536, 33, 2901, 3471, 3653, 2616, + 3652, 2958, 73, 2662, 1445, 1447, 1451, 1047, 825, 1452, + 536, 536, 1453, 1454, 536, 1455, 536, 1456, 1048, 2729, + 2686, 3438, 1457, 2632, 40, 2684, 2663, 2976, 2041, 3042, + 3270, 3240, 3640, 3269, 38, 43, 1006, 2413, 1957, 2609, + 1234, 2253, 3031, 2255, 1406, 3436, 2883, 2394, 536, 0, + 0, 0, 44, 0, 1049, 0, 1598, 1676, 1470, 0, + 1677, 1596, 0, 0, 1678, 1679, 0, 0, 0, 40, + 0, 0, 536, 0, 0, 2059, 45, 1604, 0, 0, + 43, 0, 0, 0, 0, 1676, 0, 0, 1677, 0, + 46, 0, 1678, 1679, 0, 0, 1687, 44, 3520, 0, + 0, 1050, 0, -2189, 0, 0, 0, 0, 1051, 0, + 0, 0, 0, 0, 0, 0, 3513, 1596, 0, 73, + 0, 45, 732, 0, 1687, 0, 0, 0, 0, 0, + 1689, -2189, 0, 3530, 2842, 46, 2000, 2001, 2002, 0, + 2003, 2004, 2005, 2006, 2007, 2008, 0, 0, 3046, 886, + 1052, 536, 3048, 73, 0, 0, 0, 0, 1689, 3553, + 536, 0, 536, 3172, 536, 0, 0, 1966, 536, 1053, + 536, 0, 536, 0, 0, 0, 0, 0, 0, 0, + 0, 3100, 0, 1604, 0, 534, 536, 0, 0, 0, + 0, 536, 536, 0, 0, 0, 2670, 0, 1598, 3109, + 3110, 3111, 3112, 536, 3114, 3115, 3116, 3117, 3118, 0, + 1655, 0, 0, 0, 1967, 0, 0, 0, 832, 3592, + 732, 3594, 0, 0, 2680, 536, 0, 0, -2189, 0, + 0, 0, 3604, 1596, 0, 1968, 869, 1604, 0, 0, + 0, 869, 1054, 834, 0, -2189, 1599, 2060, 0, 1604, + -2189, 567, 0, 1969, 0, 0, -2189, 0, 1970, 1781, + 0, 0, 0, 0, 0, 0, 3520, 0, 1470, 0, + 0, 0, 0, -2189, 0, 0, 0, 0, -2189, 1604, + 0, 1971, 0, 0, 1972, 0, 1604, 0, 0, -2189, + 0, 824, 0, 0, 0, 0, 0, 0, 1596, 0, + 1973, 73, 0, 0, 1598, 0, 0, 3624, 0, 0, + 886, 0, 3631, 0, 0, 0, 0, -2189, 0, 0, + 0, 0, 1042, 536, 0, 0, 0, 1043, 0, 0, + 1604, 0, 3636, 536, 1604, 0, 0, 0, 0, 0, + 1604, 0, 0, 0, 1599, 536, 1698, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3363, 0, 1598, 0, + 536, 0, 536, 1601, 1604, 0, 0, 0, 0, 0, + 1598, 0, 0, 0, 1698, 0, 0, 23, 0, 0, + 0, 536, 0, 0, 0, 0, 1044, 0, 0, 0, + 0, 0, 0, 0, 534, 0, 1974, 536, 536, 0, + 1598, 0, 1256, 0, 1975, 0, 0, 1598, 536, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1257, 536, 0, 0, 1976, 832, 0, 0, + 0, 0, 0, 0, 0, 73, 3520, 0, 732, 0, + 0, 0, 534, 0, 981, 567, 567, 0, 0, -2189, + 3604, 1598, 834, 1596, 3513, 1598, 1977, 0, 0, 1045, + 0, 1598, 0, 0, 0, 536, 0, 0, 1258, 3748, + 0, 0, 3311, 0, 0, 832, 0, -2189, 0, 536, + 536, 536, 1655, 0, 0, 1598, 1599, 0, 1004, 543, + 536, 0, 0, 0, 532, 1046, 869, 0, 3766, 534, + 834, 0, 0, 0, 0, 822, 0, 1470, 1470, 1031, + 1031, 1047, 822, 1470, 0, 1031, 1058, 0, 0, 1596, + 536, 0, 1048, 0, 26, 27, 28, 0, 849, 849, + 849, 0, 832, 849, 0, 0, 0, 0, 0, 0, + 0, 1128, 1128, 849, 849, 0, 849, 0, 849, 0, + 0, 0, 0, 1601, 0, 0, 0, 834, 1049, 0, + 869, -2189, 0, 0, 0, 1259, 567, 0, 1705, 1706, + 1707, 1708, 1709, 1710, 0, 0, 0, 0, 0, 869, + 536, 0, 0, 0, 0, 0, 0, 536, 0, -2189, + 0, 33, 1599, 869, 837, 0, 1705, 1706, 1707, 1708, + 1709, 1710, 0, 0, 1596, 1050, 0, 0, 0, 0, + 0, 0, 1051, 1602, 0, 0, 1260, 0, 0, 0, + 0, 1676, 0, 0, 1677, 0, 0, 1261, 1678, 1679, + 38, 0, 869, 1342, 0, 0, 0, 0, 0, 1262, + 0, 73, 0, 1352, 0, 0, 1599, 869, 869, 869, + 869, 869, 0, 0, 1052, 0, 0, 0, 1599, 0, + 1687, 0, 0, 0, 1375, 40, 0, -2189, 0, 0, + 3558, 1263, 0, 1053, 0, 0, 43, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1599, 0, + 0, 0, 0, 44, 1689, 1599, 1031, 1058, 0, 869, + 1604, 0, 1468, 0, 0, 0, 0, 0, 1031, 1031, + 0, 0, 1603, 0, 0, 567, 0, 45, 1596, 0, + 0, 822, 3468, 822, 0, 0, 1265, 73, 0, 73, + 0, 46, 822, 0, 0, 0, 0, 0, 0, 1599, + 3522, 3523, 567, 1599, 0, 0, 1054, 0, 0, 1599, + 0, 1266, 0, 0, 0, 0, 1604, 0, 0, 1611, + 2989, 0, 0, 0, 0, 3536, 0, 0, 0, 0, + 0, 1596, 1268, 1599, 0, 0, 0, 1596, 0, 0, + 0, 0, -1910, 0, 0, 0, 0, 567, 0, 0, + 0, 0, -2189, 0, 0, 0, 1042, 0, 0, 0, + 1596, 1043, 0, 1602, 0, 0, 2286, 0, 0, -2189, + 0, 0, 567, 0, -2189, 0, 0, 0, 0, 0, + 73, 1598, 0, 0, 1676, 0, 0, 1677, 0, 0, + 0, 1678, 1679, 0, 0, 0, -2189, -2189, -2189, 0, + 73, 0, 0, 0, 1596, 0, 0, 0, 0, 0, + 0, 0, 0, -2189, 0, 0, 0, 0, 0, 0, + 1044, 0, 0, 1687, 0, 1736, 0, 0, 0, 0, + 1688, 0, 1604, 0, 0, 0, 1601, 1598, 0, 0, + 0, 567, 567, -1910, 0, 0, 0, 0, 869, 0, + 0, 869, 0, 0, 0, 0, 0, 1689, 0, 0, + 0, 0, 1603, 0, 0, 0, 0, 0, 0, 0, + 1698, 0, 1468, 1128, 1128, 0, 0, 0, 0, 0, + 0, 0, 869, 0, 0, 1809, 0, 869, 1821, 0, + 0, -1910, 0, 1045, 0, 0, 0, 1604, 0, 0, + 869, 0, 0, 0, 0, 0, -1910, 0, 0, 0, + 0, -1910, 0, 0, 1596, 0, -1910, 869, 0, 0, + 0, 869, 0, 0, 0, -1910, 0, 1873, 0, 1046, + -1910, 0, 0, 0, 1601, 0, 0, 73, 0, 0, + 0, 0, 0, 0, 0, 1047, 0, 0, 0, 0, + 0, 0, 0, 1598, 0, 1690, 1048, 0, 0, 0, + 0, 0, -1910, 0, 0, 0, 73, 0, 0, 0, + 0, 0, 1691, -2189, 0, 0, 0, 1692, 0, 0, + 0, 0, 0, -1910, 0, 0, 0, 0, 0, 1893, + 0, 869, 1049, 1470, 1470, 1470, 1470, 1470, 1470, 869, + 0, 1470, 1470, 1470, 1470, 1470, 1470, 1470, 1470, 1470, + 1470, 0, 1938, 1229, 0, 0, 1695, 0, 1598, 0, + 0, 981, 0, 0, 0, 0, 981, 3721, 567, 567, + 0, 567, 981, 0, -1910, 0, 0, -1910, 0, 1050, + 0, 0, 0, -1910, 0, 0, 1051, 0, 0, 0, + 0, 0, 1604, 0, 0, 868, 0, 0, 0, 876, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1599, + 0, 0, 0, 1698, 0, 0, 1601, 0, 0, 0, + 0, 0, 1596, 0, -1910, -2189, 1602, 0, 1052, 0, + 0, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1053, 0, -1910, + 0, 1468, 1468, 0, 0, 0, 0, 1468, 1604, 532, + 0, 914, 0, 0, 0, 1599, 0, 0, 0, 919, + 0, 922, 1031, 926, 567, 2034, 0, 0, 0, 1128, + 1128, 0, 869, 0, 0, 0, 0, 0, 0, 822, + 0, 822, 0, 0, 822, 0, 0, 0, 0, 822, + 0, 1128, 822, 0, 822, 0, 0, 0, 822, 874, + 567, 0, 567, 1598, 0, 0, 1700, 0, 0, 0, + 1054, 0, 1601, 0, 1602, 1603, 0, 0, 0, 0, + 568, 0, 0, 0, 1470, 1470, 568, 0, -1910, 0, + 823, 0, 0, 1604, 0, 0, 0, 568, 0, -1910, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1601, 0, 0, 0, 822, 0, 0, 1601, 0, 0, - 0, 0, 0, 0, 0, 0, 567, 0, 0, 0, - 822, 0, 0, 0, 822, 2267, 0, 0, 0, 2000, - 2001, 2002, 0, 2003, 2004, 2005, 2006, 2007, 2008, 0, + 0, 568, 568, 0, 0, 0, 0, 0, 0, -1910, + 0, -1910, -1910, 0, 0, 0, 1601, 0, 0, 1598, + 0, 1599, 0, 0, 0, 0, 0, 0, 1601, 0, + 0, 0, 1596, 0, 823, 823, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, -1910, 0, + 0, -1910, -1910, -1910, 0, 0, 0, 0, 1601, 0, + 0, 2148, 0, 1603, 0, 1601, 0, 0, 1701, 568, + 0, -2189, -2189, -2189, 567, 1705, 1706, 1707, 1708, 1709, + 1710, 0, 0, 0, 0, 0, 1599, 0, 0, 0, + 1470, 0, 0, 0, 0, 0, 0, 1604, 0, 0, + 0, 0, 0, 0, 1598, 0, 1602, 0, 0, 1601, + 0, 0, 0, 1601, 981, 0, 0, 1468, 0, 1601, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1601, 0, 0, 0, 1601, 0, 0, 1602, 0, - 0, 1601, 0, 0, 0, 567, 0, 0, 1468, 0, - 1128, 567, 0, 0, 1596, 0, 0, 0, 0, 0, - 0, 1603, 0, 0, 0, 1601, 0, 1079, 0, 0, - 1991, 0, 0, 1893, 1992, 1993, 0, 0, 0, 1994, - 1995, 1996, 0, 0, 0, 0, 0, 1079, 73, 0, - 1991, 0, 0, 0, 1992, 1993, 2978, 0, 0, 1994, - 1995, 1996, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 3293, 1079, 0, 0, - 1991, 0, 0, 0, 1992, 1993, 0, 0, 0, 1994, - 1995, 1996, 0, 0, 950, 0, 0, 0, 0, 957, - 0, 0, 0, 0, 0, 0, 3294, 0, 0, 0, - 0, 0, 0, 0, 1470, 1470, 1893, 0, 0, 1603, - 1470, 0, 0, 869, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1352, 0, 0, 1893, 869, 869, 869, - 1602, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 567, 0, 869, 0, 0, 0, 869, 0, 0, 869, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1598, 0, 0, 0, 0, 1599, 0, - 0, 0, 824, 0, 0, 0, 0, 0, 824, 0, + 0, 0, 0, 1601, 0, 1128, 0, 0, 0, 0, + 1604, 0, 0, 0, 0, 0, 1604, 0, 0, 0, + 2251, 0, 869, 0, 869, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 869, 0, 0, 2267, 1604, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 869, 0, 0, 0, 0, 0, 981, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1893, 1893, 0, 1893, 0, 0, 0, 1598, - 1676, 0, 0, 1677, 1599, 0, 0, 1678, 1679, 0, - 0, 0, 0, 1998, 0, 0, 1602, 0, 0, 0, - 0, 0, 0, 0, 532, 0, 0, 0, 0, 0, - 0, 1603, 1471, 1998, 0, 0, 0, 0, 0, 1687, - 0, 0, 2905, 0, 0, 0, -2183, 0, 0, 0, - 869, 869, 869, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1998, 567, 0, 1468, 0, 567, 0, - 1602, 0, 0, 1689, 567, 0, 0, 0, 0, 0, - 0, 0, 1602, 0, 0, 0, 1999, 0, 0, 0, - 0, 0, 0, 1655, 869, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1999, 0, 0, 2148, - 0, 0, 1602, 2199, 0, 1598, 0, 0, 0, 1602, - 1599, 567, 0, 0, 1015, 567, 0, 0, 568, 2689, - 1601, 0, 0, 0, 0, 0, 1999, 1603, 0, 3297, - 824, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1468, 1468, 0, 0, 0, 824, 0, 0, 0, - 824, 0, 0, 1602, 0, 0, 0, 1602, 0, 0, - 0, -2183, 0, 1602, 0, 3008, 0, 0, 0, 0, - 1598, 0, 3017, 2286, 0, 1599, 1601, 0, -2183, 2267, - 0, 1603, 0, -2183, 0, 0, 0, 1602, 0, 0, - 0, 0, 0, 1603, 0, 869, 0, 0, 0, 567, - 0, 1128, 0, 567, 567, 0, 0, 3045, 567, 0, - 0, 1233, 1893, 1821, 1893, 0, 1938, 0, 0, 0, - 0, 0, -2183, 1603, 0, 0, 0, 0, 0, 0, - 1603, 0, 1471, 0, 0, 0, 0, 567, 0, 1821, + 1468, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1603, 0, 0, 0, 0, + 0, 0, 1602, 0, 0, 869, 0, 567, 1598, 0, + 0, 0, 0, 1604, 0, 0, 0, 0, 0, 2318, + 2320, 0, 0, 0, 0, 2323, 0, 0, 1821, 567, + 0, 1599, 0, 0, 0, 0, 0, 0, 0, 0, + 567, 2344, 567, 1821, 0, 567, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 567, 1602, 567, 0, 0, + 0, 1598, 0, 0, 0, 0, 0, 1598, 1602, 981, + 567, 0, 0, 0, 981, 567, 0, 0, 0, 567, + 567, 1821, 567, 0, 567, 567, 0, 0, 0, 0, + 1598, 0, 1676, 0, 0, 1677, 0, 1599, 1602, 1678, + 1679, 1603, 0, 0, 0, 1602, 2414, 0, 0, 0, + 0, 0, 0, 0, 1352, 0, 869, 869, 869, 869, + 869, 869, 0, 1604, 0, 0, 0, 0, 0, 0, + 0, 1687, 0, 0, 1598, 0, 2442, 0, -2189, 950, + 0, 0, 0, 0, 957, 0, 0, 0, 0, 1602, + 0, 0, 0, 1602, 0, 1603, 0, 2505, 0, 1602, + 0, 0, 0, 0, 0, 1689, 0, 1603, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1341, 0, 0, 0, 567, 567, 567, 567, 1821, 567, - 567, 567, 567, 567, 0, 1356, 1358, 1361, 1363, 1365, - 0, 0, 0, 0, 1603, 0, 0, 0, 1603, 1698, - 0, 1598, 0, 0, 1603, 0, 1599, 0, 0, 2441, - 0, 0, 1601, 0, 2000, 2001, 2002, 869, 2003, 2004, - 2005, 2006, 2007, 2008, 0, 0, 0, 0, 1603, 0, - 3198, 0, 568, 568, 2000, 2001, 2002, 1463, 2003, 2004, - 2005, 2006, 2007, 2008, 1598, 0, 0, 0, 0, 1599, - 0, 0, 0, 0, 0, 0, 1938, 0, 0, 2862, - 0, 0, 0, 1893, 2000, 2001, 2002, 0, 2003, 2004, - 2005, 2006, 2007, 2008, 1468, 0, 0, 1601, 0, 0, - 567, 0, 0, 0, 0, 0, 0, 869, 869, 869, - 869, 0, 823, 0, 0, 0, 0, 0, 0, 0, - 0, 1468, -2183, 0, 1468, 0, 0, 0, 567, 981, - 1598, 0, 0, 0, 0, 1599, 0, 3271, 0, 0, - 1470, 1470, 1470, 1470, 1470, 1470, 0, 0, 1470, 1470, - 1470, 1470, 1470, 1470, 1470, 1470, 1470, 1470, 0, 0, - 567, 0, 0, 0, 0, 0, 0, 3279, 567, 0, + 0, 0, 1599, 1602, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1603, 0, 0, + 0, 0, 0, 0, 1603, 0, 0, 1468, 1468, 1468, + 1468, 1468, 1468, 0, 0, 1468, 1468, 1468, 1468, 1468, + 1468, 1468, 1468, 1468, 1468, 0, 0, 0, 0, 0, + 0, 2992, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1598, 567, 0, 0, 1603, 0, + 0, 0, 1603, 0, 1470, 1470, 0, 0, 1603, 869, + 0, 0, 0, -2189, 0, 0, 0, 0, 0, 1601, + 0, 0, 822, 0, 0, 0, 0, 0, 822, -1925, + -2189, 0, 1603, 0, 567, -2189, 0, 0, 0, 0, + 567, 1604, 0, 0, 0, 0, 1599, 0, 0, 2614, + 2614, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 568, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1417, 0, - 836, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3307, 0, 822, 0, 0, 0, 0, 0, 1601, 0, - 0, 1471, 1471, 0, 1128, 1598, 0, 1471, 0, 0, - 1599, 3321, 0, 0, 0, 0, 2267, 0, 0, 0, - 0, 0, 2148, 0, -2183, 0, 0, 0, 0, 0, - 0, 1705, 1706, 1707, 1708, 1709, 1710, 1821, 0, 0, - 0, 1601, 0, 1893, 1418, 1419, 0, 0, 0, 0, - 0, 0, 1602, 0, 0, 0, 981, 567, 1468, 0, - 0, 0, 0, 0, 869, 0, 0, 0, 1655, 0, - 1807, 0, 0, 0, 0, 1811, 0, 0, 0, 0, - 0, 3377, 0, 0, 0, 1420, 1421, 0, 1843, 1422, - 1423, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1655, 0, 0, 0, 1601, 1602, 1868, - 0, 0, 1488, 0, 0, 0, 0, 0, 823, 1598, - 823, 0, 0, 0, 1599, 0, 0, 0, 0, 823, - 73, 1470, 1470, 0, 0, 0, 0, 0, 0, 1526, + 0, 0, 0, 1676, -2189, 1601, 1677, 0, 0, 0, + 1678, 1679, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1599, + 0, 0, 0, 0, 0, 1599, 0, 0, 0, 0, + 0, 0, 1687, 0, 0, 0, 0, 0, 0, -2189, + 0, 0, 0, 0, 567, 0, 0, 0, 1599, 567, + -1925, 1698, 0, 0, 567, 0, 0, 0, 0, 0, + 1676, 0, 0, 1677, 0, 0, 1689, 1678, 1679, 1015, + 0, 0, 0, 0, 0, 0, 0, 0, 1468, 1468, + 0, 0, 1598, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1599, 0, 0, 0, 0, 2148, -1925, 1687, + 0, 0, 0, 1468, 0, 0, -2189, 0, 0, 0, + 0, 1601, 0, -1925, 0, 0, 0, 0, -1925, 0, + 0, 0, 0, -1925, 0, 0, 0, 0, 0, 0, + 822, 1604, -1925, 1689, 0, 0, 0, -1925, 1470, 0, + 0, 0, 567, 0, 0, 0, 822, 0, 0, 0, + 822, 2267, 0, 0, -2189, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -2189, 3210, 1233, 0, 0, -1925, + 0, 0, 0, 0, 0, 0, 1601, 568, 568, 0, + 0, -2189, 0, 0, 0, 0, -2189, 0, 0, 1602, + -1925, 567, 0, 0, 1468, 0, 1128, 567, 0, 2993, + 0, 0, 1599, 0, 0, 1341, 0, 0, 0, 0, + 0, 0, 1471, 0, 0, 3239, 0, 0, 0, 1893, + 1356, 1358, 1361, 1363, 1365, -2189, 0, 0, 0, 0, + 0, -2189, 0, 0, 0, 0, 0, 823, 0, 0, + 0, -1925, 0, 0, -1925, 1602, 0, 0, -2189, 0, + -1925, 0, 1598, -2189, 0, 0, 0, 0, 0, 0, + 0, 1676, 0, 0, 1677, 0, -2189, 0, 1678, 1679, + 0, 0, 1463, 1705, 1706, 1707, 1708, 1709, 1710, 0, + 0, 0, 1698, 0, 0, 0, 0, 0, 1603, 0, + 0, -1925, -2189, 0, 0, 0, 0, 0, 568, 0, + 1687, 0, 0, 1893, 0, 0, 0, -2189, 0, 0, + 869, 0, 1470, 0, 0, 0, -1925, 0, 0, 0, + 1352, 0, 0, 1893, 869, 869, 869, 0, 0, 0, + 0, 1601, 0, 0, 1689, 0, 0, 567, 0, 869, + 0, 0, 0, 869, 1603, 0, 869, 0, 0, 1698, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1598, 0, 0, 3040, 0, 1599, - 0, 0, 0, 3394, 0, 0, 1424, 1425, 1893, 0, - 0, 0, 0, 1603, 0, 0, 0, 0, 0, 1898, - 0, 0, 0, 2441, 568, 0, 0, 1916, 0, 0, - 0, 0, 1601, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1660, - 3432, 0, 0, 0, 0, 1468, 0, 0, 0, 0, - 1598, 0, 0, 0, 1602, 1599, 1598, 0, 0, 1603, - 0, 1599, 0, 1426, 1427, 1428, 1429, 1430, 1431, 1432, - 1433, 3448, 0, 1434, 1435, 0, 73, 1470, 567, 1598, - 0, 0, 0, 2243, 1599, 567, 0, 0, 0, 0, + 0, 1602, 0, 0, 0, 0, 0, 0, 0, 0, + 1599, 0, 0, 0, 0, 0, 874, 0, 0, 0, + 0, 0, 0, 0, 0, -2189, 0, 0, 0, 869, + 0, 0, 0, 0, 0, 981, 0, 1601, 0, 0, + 3251, 0, 0, 0, 0, -1925, 0, 0, 0, 1893, + 1893, 0, 1893, 0, 0, 0, -1925, 0, 0, 0, + 0, 1470, 1471, 0, 0, 0, 1602, 0, 0, 0, + 0, 0, -2189, 0, 0, 0, -1925, 0, -1925, -1925, + 0, 532, 0, 0, 0, 0, 0, 1488, 0, -2189, + 0, 0, -2189, 823, -2189, 823, 0, 0, 0, 2907, + 1603, 0, 0, 0, 823, 0, 0, 869, 869, 869, + 0, 0, 0, 0, 1526, -1925, 0, 0, -1925, -1925, + -1925, 567, 1601, 1468, 0, 567, 0, 0, 0, 0, + 0, 567, 0, -2189, 0, 1807, 0, -2189, 0, 0, + 1811, 0, 0, 0, 1705, 1706, 1707, 1708, 1709, 1710, + 0, 869, 0, 1843, 0, 0, 0, 0, 0, 568, + 0, 0, 0, 0, 0, 1603, 2148, 0, 0, 0, + 0, 0, 0, 0, 1868, 0, 0, 0, 567, 0, + 1599, 0, 567, 0, 1660, 0, 0, 0, 0, 0, + 1698, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -2189, 0, 0, 0, 1468, 1468, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, + 0, 1602, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3010, 0, 0, 1079, 1601, 0, 1991, 3019, + 0, 0, 1992, 1993, 1898, 0, 2267, 1994, 1995, 1996, + 0, 0, 1916, 568, 568, 0, 0, 0, 0, 0, + 0, 0, 869, 0, 2980, 0, 567, 0, 1128, 0, + 567, 567, 0, 0, 3047, 567, 0, 0, 0, 1893, + 1821, 1893, 0, 1938, 0, 0, 0, 1602, 3578, 1601, + 0, 0, 0, -2189, 0, 1601, 0, 0, 0, 0, + 0, 1471, 1471, 0, 567, 0, 1821, 1471, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1601, 0, + 1603, 0, 567, 567, 567, 567, 1821, 567, 567, 567, + 567, 567, 0, 0, 0, 0, 0, 0, 0, 1079, + 0, 0, 1991, 0, 0, 0, 1992, 1993, 0, 0, + 0, 1994, 1995, 1996, 0, 0, 0, 2442, 0, 0, + 0, 0, 1601, 0, 0, 869, 0, 0, 0, 0, + 0, 0, 1602, 0, 0, 0, 0, 0, 3152, 0, + 0, 0, 0, 0, 0, 0, 1603, 0, 0, 0, + 0, 0, 0, 0, 0, 2048, 0, 0, 0, 0, + 0, 0, 0, 0, 1938, -2189, 0, 0, 0, 0, + 0, 1893, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, + 0, 0, 1468, 0, 0, 0, 0, 0, 567, 0, + 0, 0, 0, 0, 0, 869, 869, 869, 869, 0, + 568, 568, 0, 568, 0, 0, 0, 0, 0, 1468, + 0, 1998, 1468, 0, 0, 0, 567, 981, 0, 0, + 0, 0, 0, 0, 0, 3225, 0, 0, 0, 0, + 1079, 1603, 1601, 1991, 0, 0, 0, 1992, 1993, 0, + 0, 0, 1994, 1995, 1996, 0, 1602, 0, 567, 0, + 0, 0, 0, 0, 0, 3233, 567, 0, 0, 3247, + 1079, 0, 0, 1991, 0, 0, 0, 1992, 1993, 0, + 0, 0, 1994, 1995, 1996, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1999, 0, 0, 0, 3261, 3248, + 822, 0, 2312, 0, 0, 0, 0, 0, 0, 1602, + 0, 0, 1128, 0, 1256, 1602, 568, 0, 0, 3275, + 0, 0, 0, 2243, 2267, 1998, 0, 0, 0, 0, + 2148, 823, 0, 823, 1257, 0, 823, 0, 1602, 0, + 0, 823, 0, 0, 823, 1821, 823, 0, 0, 0, + 823, 1893, 2072, 0, 2076, 1603, 0, 0, 0, 0, + 0, 0, 0, 0, 981, 567, 1468, 0, 0, 0, + 1471, 0, 869, 0, 0, 0, 0, 0, 0, 0, + 1258, 3089, 1602, 0, 0, 0, 0, 0, 0, 3331, + 0, 3090, 0, 0, 0, 0, 0, 0, 1999, 0, + 0, 0, 0, 0, 0, 2252, 0, 2254, 1603, 0, + 1601, 0, 0, 0, 1603, 0, 0, 0, 2263, 1079, + 0, 0, 1991, 3345, 0, 0, 1992, 1993, 1893, 0, + 0, 1994, 1995, 1996, 0, 0, 0, 1603, 0, 0, + 0, 0, 0, 2442, 0, 0, 0, 0, 0, 0, + 0, 3091, 0, 0, 0, 0, 1998, 0, 2301, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3467, 0, 0, 0, 886, 0, 568, 568, - 73, 0, 0, 0, 0, 0, 0, 0, 0, 1602, - 3218, 0, 0, 1598, 0, 3479, 0, 0, 1599, 0, - 1471, 0, 0, 3008, 0, 0, 1601, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1436, 1437, - 0, 0, 0, 0, 567, 0, 0, 0, 0, 567, - 2048, 0, 0, 0, 0, 0, 0, 1655, 0, 0, - 0, 1601, 0, 0, 0, 1603, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 567, 0, 0, 0, 1438, - 1439, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 567, 567, 0, 0, - 0, 0, 0, 0, 0, 1418, 1419, 0, 0, 0, - 0, 0, 0, 0, 869, 0, 3198, 0, 0, 0, - 1602, 567, 0, 0, 0, 0, 1598, 1601, 0, 0, - 1603, 1599, 0, 1601, 0, 0, 0, 0, 824, 0, - 869, 0, 0, 3557, 0, 0, 1420, 1421, 73, 0, - 1422, 1423, 0, 0, 0, 0, 1601, 886, 0, 0, - 0, 0, 1468, 1602, 1128, 0, 567, 1031, 0, 1031, - 0, 0, 0, 0, 567, 0, 0, 0, 0, 1440, - 1441, 0, 0, 0, 0, 568, 568, 0, 568, 0, - 0, 0, 0, 0, 0, 1128, 0, 0, 0, 3321, - 1601, 0, 0, 1442, 1443, 0, 0, 0, 0, 0, - 869, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1424, 1425, 1602, + 3386, 0, 0, 0, 0, 1468, 2160, 1259, 0, 0, + 0, 1603, 0, 0, 0, 0, 1998, 0, 0, 0, + 0, 0, 1602, 0, 0, 0, 0, 0, 0, 0, + 0, 3402, 0, 0, 0, 0, 0, 0, 567, 0, + 0, 0, 2000, 2001, 2002, 567, 2003, 2004, 2005, 2006, + 2007, 2008, 0, 0, 0, 0, 0, 0, 1260, 1999, + 0, 0, 3421, 0, 0, 0, 0, 0, 0, 1261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 869, 1603, 0, 0, 0, 0, 0, 1471, 1471, 1471, + 0, 1262, 0, 3092, 0, 3433, 0, 0, 0, 1999, + 0, 0, 0, 3010, 0, 0, 0, 0, 0, 2426, + 2427, 2429, 2430, 2431, 2432, 0, 0, 0, 0, 0, + 1601, 0, 0, 1263, 567, 0, 0, 0, 0, 567, + 0, 1603, 0, 0, 0, 0, 0, 1471, 1471, 1471, 1471, 1471, 1471, 0, 0, 1471, 1471, 1471, 1471, 1471, - 1471, 1471, 1471, 1471, 1471, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3448, - 0, 0, 0, 0, 1603, 0, 0, 1128, 0, 0, - 2252, 568, 2254, 0, 1426, 1427, 1428, 1429, 1430, 1431, - 1432, 1433, 3557, 2263, 1434, 1435, 823, 0, 823, 0, - 0, 823, 0, 1601, 1602, 0, 823, 0, 0, 823, - 0, 823, 0, 0, 0, 823, 0, 2072, 0, 2076, - 73, 0, 3198, 0, 0, 0, 0, 735, 0, 0, - 1470, 1470, 0, 2301, 981, 981, 0, 3557, 981, 0, - 1603, 0, 0, 0, 0, 0, 2034, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 567, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1655, 0, 1436, - 1437, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1243, 3198, 736, 0, 0, 0, 1244, 0, - 3557, 0, 0, 0, 0, 0, 1256, 0, 1598, 0, - 737, 0, 0, 1599, 0, 0, 0, 0, 0, 0, - 1438, 1439, 0, 0, 0, 0, 1257, 0, 1602, 0, - 0, 0, 0, 0, 0, 1603, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 981, 0, 1471, 1471, - 0, 2160, 0, 0, 2425, 2426, 2428, 2429, 2430, 2431, - 738, 2267, 0, 1602, 0, 0, 3321, 0, 0, 2267, - 739, 0, 1258, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 740, 0, 0, 0, 0, 741, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1245, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 742, 0, 0, - 1440, 1441, 0, 0, 0, 0, 0, 0, 0, 1602, - 0, 0, 1143, 1143, 0, 1602, 0, 0, 0, 73, - 0, 0, 0, 0, 1442, 1443, 0, 0, 0, 1603, - 0, 0, 0, 1470, 0, 0, 0, 0, 1602, 0, - 0, 743, 0, 0, 1471, 3554, 744, 0, 0, 1259, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3256, 0, 0, 0, 1603, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 568, 1601, 0, 2580, 0, 0, - 0, 0, 1602, 0, 0, 0, 0, 0, 1286, 0, - 0, 0, 1332, 1339, 0, 0, 568, 0, 0, 0, - 1260, 0, 73, 0, 73, 0, 0, 568, 0, 568, - 3285, 1261, 568, 0, 0, 0, 0, 0, 745, 0, - 0, 0, 568, 1262, 568, 0, 0, 0, 0, 0, - 1603, 0, 0, 746, 0, 0, 1603, 568, 0, 0, - 0, 0, 568, 0, 1246, 1390, 568, 568, 73, 568, - 0, 568, 568, 0, 0, 1263, 0, 0, 0, 1603, - 0, 0, 0, 1414, 0, 73, 0, 0, 747, 1462, - 0, 748, 1464, 0, 0, 1475, 1478, 1483, 1486, 0, - 0, 0, 749, 0, 0, 750, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1602, 0, 0, 0, 0, - 0, 0, 0, 1603, 1264, 751, 0, 1470, 1248, 0, - 1265, 0, 0, 0, 0, 0, 0, 0, 0, 752, - 1530, 1332, 0, 0, 0, 0, 0, 754, 0, 0, - 0, 0, 0, 0, 0, 1266, 0, 755, 0, 0, - 1267, 0, 1617, 756, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1268, 0, 0, 0, - 0, 0, 1634, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 757, 0, 1645, 1646, 1647, 0, 1652, 1656, - 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, - 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 73, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1685, 0, 568, 0, 1719, 1250, 1603, 0, 0, 0, - 1687, 0, 0, 0, 73, 0, 0, 1688, 0, 1243, - 0, 0, 1530, 1530, 0, 1244, 0, 0, 0, 823, - 0, 0, 0, 1256, 0, 823, 0, 0, 0, 0, - 0, 2600, 0, 0, 1689, 0, 0, 2076, 0, 0, - 0, 0, 0, 1257, 1470, 0, 0, 0, 0, 1759, - 0, 0, 0, 1775, 1780, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1143, 1143, 1675, 0, 0, 0, - 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, - 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 1258, - 0, 0, 0, 0, 0, 0, 0, 1471, 1471, 0, - 1685, 0, 0, 0, 1686, 0, 0, 0, 0, 0, - 1687, 0, 0, 0, 0, 0, 0, 1688, 0, 0, - 1245, 2160, 0, 0, 0, 0, 568, 0, 1332, 0, - 0, 1660, 1690, 0, 0, 0, 0, 2828, 0, 1332, - 0, 0, 0, 0, 1689, 0, 0, 0, 0, 1691, - 0, 2844, 2845, 2847, 1692, 0, 0, 1602, 0, 0, - 0, 0, 0, 0, 1332, 0, 2860, 0, 0, 0, - 2863, 0, 0, 2866, 0, 0, 0, 1693, 1694, 0, - 0, 0, 0, 0, 0, 0, 1259, 0, 0, 0, - 0, 0, 0, 1695, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 823, 0, 0, - 0, 0, 0, 0, 0, 0, 2878, 0, 0, 568, - 0, 0, 0, 823, 0, 0, 0, 823, 0, 0, - 0, 0, 0, 1696, 0, 0, 1697, 1260, 0, 0, - 0, 0, 1690, 0, 0, 0, 0, 0, 1261, 0, - 1698, 0, 1981, 1699, 0, 0, 0, 0, 0, 1691, - 1262, 0, 0, 0, 1692, 0, 0, 0, 568, 0, - 0, 3574, 0, 0, 2743, 0, 0, 0, 1603, 0, - 0, 1246, 0, 0, 0, 0, 0, 1693, 1694, 0, - 0, 0, 1263, 0, 2912, 2913, 2914, 0, 0, 0, - 0, 0, 0, 1695, 0, 0, 0, 0, 0, 0, - 1471, 0, 0, 0, 0, 1483, 0, 1483, 1483, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1143, 1143, 0, 0, 0, 0, 0, 1471, 0, 0, - 0, 2368, 0, 1696, 0, 1248, 1697, 1265, 0, 0, - 0, 0, 1143, 1700, 0, 0, 0, 0, 0, 0, - 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, - 0, 0, 1266, 0, 0, 0, 0, 2369, 0, 0, + 1471, 1471, 1471, 1471, 1471, 567, 2000, 2001, 2002, 568, + 2003, 2004, 2005, 2006, 2007, 2008, 0, 0, 0, 0, + 0, 0, 0, 567, 567, -2189, 0, 0, 1265, 0, + 0, 568, 0, 1143, 1143, 0, 0, 0, 0, 0, + 0, 869, 568, 3152, 568, 0, 0, 568, 567, 0, + 1602, 0, 0, 1266, 0, 0, 0, 568, 0, 568, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1268, 0, 0, 0, 0, 0, 0, + 869, 0, 568, 3561, 1268, 0, 3093, 568, 0, 3094, + 0, 568, 568, 0, 568, 0, 568, 568, 0, 0, + 0, 0, 1468, 0, 1128, 0, 567, 1031, 1999, 1031, + 0, 0, 2581, 0, 567, 0, 0, 0, 0, 1286, + 0, 0, 0, 1332, 1339, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1128, 0, 0, 0, 3275, + 0, 0, 0, 0, 0, 0, 0, 2000, 2001, 2002, + 869, 2003, 2004, 2005, 2006, 2007, 2008, 0, 0, 1603, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 568, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1390, 2000, 2001, 2002, + 0, 2003, 2004, 2005, 2006, 2007, 2008, 0, 0, 0, + 0, 0, 0, 0, 1414, 0, 0, 0, 1471, 1471, + 1462, 1833, 0, 1464, 0, 0, 1475, 1478, 1483, 1486, + 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, + 1681, 0, 1682, 1683, 1684, 0, 0, 869, 0, 0, + 1602, 0, 0, 0, 0, 0, 0, 0, 0, 1685, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1687, + 0, 1530, 1332, 0, 0, 0, 1688, 568, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3402, + 0, 0, 0, 1617, 0, 0, 0, 1128, 0, 0, + 0, 0, 0, 1689, 823, 0, 0, 0, 0, 735, + 823, 0, 3561, 1634, 0, 0, 2601, 0, 0, 0, + 0, 0, 2076, 0, 0, 1645, 1646, 1647, 0, 1652, + 1656, 0, 0, 0, 1471, 0, 0, 0, 0, 0, + 0, 0, 0, 3152, 0, 0, 2000, 2001, 2002, 1603, + 2003, 2004, 2005, 2006, 2007, 2008, 0, 981, 981, 0, + 3561, 981, 0, 0, 0, 1719, 736, 0, 0, 2034, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 567, 0, 737, 1530, 1530, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3036, - 0, 0, 1250, 0, 0, 0, 0, 2122, 0, 0, - 0, 0, 0, 1700, 0, 1701, 2126, 0, 1702, 1703, - 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, - 2157, 0, 0, 0, 1471, 1984, 0, 0, 0, 0, + 0, 1690, 0, 0, 0, 0, 2160, 0, 3152, 0, + 0, 568, 0, 0, 0, 0, 1660, 3561, 1691, 0, + 1759, 0, 0, 1692, 1775, 1780, 0, 0, 0, 0, + 0, 0, 738, 0, 0, 1143, 1143, 0, 0, 0, + 0, 0, 739, 0, 0, 0, 1693, 1694, 0, 0, + 0, 0, 0, 0, 0, 740, 0, 0, 0, 0, + 741, 0, 1695, 0, 0, 0, 0, 0, 981, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2171, 0, 0, 0, 0, 0, 0, 0, 2176, 0, - 0, 0, 0, 0, 2180, 2181, 2182, 2183, 2184, 2185, - 2186, 2187, 0, 0, 0, 0, 2196, 2197, 0, 0, - 0, 2210, 0, 0, 0, 2213, 0, 0, 2221, 2222, - 2223, 2224, 2225, 2226, 2227, 2228, 2229, 0, 0, 2230, - 0, 3186, 0, 0, 0, 0, 1143, 568, 1332, 0, - 0, 568, 0, 0, 0, 0, 0, 2072, 0, 0, - 0, 0, 0, 0, 0, 1701, 2256, 0, 1702, 1703, - 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, + 0, 0, 0, 2267, 0, 0, 0, 0, 3275, 742, + 0, 2267, 823, 0, 0, 0, 0, 0, 0, 1332, + 0, 0, 1696, 0, 568, 1697, 0, 0, 823, 0, + 1332, 0, 823, 2830, 0, 0, 0, 0, 0, 1698, + 0, 0, 1699, 0, 0, 0, 0, 2846, 2847, 2849, + 0, 0, 0, 743, 0, 1332, 0, 0, 744, 0, + 0, 0, 2862, 0, 0, 0, 2865, 0, 0, 2868, + 0, 0, 0, 568, 0, 1675, 0, 0, 0, 2744, + 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, + 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1685, + 0, 0, 2880, 1686, 0, 1676, 0, 0, 1677, 1687, + 0, 0, 1678, 1679, 555, 0, 1688, 1682, 1683, 1684, + 745, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1700, 1981, 1685, 746, 0, 0, 0, 0, + 0, 0, 0, 1689, 1687, 0, 0, 0, 0, 0, + 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 747, 0, 0, 748, 0, 0, 0, 0, 1689, 0, + 2914, 2915, 2916, 0, 749, 0, 0, 750, 0, 0, + 0, 0, 0, 0, 0, 0, 1483, 0, 1483, 1483, + 0, 0, 0, 0, 0, 0, 0, 751, 0, 568, + 0, 1143, 1143, 0, 0, 0, 0, 0, 1471, 1471, + 0, 752, 0, 0, 0, 0, 0, 0, 753, 754, + 0, 0, 0, 1143, 0, 0, 0, 0, 0, 755, + 0, 1690, 0, 0, 1701, 756, 0, 1702, 1703, 1704, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 1691, 1417, + 0, 836, 0, 1692, 1984, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 757, 0, 1690, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1693, 1694, 0, 0, + 0, 0, 0, 1691, 0, 0, 0, 0, 1692, 0, + 0, 0, 1695, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1646, 1647, 2963, 0, 0, 0, 2160, 0, - 0, 3234, 3235, 3236, 3237, 0, 0, 0, 0, 0, + 0, 1693, 1694, 0, 0, 1418, 1419, 0, 0, 0, + 0, 0, 0, 0, 0, 3038, 0, 1695, 2122, 0, + 0, 0, 1696, 0, 0, 1697, 0, 2126, 0, 0, + 0, 0, 0, 568, 0, 0, 0, 568, 0, 1698, + 0, 2157, 1699, 2072, 0, 0, 1420, 1421, 0, 0, + 1422, 1423, 0, 0, 0, 0, 0, 1696, 0, 0, + 1697, 2171, 0, 0, 0, 0, 0, 0, 0, 2176, + 0, 0, 0, 0, 1698, 2180, 2181, 2182, 2183, 2184, + 2185, 2186, 2187, 0, 0, 0, 0, 2196, 2197, 0, + 2965, 0, 2210, 0, 2160, 0, 2213, 0, 0, 2221, + 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 0, 0, + 2230, 0, 1471, 0, 0, 0, 0, 1143, 3140, 1332, + 0, 0, 0, 1418, 1419, 0, 0, 1424, 1425, 0, + 0, 0, 0, 0, 0, 0, 0, 2256, 0, 1471, + 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1471, 0, 0, 0, 1676, 0, 0, 1677, 0, - 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, + 0, 0, 0, 0, 1420, 1421, 0, 0, 1422, 1423, + 0, 0, 0, 1646, 1647, 0, 0, 1700, 568, 0, + 0, 0, 568, 568, 0, 0, 0, 568, 3188, 3189, + 3190, 3191, 0, 0, 1426, 1427, 1428, 1429, 1430, 1431, + 1432, 1433, 0, 0, 1434, 1435, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 568, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1685, 0, 0, 0, 2968, 0, - 0, 0, 0, 0, 1687, 0, 0, 0, 0, 0, - 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 568, 0, 0, 0, 568, 568, 0, 0, - 0, 568, 0, 2395, 0, 0, 0, 0, 1689, 0, - 1332, 0, 0, 2406, 2407, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 568, 568, 568, 568, 0, 568, + 568, 568, 568, 568, 0, 1424, 1425, 0, 0, 0, + 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, 1704, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, + 0, 0, 0, 0, 2396, 0, 0, 0, 0, 1436, + 1437, 1332, 0, 0, 2407, 2408, 1471, 0, 0, 1701, + 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, + 1709, 1710, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, + 1438, 1439, 1434, 1435, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 568, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 568, 568, 568, - 568, 0, 568, 568, 568, 568, 568, 0, 0, 0, + 2072, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1390, 2513, 0, 0, 3318, -48, 0, 0, 0, + 2515, 0, 0, 0, 0, 0, 0, 0, 2601, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 2531, 2532, 0, 2533, 0, 0, 0, 0, 0, 2, + 0, 3, 4, 0, 0, 1471, 735, 1436, 1437, 0, + 2160, 0, 0, 0, 5, 0, 0, 0, 2160, 6, + 0, 0, 2559, 2560, 0, 0, 2256, 0, 7, 0, + 1440, 1441, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 8, 0, 0, 0, 0, 0, 1438, 1439, + 0, 9, 823, 10, 1442, 1443, 0, 2585, 0, 0, + 0, 0, 0, 736, 0, 11, 2595, 12, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 13, 737, + 0, 0, 0, 0, 0, 1530, 0, 1332, 0, 0, + 0, 0, 0, 14, 15, 16, 0, 0, 0, 0, + 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, + 18, 0, 0, 0, 0, 0, 0, 568, 0, 19, + 0, 20, 21, 0, 0, 0, 2630, 0, 0, 738, + 0, 0, 2637, 0, 0, 1472, 22, 0, 0, 739, + 23, 0, 0, 0, 0, 0, 0, 0, 1440, 1441, + 0, 0, 740, 0, 0, 0, 0, 741, 0, 0, + 0, 0, 0, 0, 0, 2649, 24, 0, 0, 2655, + 0, 0, 1442, 1443, 2660, 2661, 0, 0, 0, 1243, + 0, 0, -1530, 0, 0, 1244, 742, 0, 0, 0, + 0, 0, 2090, 1256, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, + 0, 0, 0, 1257, 0, 0, 0, 0, 0, 0, + 0, 2682, 0, 0, 2685, 0, 2687, 0, 0, 0, + 743, 0, 1471, 0, 0, 744, 0, 0, 0, 0, + 0, 0, 2691, 0, 3531, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1258, + 3410, 1713, 0, 0, 0, 0, 0, 2601, 0, 0, + 0, 0, 0, 3559, 0, 0, 0, 0, 0, 0, + 0, 0, 1759, 0, 0, 0, 0, 26, 27, 28, + 1245, 0, 0, 0, 0, 29, 0, 0, 30, 1780, + 2228, 0, 0, 0, 0, 0, 0, 745, 0, 0, + 1713, 0, 0, 0, 0, 0, 0, 0, 1143, 0, + 0, 0, 746, 0, 0, 0, 0, 0, 0, 31, + 0, 0, 0, 2751, 0, 0, 568, 0, 32, 0, + 0, 568, 0, 3602, 0, 1472, 0, 0, 0, 0, + 0, 0, 0, 0, 33, 0, 1259, 747, 0, 0, + 748, 34, 0, 0, 0, 35, 0, 568, 0, 0, + 0, 749, 0, 0, 750, 0, 0, 36, 0, 0, + 0, 0, 0, 0, 0, 568, 568, 0, 0, 37, + 0, 0, 0, 38, 751, 0, 0, 0, 0, 0, + 0, 0, 1647, 0, 1713, 0, 0, 1260, 752, 0, + 568, 1332, 0, 0, 39, 0, 754, 0, 1261, 0, + 3629, 0, 0, 0, 0, 0, 755, 0, 40, 0, + 1262, 41, 756, 0, 42, 0, 0, 0, 0, 43, + 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 0, + 1713, 1246, 1682, 1683, 1684, 0, 44, 1713, 568, 0, + 0, 757, 1263, 0, 0, 0, 2160, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1687, + 45, 0, 0, 0, 0, 0, 1688, 0, 0, 0, + 0, 0, 0, 0, 46, 0, 0, -48, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1713, 2878, + 0, 2369, 0, 1689, 0, 1248, 0, 1265, 0, 0, + 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, + 1680, 1681, 1713, 1682, 1683, 1684, 0, 0, 0, 0, + 0, 0, 1266, 0, 0, 0, 0, 2370, 0, 0, + 1685, 0, 0, 0, 2970, 0, 0, 0, 0, 0, + 1687, 0, 0, 1268, 0, 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3364, 0, - 1390, 2512, 0, 0, 0, 0, 0, 0, 0, 2514, - 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, - 1681, 0, 1682, 1683, 1684, 0, 1690, 0, 0, 2530, - 2531, 0, 2532, 0, 0, 0, 0, 0, 0, 1685, - 0, 0, 0, 1691, 0, 0, 0, 0, 1692, 1687, - 0, 0, 0, 0, 0, 0, 1688, 0, 0, 0, - 0, 2558, 2559, 0, 0, 2256, 0, -48, 0, 0, - 0, 1693, 1694, 2072, 0, 0, 0, 0, 1471, 0, - 0, 0, 0, 1689, 0, 0, 0, 1695, 0, 0, - 1, 0, 0, 0, 0, 0, 2584, 0, 0, 0, - 2, 2600, 3, 4, 0, 2594, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, - 6, 0, 0, 0, 1530, 0, 1332, 1696, 0, 7, - 1697, 0, 0, 2160, 0, 0, 0, 0, 0, 0, - 0, 2160, 0, 8, 1698, 0, 0, 1699, 0, 0, - 0, 0, 9, 0, 10, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2629, 11, 0, 12, 0, - 0, 2636, 0, 0, 0, 823, 0, 0, 0, 13, + 1713, 0, 1713, 0, 1472, 1472, 0, 2009, 0, 0, + 1472, 0, 0, 1713, 1689, 0, 1713, 0, 0, 0, + 0, 1713, 0, 0, 1713, 0, 0, 0, 0, 0, 0, 1690, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 14, 15, 16, 0, 1691, 0, - 0, 0, 0, 1692, 2648, 17, 0, 0, 2654, 0, - 0, 18, 0, 2659, 2660, 0, 0, 0, 0, 0, - 19, 0, 20, 21, 0, 0, 1693, 1694, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, - 568, 23, 1695, 0, 0, 0, 0, 1700, 0, 0, + 0, 0, 1250, 0, 0, 0, 0, 0, 1691, 0, + 0, 0, 0, 1692, 0, 0, 0, 0, 2955, 0, + 0, 0, 0, 0, 0, 2957, 2126, 0, 1713, 0, + 0, 0, 0, 0, 0, 0, -2189, -2189, 0, 0, + 0, 2966, 1418, 1419, 0, 0, 0, 0, 0, 0, + 0, 0, 1695, 0, 2978, 0, 0, 2981, 0, 2983, + 0, 0, 0, 0, 0, 0, 0, 2987, 0, 0, + 0, 0, 1690, 0, 0, 2994, 2995, 0, 0, 0, + 0, 0, 3002, 1420, 1421, 0, 0, 1422, 1423, 1691, + 0, 0, 568, 0, 1692, -2189, 0, 0, 0, 3016, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1698, + 3032, 0, 0, 0, 0, 1713, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 2681, 0, 0, 2684, 0, 2686, 0, 24, 0, 0, + 1143, 0, 1713, 1695, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1713, 1713, 1713, 0, 0, 0, 0, + 1713, 0, 0, 0, 1713, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1424, 1425, 0, 0, 0, 0, + 0, 0, 0, 1696, 0, 0, 1697, 3103, 3104, 0, + 0, 0, 0, 1759, 0, 0, 0, 0, 0, 0, + 1698, 0, 0, 1699, 0, 0, 0, 2396, 2396, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2690, 1696, -1524, 0, 1697, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1698, - 0, 0, 1699, 0, 0, 0, 0, 0, 0, 0, - 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1759, 0, 0, 0, 0, 0, 0, 3530, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1780, 2228, + 3129, 0, 1700, 0, 0, 0, 0, 1713, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3143, + 0, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433, 0, + 0, 1434, 1435, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1676, 0, 0, 1677, 0, 1713, 0, 1678, + 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, + 0, 0, 0, 1713, 0, 0, 0, 0, 1713, 0, + 0, 1685, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1687, 0, 1700, 0, 2009, 0, 0, 1688, 0, + 0, 0, 0, 0, 3204, 3205, 0, 3208, 0, 0, + 0, 0, 0, 0, 0, 0, 1436, 1437, 0, 0, + 0, 0, 0, 0, 1701, 1689, 0, 1702, 1703, 1704, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, + 0, 3229, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1438, 1439, 0, + 0, 3238, 0, 0, 0, 0, 3241, 3242, 0, 0, + 0, 3243, 0, 0, 0, 0, 3246, 0, 0, 3249, + 3250, 0, 0, 0, 2396, 1332, 0, 0, 3258, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3555, 0, 0, 1143, 0, 1701, - 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, - 1709, 1710, 2750, 0, 0, 0, 2166, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, - 28, 0, 0, 0, 0, 0, 29, 0, 0, 30, - 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1143, 1701, 0, 0, 1702, 1703, + 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, + 0, 0, 2166, 1690, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3598, 0, 0, 0, 0, 1676, - 31, 3456, 1677, 0, 0, 0, 1678, 1679, 2600, 32, - 1647, 1682, 1683, 1684, 0, 0, 0, 0, 0, 1332, - 0, 0, 0, 0, 3624, 33, 0, 0, 1685, 0, - 0, 0, 34, 1472, 1418, 1419, 35, 0, 1687, 0, - 0, 0, 0, 0, 0, 1688, 0, 0, 36, 0, + 1691, 0, 0, 0, 0, 1692, 0, 0, 0, 0, + 3306, 0, 0, 0, 0, 0, 0, 1440, 1441, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1693, 1694, + 0, 0, 0, 0, 0, 0, 0, 3325, 0, 1713, + 0, 1442, 1443, 0, 1695, 0, 0, 2009, 2009, 0, + 1472, 1472, 1472, 1472, 1472, 1472, 0, 0, 1472, 1472, + 1472, 1472, 1472, 1472, 1472, 1472, 1472, 1472, 2009, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 37, 0, 0, 0, 38, 0, 0, 0, 0, 0, - 0, 0, 1689, 0, 0, 1420, 1421, 568, 0, 1422, - 1423, 0, 568, 0, 1701, 39, 0, 1702, 1703, 1704, - 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 40, - 0, 2166, 41, 0, 0, 42, 0, 0, 568, 0, - 43, 0, 0, 0, 0, 0, 0, 2876, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 44, 0, 568, - 568, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1696, 0, 0, 1697, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 45, 0, 0, 568, 0, 1424, 1425, 0, 1713, - 0, 0, 0, 0, 0, 46, 0, 0, -48, 0, - 1690, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, - 1680, 1681, 0, 1682, 1683, 1684, 0, 1691, 0, 0, - 0, 0, 1692, 0, 0, 0, 0, 0, 0, 568, - 1685, 0, 0, 0, 0, 0, 0, 2160, 1713, 0, - 1687, 0, 0, 0, 0, 1693, 1694, 1688, 0, 0, - 0, 0, 0, 1426, 1427, 1428, 1429, 1430, 1431, 1432, - 1433, 1695, 0, 1434, 1435, 0, 0, 0, 0, 0, - 0, 0, 0, 1472, 1689, 0, 2953, 0, 0, 0, - 0, 0, 1676, 2955, 2126, 1677, 0, 0, 0, 1678, - 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 2964, + 0, 1698, 0, 0, 1699, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3382, 3383, 0, 2878, 1676, + 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, 1681, + 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1656, 0, 0, 0, 0, 1685, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1687, 0, + 0, 0, 0, 0, 0, 1688, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2655, 0, + 1713, 0, 0, 0, 1713, 0, 0, 0, 0, 0, + 0, 0, 1689, 0, 3425, 3426, 0, 0, 3427, 0, + 1647, 0, 0, 0, 1700, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1713, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1713, + 0, 0, 3451, 0, 1713, 0, 0, 0, 1713, 1713, + 1713, 1713, 1713, 1713, 1713, 1713, 0, 0, 0, 0, + 0, 1472, 1472, 0, 1713, 1713, 3463, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1713, 0, + 0, 1713, 0, 0, 0, 0, 0, 0, 0, 1713, + 1713, 1713, 1713, 1713, 1713, 1713, 1713, 1713, 1713, 0, + 1690, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1691, 0, 0, + 0, 0, 1692, 0, 1713, 0, 1701, 0, 0, 1702, + 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, + 0, 0, 0, 2166, 0, 1693, 1694, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 3204, 0, + 0, 1695, 3575, 0, 0, 0, 1143, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1472, 0, 0, + 3585, 0, 0, 0, 0, 2396, 2396, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1143, 0, 0, 0, 1696, 0, 0, 1697, 0, 0, 0, 0, 0, - 0, 1685, 2976, 0, 0, 2979, 0, 2981, 1698, 0, - 0, 1687, 0, 0, 0, 2985, 0, 0, 1688, 0, - 0, 0, 1713, 2992, 2993, 0, 0, 0, 1436, 1437, - 3000, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1689, 0, 3014, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 3030, 0, - 0, 0, 1690, 0, 0, 0, 0, 0, 1713, 1438, - 1439, 0, 0, 0, 0, 1713, 0, 0, 1143, 1691, - 0, 0, 0, 0, 1692, 1676, 0, 0, 1677, 0, - 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, - 0, 0, 0, 0, 0, 0, 0, 1693, 1694, 0, - 0, 1700, 0, 0, 1685, 0, 0, 0, 0, 0, - 568, 0, 0, 1695, 1687, 0, 1713, 0, 0, 0, - 1759, 1688, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1690, 2395, 2395, 0, 0, 0, 0, - 1713, 0, 0, 0, 0, 0, 0, 3175, 1689, 0, - 1691, 0, 0, 1696, 0, 1692, 1697, 0, 0, 1440, - 1441, 0, 0, 0, 0, 0, 3189, 0, 0, 0, - 1698, 0, 0, 1699, 0, 0, 0, 0, 1693, 1694, - 0, 0, 0, 1442, 1443, 0, 0, 0, 1713, 0, - 1713, 0, 1472, 1472, 1695, 2009, 0, 0, 1472, 0, - 0, 1713, 0, 2090, 1713, 0, 0, 0, 0, 1713, - 0, 0, 1713, 1701, 0, 0, 1702, 1703, 1704, 0, - 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, - 0, 0, 0, 0, 1696, 0, 0, 1697, 0, 0, - 0, 3250, 3251, 0, 3254, 0, 1690, 0, 0, 0, - 0, 1698, 0, 0, 1699, 0, 1713, 0, 0, 0, - 0, 0, 0, 1691, 0, 0, 0, 0, 1692, 0, - 0, 0, 0, 1700, 0, 0, 0, 0, 3275, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1698, 3613, + 0, 1699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1693, 1694, 0, 0, 0, 0, 0, 3284, 0, - 0, 0, 0, 3287, 3288, 0, 0, 1695, 3289, 0, - 0, 0, 0, 3292, 0, 0, 3295, 3296, 0, 0, - 0, 2395, 1332, 0, 0, 3304, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1143, 0, 1713, 0, 0, 0, 1696, 0, 0, - 1697, 0, 0, 0, 1700, 0, 0, 0, 0, 0, - 1713, 0, 0, 0, 1698, 0, 0, 1699, 0, 0, - 0, 1713, 1713, 1713, 0, 0, 0, 0, 1713, 0, - 0, 0, 1713, 0, 0, 1701, 0, 3352, 1702, 1703, - 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, - 0, 0, 2529, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3371, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1713, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1713, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1713, 0, 0, 0, 0, + 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, + 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3641, 0, 1685, + 0, 1700, 0, 0, 0, 0, 0, 3204, 0, 1687, + 0, 0, 0, 0, 0, 0, 1688, 0, 0, 1143, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1701, 1700, 0, 1702, - 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 1676, - 0, 0, 1677, 2633, 0, 1713, 1678, 1679, 1680, 1681, - 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, - 0, 1713, 0, 0, 0, 0, 1713, 0, 1685, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1687, 0, - 0, 0, 0, 2009, 0, 1688, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3668, 0, 0, 0, + 0, 0, 0, 1689, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3688, 0, 0, 0, 0, + 0, 1713, 0, 1713, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1713, + 1713, 1713, 0, 0, 2009, 2009, 2009, 2009, 2009, 2009, + 0, 0, 0, 2009, 2009, 2009, 2009, 2009, 2009, 2009, + 2009, 2009, 2009, 0, 0, 0, 0, 1713, 1713, 0, + 0, 0, 0, 1701, 0, 0, 1702, 1703, 1704, 0, + 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, + 2530, 0, 0, 1713, 0, 0, 0, 0, 0, 0, + 0, 1690, 0, 1713, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 3760, 3760, 3760, 0, 0, 1691, 0, + 0, 0, 0, 1692, 3771, 0, 0, 1676, 0, 0, + 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 1713, 1682, + 1683, 1684, 0, 0, 0, 1713, 1693, 1694, 0, 0, + 0, 0, 0, 0, 3760, 0, 1685, 1713, 0, 0, + 0, 0, 1695, 1713, 0, 0, 1687, 0, 1713, 1713, + 0, 0, 0, 1688, 0, 0, 2009, 2009, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 3428, 3429, 0, 2876, 0, 0, 0, 0, 0, 0, - 0, 0, 1689, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1656, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1701, - 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, - 1709, 1710, 1676, 0, 0, 1677, 2647, 0, 0, 1678, - 1679, 1680, 1681, 2654, 1682, 1683, 1684, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3471, - 3472, 1685, 0, 3473, 0, 1647, 0, 0, 0, 0, - 0, 1687, 0, 0, 0, 0, 0, 0, 1688, 0, + 1713, 1472, 1472, 1713, 0, 1713, 0, 0, 0, 1713, + 1689, 0, 1696, 0, 0, 1697, 0, 0, 0, 0, + 0, 0, 0, 0, 3760, 0, 0, 0, 0, 1698, + 0, 0, 1699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1690, 0, 0, 0, 0, 0, 0, 3497, 0, 0, - 0, 0, 0, 0, 0, 1689, 0, 1691, 0, 0, - 0, 0, 1692, 0, 0, 0, 0, 0, 0, 0, - 0, 3509, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1693, 1694, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1713, 0, 0, - 0, 1695, 0, 0, 0, 2009, 2009, 0, 1472, 1472, - 1472, 1472, 1472, 1472, 0, 0, 1472, 1472, 1472, 1472, - 1472, 1472, 1472, 1472, 1472, 1472, 2009, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1696, 0, 0, 1697, 0, 0, 0, 0, 0, - 0, 0, 0, 1690, 0, 0, 0, 0, 1698, 0, - 0, 1699, 0, 3250, 0, 0, 0, 3571, 0, 0, - 1691, 1143, 0, 0, 0, 1692, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 3581, 0, 0, 0, 0, - 2395, 2395, 0, 0, 0, 0, 0, 0, 1693, 1694, - 0, 0, 1143, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1695, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3609, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1713, 0, - 0, 0, 1713, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1696, 0, 0, 1697, 0, 0, - 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1698, 3634, 1713, 1699, 0, 0, 0, 0, 0, - 0, 0, 3250, 0, 0, 0, 0, 1713, 0, 0, - 0, 0, 1713, 0, 1143, 0, 1713, 1713, 1713, 1713, - 1713, 1713, 1713, 1713, 0, 0, 0, 0, 0, 1472, - 1472, 3661, 1713, 1713, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1713, + 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, + 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1685, + 0, 0, 0, 0, 0, 0, 0, 0, 1690, 1687, + 0, 0, 0, 0, 0, 0, 1688, 0, 0, 0, + 0, 0, 0, 0, 0, 1691, 0, 0, 0, 0, + 1692, 0, 1700, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1689, 0, 0, 0, 0, 1676, 0, + 0, 1677, 0, 1693, 1694, 1678, 1679, 1680, 1681, 0, + 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, 1695, + 0, 0, 0, 0, 0, 0, 0, 1685, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1687, 0, 0, + 0, 0, 0, 0, 1688, 0, 1713, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1696, + 0, 0, 1697, 0, 0, 1472, 0, 0, 0, 0, + 0, 1689, 0, 0, 0, 0, 1698, 0, 0, 1699, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1690, 0, 0, 1701, 0, 0, 1702, 1703, 1704, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 1691, 0, + 0, 2634, 0, 1692, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1713, 0, 1713, 0, 0, 0, 0, + 0, 0, 0, 0, 1713, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, 1713, 0, 0, 1713, - 3681, 0, 0, 0, 0, 0, 0, 1713, 1713, 1713, - 1713, 1713, 1713, 1713, 1713, 1713, 1713, 0, 0, 0, + 0, 1713, 1695, 0, 0, 1713, 0, 0, 2009, 2009, + 0, 0, 1713, 1713, 0, 0, 0, 0, 0, 1690, + 1713, 0, 0, 0, 0, 0, 0, 0, 0, 1700, + 0, 0, 0, 0, 1713, 0, 1691, 0, 0, 0, + 0, 1692, 1696, 0, 0, 1697, 0, 0, 0, 0, + 1713, 0, 0, 0, 0, 0, 0, 0, 0, 1698, + 0, 0, 1699, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1695, 0, 0, 0, 0, 0, 0, 0, 0, 1472, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1713, 1701, 1700, 0, 1702, 1703, 1704, 0, - 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, - 2665, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, - 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, - 0, 3744, 3744, 3744, 0, 1472, 0, 0, 0, 0, - 1685, 0, 3755, 0, 0, 0, 0, 0, 0, 0, - 1687, 0, 0, 0, 0, 0, 0, 1688, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 3744, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1689, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1701, 0, 0, 1702, - 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, - 0, 0, 0, 2893, 0, 0, 0, 0, 0, 0, - 0, 1713, 0, 0, 0, 0, 3744, 0, 0, 0, - 0, 0, 1713, 1713, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1676, 0, 0, - 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1696, 1713, 1713, 1697, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1698, 0, 0, + 1699, 1701, 0, 0, 1702, 1703, 1704, 1713, 1705, 1706, + 1707, 1708, 1709, 1710, 0, 0, 0, 1676, 2648, 0, + 1677, 1713, 1700, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1685, 0, 0, 0, - 0, 0, 1690, 0, 0, 0, 1687, 0, 0, 0, - 0, 0, 0, 1688, 0, 0, 0, 0, 0, 1691, - 0, 0, 0, 0, 1692, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1687, 2009, 1472, 0, + 0, 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1689, 0, 0, 0, 0, 0, 0, 1693, 1694, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1713, 0, - 1713, 0, 0, 1695, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1713, 1713, 1713, 0, - 0, 2009, 2009, 2009, 2009, 2009, 2009, 0, 0, 0, - 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, 2009, - 0, 0, 0, 1696, 1713, 1713, 1697, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, - 1713, 0, 0, 0, 1676, 0, 0, 1677, 1690, 0, - 1713, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, - 0, 0, 0, 0, 0, 1691, 0, 0, 0, 0, - 1692, 0, 0, 1685, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1687, 0, 1713, 0, 0, 0, 0, - 1688, 0, 1713, 1693, 1694, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1713, 0, 0, 0, 0, 1695, - 1713, 0, 0, 0, 0, 1713, 1713, 1689, 0, 0, - 0, 0, 0, 2009, 2009, 0, 0, 0, 0, 0, - 0, 0, 0, 1700, 0, 0, 0, 1713, 1472, 1472, - 1713, 0, 1713, 0, 0, 0, 1713, 0, 0, 1696, - 1676, 0, 1697, 1677, 0, 0, 0, 1678, 1679, 1680, - 1681, 0, 1682, 1683, 1684, 0, 1698, 0, 0, 1699, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1685, - 0, 0, 0, 0, 0, 1676, 0, 0, 1677, 1687, - 0, 0, 1678, 1679, 1680, 1681, 1688, 1682, 1683, 1684, - 0, 0, 0, 0, 0, 0, 1713, 0, 0, 0, - 0, 0, 0, 0, 1685, 1690, 0, 0, 0, 0, - 0, 0, 0, 1689, 1687, 0, 0, 0, 0, 0, - 0, 1688, 1691, 0, 0, 0, 0, 1692, 0, 0, - 0, 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, - 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 1689, 0, - 1693, 1694, 2960, 0, 0, 0, 0, 0, 0, 1700, - 0, 0, 0, 0, 0, 0, 1695, 0, 0, 0, + 0, 0, 1713, 1713, 0, 0, 1713, 0, 0, 0, + 1689, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1700, 0, 0, 0, 0, 0, 0, 1713, 0, 0, + 0, 0, 0, 0, 0, 0, 1713, 0, 0, 1713, + 1713, 1713, 0, 0, 1713, 0, 0, 1713, 1713, 0, + 0, 0, 0, 0, 1701, 0, 1713, 1702, 1703, 1704, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, + 0, 2666, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, - 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1696, 0, 0, 1697, - 1685, 1690, 0, 0, 0, 0, 0, 0, 0, 0, - 1687, 0, 1713, 1698, 0, 0, 1699, 1688, 1691, 0, - 0, 0, 0, 1692, 0, 0, 0, 0, 0, 0, - 0, 1472, 0, 0, 0, 0, 1690, 0, 0, 0, - 0, 0, 0, 0, 1689, 0, 1693, 1694, 0, 0, - 0, 0, 0, 1691, 0, 0, 0, 0, 1692, 0, - 0, 1701, 1695, 0, 1702, 1703, 1704, 0, 1705, 1706, - 1707, 1708, 1709, 1710, 0, 0, 0, 0, 2973, 0, - 0, 1693, 1694, 0, 0, 0, 0, 0, 0, 1713, - 0, 1713, 0, 0, 0, 0, 0, 1695, 0, 0, - 1713, 0, 1696, 0, 0, 1697, 0, 0, 0, 0, - 0, 0, 1713, 0, 0, 1713, 1700, 1713, 0, 1698, - 0, 1713, 1699, 0, 2009, 2009, 0, 0, 1713, 1713, - 0, 0, 0, 0, 0, 0, 1713, 1696, 0, 0, - 1697, 0, 1690, 0, 0, 0, 0, 0, 0, 0, - 1713, 0, 0, 0, 1698, 0, 0, 1699, 0, 1691, - 0, 0, 0, 0, 1692, 0, 1713, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1676, 0, 0, - 1677, 0, 0, 0, 1678, 1679, 0, 1693, 1694, 1682, - 1683, 1684, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1695, 0, 1472, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1687, 0, 0, 0, - 0, 0, 1700, 1688, 0, 0, 0, 0, 1701, 0, - 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 0, 0, 1696, 0, 3047, 1697, 0, 0, 0, - 1689, 0, 0, 0, 0, 0, 0, 1700, 0, 0, - 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1676, 0, 0, 1677, 0, 0, - 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1685, 0, 0, 0, 0, 0, 0, - 0, 1713, 0, 1687, 0, 0, 0, 0, 0, 0, - 1688, 0, 0, 0, 0, 1713, 0, 0, 0, 0, - 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, 1704, - 0, 1705, 1706, 1707, 1708, 1709, 1710, 1689, 1690, 0, - 0, 3298, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 2009, 1472, 1700, 0, 1691, 0, 0, 0, 1701, - 1692, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, - 1709, 1710, 0, 0, 1876, 0, 1713, 1713, 0, 0, - 1713, 0, 0, -2183, -2183, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1713, 0, 0, 0, 1690, 0, + 2009, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1713, 0, 1691, 0, 0, 0, 0, + 1692, 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, + 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, 2895, + 0, 0, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1695, - 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, - 1713, 0, 0, 1713, 1713, 1713, 0, 0, 1713, 0, - 0, 1713, 1713, 0, 0, 0, 0, 0, 0, 0, - 1713, 0, 0, 0, 0, 1690, 0, 0, 0, 0, - 0, 0, -2183, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1691, 0, 0, 0, 1698, 1692, 0, 0, - 0, 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, - 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 1713, 0, - 1693, 1694, 3305, 0, 2009, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1695, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1713, 1713, 0, 0, 0, 0, 0, 2009, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1696, + 0, 0, 1697, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1713, 1713, 1713, 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1696, 0, 0, 1697, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1698, 1713, 1713, 1699, 0, 0, 1700, - 0, 2009, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1713, 1713, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, - 1707, 1708, 1709, 1710, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1713, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1713, 0, 0, 0, 0, 0, 0, 0, 1701, 0, - 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 0, 0, 0, 0, 3395, 0, 1713, 0, 0, - 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1713, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, - 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, - 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, - 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, - 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, - 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, - 1713, 1089, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 1713, 176, 177, 178, 179, 180, 181, 0, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, - 201, 202, 203, 204, 14, 15, 205, 206, 207, 208, - 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, - 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, - 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, - 240, 23, 241, 242, 243, 244, 245, 246, 247, 248, - 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, - 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, - 283, 284, 285, 286, 287, 288, 289, 290, 1102, 291, - 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, - 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 1104, 330, 1105, 332, 333, 334, 335, 1106, 336, 337, - 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, - 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, - 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 26, 27, - 28, 0, 370, 371, 813, 373, 374, 375, 376, 377, - 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, - 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, - 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, - 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 33, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 35, 438, 439, 440, - 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, - 37, 0, 460, 461, 38, 462, 463, 464, 465, 466, - 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, - 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 1116, 40, - 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 819, 1117, 500, 0, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 0, 0, 510, 0, 44, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, - 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, - 0, 45, 0, 0, 0, 0, 1119, 1120, 1121, 0, - 0, 0, 0, 1122, 0, 1123, 3446, 0, 0, 0, - 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, - 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, - 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, - 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, - 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, - 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, - 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, - 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, - 198, 0, 199, 200, 201, 202, 203, 204, 14, 15, - 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, - 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, - 0, 238, 0, 239, 240, 23, 241, 242, 243, 244, - 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, - 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, - 1100, 0, 1101, 0, 283, 284, 285, 286, 287, 288, - 289, 290, 1102, 291, 292, 293, 0, 0, 294, 295, - 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, - 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 1104, 330, 1105, 332, 333, 334, - 335, 1106, 336, 337, 338, 339, 1107, 810, 341, 1108, - 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, - 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 26, 27, 28, 0, 370, 371, 813, 373, - 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, - 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, - 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, - 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 33, - 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 35, 438, 439, 440, 1112, 442, 0, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 815, 37, 0, 460, 461, 38, 462, - 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, - 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, - 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, - 487, 488, 1116, 40, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 819, 1117, 500, 0, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, - 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 1118, 0, 45, 0, 0, 0, 0, - 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, - 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, - 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1713, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1713, + 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, + 1707, 1708, 1709, 1710, 0, 0, 0, 0, 2962, 0, + 0, 0, 0, 0, 0, 0, 1713, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 121, 1076, + 836, 1077, 1078, 1079, 1080, 1081, 1713, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, - 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, + 0, 160, 161, 162, 163, 806, 0, 807, 1713, 1089, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 1713, 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, - 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, + 203, 204, 14, 15, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, @@ -5793,9 +5633,9 @@ static const yytype_int16 yytable[] = 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 33, 0, 429, 430, 431, 432, 433, - 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, + 434, 435, 436, 437, 35, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, - 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, + 452, 453, 454, 455, 456, 457, 458, 815, 37, 0, 460, 461, 38, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, @@ -5806,67 +5646,67 @@ static const yytype_int16 yytable[] = 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 45, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, - 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, - 1126, 1127, 1291, 1076, 836, 1077, 1078, 1079, 1080, 1081, + 0, 1122, 0, 1123, 3400, 0, 0, 0, 1124, 1125, + 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 1292, 130, 131, 132, 0, 0, 0, 1293, 0, 1082, - 0, 0, 1294, 134, 135, 0, 1295, 137, 138, 1296, - 140, 141, 142, 143, 1083, 1297, 1084, 1085, 0, 1298, + 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, + 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, + 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, - 0, 1299, 0, 1300, 167, 168, 169, 170, 171, 1301, + 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, - 0, 1302, 183, 184, 185, 186, 187, 188, 189, 190, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, - 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 1303, 0, 209, 210, 1093, 212, 213, 0, + 199, 200, 201, 202, 203, 204, 14, 15, 205, 206, + 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, - 0, 239, 1304, 0, 1305, 242, 243, 1306, 1307, 246, + 0, 239, 240, 23, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, - 255, 256, 257, 258, 259, 1308, 261, 262, 263, 264, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, - 1309, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, - 1101, 0, 283, 1310, 1311, 286, 1312, 288, 289, 290, - 1102, 291, 292, 293, 0, 0, 294, 1313, 296, 1314, - 0, 298, 299, 300, 301, 302, 303, 304, 305, 1315, + 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, + 1101, 0, 283, 284, 285, 286, 287, 288, 289, 290, + 1102, 291, 292, 293, 0, 0, 294, 295, 296, 297, + 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 1104, 1316, 1105, 332, 333, 334, 335, 1106, - 336, 337, 1317, 339, 1107, 810, 341, 1108, 343, 344, + 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 1106, + 336, 337, 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, - 897, 351, 352, 353, 1318, 355, 1319, 812, 358, 359, + 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 0, 0, 0, 0, 370, 371, 813, 1320, 374, 375, + 26, 27, 28, 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 0, 409, 410, 1321, + 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 427, 428, 0, 1322, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, 1323, + 422, 423, 424, 425, 426, 427, 428, 33, 0, 429, + 430, 431, 432, 433, 434, 435, 436, 437, 35, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 1324, - 458, 815, 0, 0, 460, 461, 0, 462, 1325, 464, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 815, 37, 0, 460, 461, 38, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, - 0, 473, 474, 816, 476, 817, 1115, 478, 479, 1326, + 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, - 1327, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 1117, 500, 1328, 501, 1329, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, + 1116, 40, 489, 490, 491, 492, 0, 493, 494, 495, + 496, 497, 819, 1117, 500, 0, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 0, 0, 510, 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, - 1121, 0, 0, 0, 0, 1122, 0, 1123, 1330, 0, + 531, 1118, 0, 45, 0, 0, 0, 0, 1119, 1120, + 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, - 1084, 1085, 1479, 0, 148, 149, 150, 151, 152, 1086, + 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, @@ -5877,13 +5717,13 @@ static const yytype_int16 yytable[] = 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, - 1096, 237, 0, 238, 0, 239, 240, 1480, 241, 242, + 1096, 237, 0, 238, 0, 239, 240, 23, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, 283, 284, 285, 286, - 287, 288, 289, 290, 1102, 291, 292, 293, 0, 1481, + 287, 288, 289, 290, 1102, 291, 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, @@ -5892,31 +5732,31 @@ static const yytype_int16 yytable[] = 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, + 366, 367, 368, 369, 26, 27, 28, 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, + 428, 33, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, - 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, - 470, 1113, 1114, 0, 1482, 473, 474, 816, 476, 817, + 38, 462, 463, 464, 465, 466, 467, 468, 469, 0, + 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, - 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, + 0, 486, 487, 488, 1116, 40, 489, 490, 491, 492, + 0, 493, 494, 495, 496, 497, 819, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, - 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, + 0, 510, 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, + 527, 528, 529, 530, 531, 1118, 0, 45, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 1291, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, + 122, 123, 124, 125, 126, 127, 128, 129, 1292, 130, 131, 132, 0, 0, 0, 1293, 0, 1082, 0, 0, 1294, 134, 135, 0, 1295, 137, 138, 1296, 140, 141, 142, 143, 1083, 1297, 1084, 1085, 0, 1298, 148, 149, @@ -5927,7 +5767,7 @@ static const yytype_int16 yytable[] = 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, + 1303, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, @@ -5943,7 +5783,7 @@ static const yytype_int16 yytable[] = 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 1104, 1316, 1105, 332, 333, 334, 335, 1106, 336, 337, 1317, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, - 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, + 346, 347, 0, 0, 1109, 349, 350, 0, 897, 351, 352, 353, 1318, 355, 1319, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, 1320, 374, 375, 376, 377, @@ -5961,66 +5801,68 @@ static const yytype_int16 yytable[] = 474, 816, 476, 817, 1115, 478, 479, 1326, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1327, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 498, 1117, 500, 2403, 501, 1329, 503, 504, 505, 506, + 498, 1117, 500, 1328, 501, 1329, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, - 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, - 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 0, + 0, 0, 0, 1122, 0, 1123, 1330, 0, 0, 0, + 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, - 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, + 1479, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, - 163, 806, 0, 807, 0, 166, 167, 168, 169, 170, + 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 0, - 198, 0, 199, 200, 201, 202, 203, 204, 14, 15, + 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, + 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, - 0, 238, 0, 239, 240, 23, 241, 242, 243, 244, + 0, 238, 0, 239, 240, 1480, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, 283, 284, 285, 286, 287, 288, - 289, 290, 0, 291, 292, 293, 0, 0, 294, 295, + 289, 290, 1102, 291, 292, 293, 0, 1481, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 1104, 330, 1105, 332, 333, 334, - 335, 0, 336, 337, 338, 339, 1107, 810, 341, 1108, - 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, + 335, 1106, 336, 337, 338, 339, 1107, 810, 341, 1108, + 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 26, 27, 28, 0, 370, 371, 813, 373, + 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 33, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 35, 438, 439, 440, 1112, 442, 0, 443, 444, 445, + 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 815, 37, 0, 460, 461, 38, 462, + 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, - 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, + 1114, 0, 1482, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, - 487, 488, 0, 40, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 819, 1117, 500, 0, 501, 502, + 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, + 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, - 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, + 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 0, 0, 45, 0, 0, 1291, 1076, - 836, 1077, 1078, 1079, 1080, 1081, 0, 1122, 0, 1123, - 0, 0, 0, 0, 1124, 1125, 1126, 1127, 122, 123, + 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, + 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, + 0, 0, 0, 0, 1124, 1125, 1126, 1127, 1291, 1076, + 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 1293, 0, 1082, 0, 0, 1294, 134, 135, 0, 1295, 137, 138, 1296, 140, 141, 142, 143, @@ -6066,129 +5908,127 @@ static const yytype_int16 yytable[] = 476, 817, 1115, 478, 479, 1326, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1327, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, - 500, 0, 501, 1329, 503, 504, 505, 506, 507, 508, + 500, 2404, 501, 1329, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, - 0, 1122, 0, 1123, 3301, 0, 0, 0, 1124, 1125, - 1126, 1127, 1291, 1076, 836, 1077, 1078, 1079, 1080, 1081, + 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, + 1126, 1127, 121, 1076, 836, 1077, 1078, 0, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 1293, 0, 1082, - 0, 0, 1294, 134, 135, 0, 1295, 137, 138, 1296, - 140, 141, 142, 143, 1083, 1297, 1084, 1085, 0, 1298, + 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, + 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, + 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, - 0, 1299, 0, 1300, 167, 168, 169, 170, 171, 1301, + 0, 807, 0, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, - 0, 1302, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, - 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 1090, 194, 195, 1091, 197, 0, 198, 0, + 199, 200, 201, 202, 203, 204, 14, 15, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, - 0, 239, 1304, 0, 1305, 242, 243, 1306, 1307, 246, + 0, 239, 240, 23, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, - 255, 256, 257, 258, 259, 1308, 261, 262, 263, 264, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, - 1309, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, - 1101, 0, 283, 1310, 1311, 286, 1312, 288, 289, 290, - 1102, 291, 292, 293, 0, 0, 294, 1313, 296, 1314, - 0, 298, 299, 300, 301, 302, 303, 304, 305, 1315, + 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, + 1101, 0, 283, 284, 285, 286, 287, 288, 289, 290, + 0, 291, 292, 293, 0, 0, 294, 295, 296, 297, + 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 1104, 1316, 1105, 332, 333, 334, 335, 1106, - 336, 337, 1317, 339, 1107, 810, 341, 1108, 343, 344, - 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, - 0, 351, 352, 353, 1318, 355, 1319, 812, 358, 359, + 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 0, + 336, 337, 338, 339, 1107, 810, 341, 1108, 343, 344, + 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, + 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 0, 0, 0, 0, 370, 371, 813, 1320, 374, 375, + 26, 27, 28, 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 0, 409, 410, 1321, + 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 427, 428, 0, 1322, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, 1323, + 422, 423, 424, 425, 426, 427, 428, 33, 0, 429, + 430, 431, 432, 433, 434, 435, 436, 437, 35, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 1324, - 458, 815, 0, 0, 460, 461, 0, 462, 1325, 464, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 815, 37, 0, 460, 461, 38, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, - 0, 473, 474, 816, 476, 817, 1115, 478, 479, 1326, + 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, - 1327, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 1117, 500, 0, 501, 1329, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, + 0, 40, 489, 490, 491, 492, 0, 493, 494, 495, + 496, 497, 819, 1117, 500, 0, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 0, 0, 510, 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, - 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, - 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, - 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 128, 129, -1196, 130, 131, 132, 0, 0, - 0, 0, -1196, 1082, 0, 0, 133, 134, 135, 0, - 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, - 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, + 531, 0, 0, 45, 0, 0, 1291, 1076, 836, 1077, + 1078, 1079, 1080, 1081, 0, 1122, 0, 1123, 0, 0, + 0, 0, 1124, 1125, 1126, 1127, 122, 123, 124, 125, + 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, + 0, 1293, 0, 1082, 0, 0, 1294, 134, 135, 0, + 1295, 137, 138, 1296, 140, 141, 142, 143, 1083, 1297, + 1084, 1085, 0, 1298, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, - 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, - 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, + 161, 162, 163, 806, 0, 1299, 0, 1300, 167, 168, + 169, 170, 171, 1301, 173, 174, 175, 0, 176, 177, + 178, 179, 180, 181, 0, 1302, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, - 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, - 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, - 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, + 1096, 237, 0, 238, 0, 239, 1304, 0, 1305, 242, + 243, 1306, 1307, 246, 247, 248, 0, 1097, 1098, 251, + 252, 0, 253, 254, 255, 256, 257, 258, 259, 1308, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, - 279, 1099, 1100, 0, 1101, 0, 283, 284, 285, 286, - 287, 288, 289, 290, 1102, 291, 292, 293, 0, 0, - 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, - 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, + 270, 271, 0, 272, 1309, 274, 275, 276, 277, 278, + 279, 1099, 1100, 0, 1101, 0, 283, 1310, 1311, 286, + 1312, 288, 289, 290, 1102, 291, 292, 293, 0, 0, + 294, 1313, 296, 1314, 0, 298, 299, 300, 301, 302, + 303, 304, 305, 1315, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 1104, 330, 1105, 332, - 333, 334, 335, 1106, 336, 337, 338, 339, 1107, 810, + 323, 324, 325, 326, 327, 328, 1104, 1316, 1105, 332, + 333, 334, 335, 1106, 336, 337, 1317, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, - 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, - 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, + 1109, 349, 350, 0, 0, 351, 352, 353, 1318, 355, + 1319, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, - 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, + 813, 1320, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, + 0, 409, 410, 1321, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 0, 438, 439, 440, 1112, 442, -1196, 443, + 428, 0, 1322, 429, 430, 431, 432, 433, 434, 435, + 436, 437, 0, 1323, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, - 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, + 454, 455, 456, 1324, 458, 815, 0, 0, 460, 461, + 0, 462, 1325, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, - 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, + 1115, 478, 479, 1326, 481, 482, 483, 484, 485, 0, + 0, 486, 487, 488, 1327, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, + 501, 1329, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, - 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, - 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, + 0, 1123, 3255, 0, 0, 0, 1124, 1125, 1126, 1127, + 1291, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 1756, 130, - 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, - 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, - 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, + 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, + 131, 132, 0, 0, 0, 1293, 0, 1082, 0, 0, + 1294, 134, 135, 0, 1295, 137, 138, 1296, 140, 141, + 142, 143, 1083, 1297, 1084, 1085, 0, 1298, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, - 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, - 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, + 1088, 159, 0, 160, 161, 162, 163, 806, 0, 1299, + 0, 1300, 167, 168, 169, 170, 171, 1301, 173, 174, + 175, 0, 176, 177, 178, 179, 180, 181, 0, 1302, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, @@ -6196,47 +6036,47 @@ static const yytype_int16 yytable[] = 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, - 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, + 1304, 0, 1305, 242, 243, 1306, 1307, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, + 257, 258, 259, 1308, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 0, 272, 1309, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, - 283, 284, 285, 286, 287, 288, 289, 290, 1102, 291, - 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, - 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, + 283, 1310, 1311, 286, 1312, 288, 289, 290, 1102, 291, + 292, 293, 0, 0, 294, 1313, 296, 1314, 0, 298, + 299, 300, 301, 302, 303, 304, 305, 1315, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 1104, 330, 1105, 332, 333, 334, 335, 1106, 336, 337, - 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, + 1104, 1316, 1105, 332, 333, 334, 335, 1106, 336, 337, + 1317, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, - 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, + 352, 353, 1318, 355, 1319, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, - 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, + 0, 0, 370, 371, 813, 1320, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, + 405, 406, 407, 408, 0, 409, 410, 1321, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, + 424, 425, 426, 427, 428, 0, 1322, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 0, 1323, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, - 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, + 450, 451, 452, 453, 454, 455, 456, 1324, 458, 815, + 0, 0, 460, 461, 0, 462, 1325, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, - 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, + 474, 816, 476, 817, 1115, 478, 479, 1326, 481, 482, + 483, 484, 485, 0, 0, 486, 487, 488, 1327, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, + 498, 1117, 500, 0, 501, 1329, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, - 1124, 1125, 1126, 1127, 121, 1771, 836, 1077, 1078, 1079, - 1772, 1081, 0, 0, 0, 0, 0, 0, 0, 0, + 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, + 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 128, 129, 1773, 130, 131, 132, 0, 0, 0, 0, - 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, + 128, 129, -1202, 130, 131, 132, 0, 0, 0, 0, + -1202, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, @@ -6272,7 +6112,7 @@ static const yytype_int16 yytable[] = 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, + 0, 438, 439, 440, 1112, 442, -1202, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, @@ -6288,7 +6128,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, - 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, + 124, 125, 126, 127, 128, 129, 1756, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, @@ -6302,7 +6142,7 @@ static const yytype_int16 yytable[] = 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, - 234, 235, 1096, 237, 0, 238, 0, 239, 240, 1480, + 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, @@ -6339,10 +6179,10 @@ static const yytype_int16 yytable[] = 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, - 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, + 1126, 1127, 121, 1771, 836, 1077, 1078, 1079, 1772, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, + 1773, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, @@ -6391,10 +6231,10 @@ static const yytype_int16 yytable[] = 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, - 1121, 0, 0, 0, 0, 1122, 0, 1123, 2151, 0, + 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, - 0, 0, 2808, 0, 0, 0, 122, 123, 124, 125, + 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, @@ -6409,7 +6249,7 @@ static const yytype_int16 yytable[] = 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, - 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, + 1096, 237, 0, 238, 0, 239, 240, 1480, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, @@ -6488,7 +6328,7 @@ static const yytype_int16 yytable[] = 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, - 0, 0, 460, 461, 2875, 462, 463, 464, 465, 466, + 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, @@ -6498,10 +6338,10 @@ static const yytype_int16 yytable[] = 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, - 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, + 0, 0, 0, 1122, 0, 1123, 2151, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 2810, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, @@ -6547,7 +6387,7 @@ static const yytype_int16 yytable[] = 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 0, 2999, 510, + 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, @@ -6555,14 +6395,14 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, - 124, 125, 126, 127, 128, 129, 3238, 130, 131, 132, + 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, - 176, 177, 178, 179, 180, 181, 0, 182, 183, 3239, + 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, @@ -6570,7 +6410,7 @@ static const yytype_int16 yytable[] = 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, - 241, 242, 243, 244, 245, 246, 247, 248, 0, 3240, + 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, @@ -6589,13 +6429,13 @@ static const yytype_int16 yytable[] = 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 411, 412, 413, 3241, 1111, + 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, - 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, + 460, 461, 2877, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, @@ -6605,9 +6445,9 @@ static const yytype_int16 yytable[] = 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, - 0, 1122, 0, 3242, 0, 0, 0, 0, 1124, 1125, + 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, - 0, 0, 0, 0, 0, 0, 0, 0, 3474, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, @@ -6654,7 +6494,7 @@ static const yytype_int16 yytable[] = 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, + 505, 506, 507, 508, 509, 0, 3001, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, @@ -6662,14 +6502,14 @@ static const yytype_int16 yytable[] = 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, + 126, 127, 128, 129, 3192, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, + 178, 179, 180, 181, 0, 182, 183, 3193, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, @@ -6677,7 +6517,7 @@ static const yytype_int16 yytable[] = 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, - 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, + 243, 244, 245, 246, 247, 248, 0, 3194, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, @@ -6696,7 +6536,7 @@ static const yytype_int16 yytable[] = 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, + 0, 409, 410, 411, 412, 413, 3195, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, @@ -6712,9 +6552,9 @@ static const yytype_int16 yytable[] = 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, - 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, + 0, 3196, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3428, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, @@ -6764,9 +6604,9 @@ static const yytype_int16 yytable[] = 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, - 0, 0, 0, 0, 0, 0, 1776, 1777, 1121, 0, + 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, - 1124, 1125, 1126, 1127, 121, 2294, 836, 1077, 1078, 1079, + 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, @@ -6871,9 +6711,9 @@ static const yytype_int16 yytable[] = 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, - 0, 0, 0, 0, 1119, 2394, 1121, 0, 0, 0, + 0, 0, 0, 0, 1776, 1777, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, - 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, + 1126, 1127, 121, 2294, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, @@ -6925,7 +6765,7 @@ static const yytype_int16 yytable[] = 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, - 1121, 0, 0, 0, 0, 1122, 0, 2653, 0, 0, + 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, @@ -6978,7 +6818,7 @@ static const yytype_int16 yytable[] = 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, - 0, 0, 1119, 3299, 1121, 0, 0, 0, 0, 1122, + 0, 0, 1119, 2395, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, @@ -6990,7 +6830,7 @@ static const yytype_int16 yytable[] = 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, - 183, 3239, 185, 186, 187, 188, 189, 190, 191, 192, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, @@ -6998,7 +6838,7 @@ static const yytype_int16 yytable[] = 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, - 0, 3240, 1098, 251, 252, 0, 253, 254, 255, 256, + 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, @@ -7017,7 +6857,7 @@ static const yytype_int16 yytable[] = 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, - 3241, 1111, 416, 417, 418, 419, 420, 421, 422, 423, + 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, @@ -7032,18 +6872,18 @@ static const yytype_int16 yytable[] = 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, - 0, 0, 0, 1122, 0, 3242, 0, 0, 0, 0, + 0, 0, 0, 1122, 0, 2654, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, - 138, 139, 140, 141, 142, 3741, 1083, 145, 1084, 1085, + 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, - 180, 181, 0, 182, 183, 184, 3742, 186, 187, 188, + 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, @@ -7078,14 +6918,14 @@ static const yytype_int16 yytable[] = 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, - 479, 818, 481, 482, 3743, 484, 485, 0, 0, 486, + 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, - 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, + 1119, 3253, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, @@ -7096,15 +6936,15 @@ static const yytype_int16 yytable[] = 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, - 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, - 3742, 186, 187, 188, 189, 190, 191, 192, 1090, 194, + 176, 177, 178, 179, 180, 181, 0, 182, 183, 3193, + 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, - 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, + 241, 242, 243, 244, 245, 246, 247, 248, 0, 3194, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, @@ -7123,7 +6963,7 @@ static const yytype_int16 yytable[] = 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, + 407, 408, 0, 409, 410, 411, 412, 413, 3195, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, @@ -7131,7 +6971,7 @@ static const yytype_int16 yytable[] = 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, - 476, 817, 1115, 478, 479, 818, 481, 482, 3743, 484, + 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, @@ -7139,36 +6979,36 @@ static const yytype_int16 yytable[] = 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, - 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, + 0, 1122, 0, 3196, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, - 140, 141, 142, -2183, 1083, 145, 1084, 1085, 0, 0, + 140, 141, 142, 3757, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, - 0, 182, 183, 184, 3742, 186, 187, 188, 189, 190, + 0, 182, 183, 184, 3758, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, - 0, 239, 240, 0, 241, 242, 243, 244, -2183, 246, + 0, 239, 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, - 255, 256, 257, 258, 259, -2183, 261, 262, 263, 264, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, - 1101, 0, 283, 0, 0, 286, 287, 288, 289, 290, - 1102, 291, 292, 293, 0, 0, 294, 295, 296, -2183, + 1101, 0, 283, 284, 285, 286, 287, 288, 289, 290, + 1102, 291, 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 0, - 336, 337, 0, 339, 1107, 810, 341, 1108, 343, 344, + 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 1106, + 336, 337, 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, @@ -7179,19 +7019,19 @@ static const yytype_int16 yytable[] = 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, -2183, + 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, - 481, 482, 3743, 484, 485, 0, 0, 486, 487, 488, + 481, 482, 3759, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, -2183, 0, 0, 0, 0, 0, 0, 1119, 1120, + 531, 1118, 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, @@ -7201,11 +7041,11 @@ static const yytype_int16 yytable[] = 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, - 161, 162, 163, 806, 0, 807, 0, 166, 167, 168, + 161, 162, 163, 806, 0, 807, 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, + 178, 179, 180, 181, 0, 182, 183, 184, 3758, 186, 187, 188, 189, 190, 191, 192, 1090, 194, 195, 1091, - 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, + 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, @@ -7216,12 +7056,12 @@ static const yytype_int16 yytable[] = 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, 283, 284, 285, 286, - 287, 288, 289, 290, 0, 291, 292, 293, 0, 0, + 287, 288, 289, 290, 1102, 291, 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 1104, 330, 1105, 332, - 333, 334, 335, 0, 336, 337, 338, 339, 1107, 810, + 333, 334, 335, 1106, 336, 337, 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, @@ -7238,45 +7078,45 @@ static const yytype_int16 yytable[] = 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, - 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, + 1115, 478, 479, 818, 481, 482, 3759, 484, 485, 0, + 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 0, 0, 0, 0, 0, - 0, 0, 1466, 1467, 0, 0, 0, 0, 0, 1122, + 527, 528, 529, 530, 531, 1118, 0, 0, 0, 0, + 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, - 121, 1076, 836, 1077, 1078, 0, 1080, 1081, 0, 0, + 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, - 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, + 142, -2189, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, - 0, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 1090, 194, 195, 1091, 197, 0, 198, 0, 199, 200, + 183, 184, 3758, 186, 187, 188, 189, 190, 191, 192, + 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, - 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, + 240, 0, 241, 242, 243, 244, -2189, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, + 257, 258, 259, -2189, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, - 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, - 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, + 283, 0, 0, 286, 287, 288, 289, 290, 1102, 291, + 292, 293, 0, 0, 294, 295, 296, -2189, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 0, 336, 337, - 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, - 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, + 0, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, + 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, @@ -7284,21 +7124,21 @@ static const yytype_int16 yytable[] = 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, - 414, 2280, 2281, 417, 418, 419, 420, 421, 422, 423, + 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, + 432, 433, 434, 435, 436, 437, 0, -2189, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, + 3759, 484, 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, - 523, 524, 525, 526, 527, 528, 529, 530, 531, 0, - 0, 0, 0, 0, 0, 0, 2282, 2283, 0, 0, + 523, 524, 525, 526, 527, 528, 529, 530, 531, -2189, + 0, 0, 0, 0, 0, 0, 1119, 1120, 1121, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 0, 0, 0, 0, 0, 0, 0, @@ -7322,7 +7162,7 @@ static const yytype_int16 yytable[] = 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, - 1100, 0, 1101, 0, 283, 0, 285, 286, 287, 288, + 1100, 0, 1101, 0, 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, @@ -7371,7 +7211,7 @@ static const yytype_int16 yytable[] = 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, - 241, 242, 243, 244, 245, 246, 247, 248, 3260, 1097, + 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, @@ -7390,8 +7230,8 @@ static const yytype_int16 yytable[] = 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 411, 412, 413, 414, 415, - 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 407, 408, 0, 409, 410, 411, 412, 413, 414, 2280, + 2281, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, @@ -7405,9 +7245,11 @@ static const yytype_int16 yytable[] = 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 0, 0, 0, - 0, 0, 121, 1076, 836, 1077, 1078, 0, 1080, 1081, - 0, 1122, 0, 2922, 0, 0, 0, 0, 1124, 1125, - 1126, 1127, 122, 123, 124, 125, 126, 127, 128, 129, + 0, 0, 0, 0, 2282, 2283, 0, 0, 0, 0, + 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, + 1126, 1127, 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, @@ -7427,14 +7269,14 @@ static const yytype_int16 yytable[] = 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, - 1101, 0, 283, 284, 285, 286, 287, 288, 289, 290, + 1101, 0, 283, 0, 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 0, 336, 337, 338, 339, 1107, 810, 341, 1108, 343, 344, - 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, + 345, 0, 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, @@ -7442,7 +7284,7 @@ static const yytype_int16 yytable[] = 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, @@ -7456,9 +7298,11 @@ static const yytype_int16 yytable[] = 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 0, 0, 0, 0, 0, 121, 1076, 836, 1077, - 1078, 0, 1080, 1081, 0, 1122, 0, 2922, 0, 0, - 0, 0, 1124, 1125, 1126, 1127, 122, 123, 124, 125, + 531, 0, 0, 0, 0, 0, 0, 0, 1466, 1467, + 0, 0, 0, 0, 0, 1122, 0, 1123, 0, 0, + 0, 0, 1124, 1125, 1126, 1127, 121, 1076, 836, 1077, + 1078, 0, 1080, 1081, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 1083, 145, @@ -7474,7 +7318,7 @@ static const yytype_int16 yytable[] = 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, - 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, + 243, 244, 245, 246, 247, 248, 3214, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, @@ -7493,7 +7337,7 @@ static const yytype_int16 yytable[] = 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 411, 412, 413, 414, 1111, 416, 417, + 0, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, @@ -7508,36 +7352,36 @@ static const yytype_int16 yytable[] = 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 0, 0, 0, 0, 0, - 121, 1076, 836, 1077, 1078, 1079, 1080, 1081, 0, 1122, - 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, + 121, 1076, 836, 1077, 1078, 0, 1080, 1081, 0, 1122, + 0, 2924, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, - 142, 0, 1083, 145, 1084, 1085, 0, 0, 148, 149, + 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, - 0, 1089, 167, 168, 169, 170, 171, 172, 173, 174, + 0, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 1090, 194, 195, 1091, 197, 1092, 198, 0, 199, 200, + 1090, 194, 195, 1091, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 0, 220, 0, 221, 222, 223, + 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, - 240, 0, 241, 242, 243, 244, 0, 246, 247, 248, + 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, + 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, 1100, 0, 1101, 0, - 283, 0, 0, 286, 287, 288, 289, 290, 1102, 291, - 292, 293, 0, 0, 294, 295, 296, 0, 0, 298, + 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, + 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 1104, 330, 1105, 332, 333, 334, 335, 0, 336, 337, - 0, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, - 346, 347, 0, 0, 1109, 349, 350, 0, 0, 351, + 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, + 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, @@ -7545,76 +7389,230 @@ static const yytype_int16 yytable[] = 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, - 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, + 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 1116, 0, + 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 0, - 0, 0, 0, 0, 121, 0, 1119, 1120, 1121, 0, - 0, 1081, 0, 1122, 0, 1123, 0, 0, 0, 0, + 0, 0, 0, 0, 121, 1076, 836, 1077, 1078, 0, + 1080, 1081, 0, 1122, 0, 2924, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, 135, 0, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 138, 139, 140, 141, 142, 143, 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, 152, 1086, 805, 153, - 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, + 154, 155, 156, 1087, 1088, 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, + 189, 190, 191, 192, 1090, 194, 195, 1091, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, - 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, + 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 808, 0, 233, 0, 234, 235, 236, 237, + 0, 221, 222, 223, 224, 1094, 226, 227, 228, 229, + 230, 231, 808, 1095, 233, 0, 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, 241, 242, 243, 244, - 245, 246, 247, 248, 0, 249, 250, 251, 252, 0, + 245, 246, 247, 248, 0, 1097, 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, - 0, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 0, 282, 0, 283, 284, 285, 286, 287, 288, + 0, 272, 273, 274, 275, 276, 277, 278, 279, 1099, + 1100, 0, 1101, 0, 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 0, 336, 337, 338, 339, 0, 810, 341, 342, + 325, 326, 327, 328, 1104, 330, 1105, 332, 333, 334, + 335, 0, 336, 337, 338, 339, 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, - 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, + 383, 384, 385, 0, 386, 387, 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 410, 411, 412, 413, 414, 1111, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 0, 438, 439, 440, 441, 442, 0, 443, 444, 445, + 0, 438, 439, 440, 1112, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, - 463, 464, 465, 466, 467, 468, 469, 0, 470, 471, - 472, 0, 0, 473, 474, 816, 476, 817, 0, 478, + 463, 464, 465, 466, 467, 468, 469, 0, 470, 1113, + 1114, 0, 0, 473, 474, 816, 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 498, 499, 500, 0, 501, 502, + 494, 495, 496, 497, 498, 1117, 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 0, 0, 0, 0, 0, 539, 2032, - 0, 0, 0, 0, 2033, 1081, 0, 1122, 0, 2198, + 529, 530, 531, 0, 0, 0, 0, 0, 121, 1076, + 836, 1077, 1078, 1079, 1080, 1081, 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, 1126, 1127, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, + 0, 0, 0, 0, 0, 1082, 0, 0, 133, 134, + 135, 0, 136, 137, 138, 139, 140, 141, 142, 0, + 1083, 145, 1084, 1085, 0, 0, 148, 149, 150, 151, + 152, 1086, 805, 153, 154, 155, 156, 1087, 1088, 159, + 0, 160, 161, 162, 163, 806, 0, 807, 0, 1089, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, + 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 1090, 194, + 195, 1091, 197, 1092, 198, 0, 199, 200, 201, 202, + 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, + 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 0, 220, 0, 221, 222, 223, 224, 1094, + 226, 227, 228, 229, 230, 231, 808, 1095, 233, 0, + 234, 235, 1096, 237, 0, 238, 0, 239, 240, 0, + 241, 242, 243, 244, 0, 246, 247, 248, 0, 1097, + 1098, 251, 252, 0, 253, 254, 255, 256, 257, 258, + 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, + 277, 278, 279, 1099, 1100, 0, 1101, 0, 283, 0, + 0, 286, 287, 288, 289, 290, 1102, 291, 292, 293, + 0, 0, 294, 295, 296, 0, 0, 298, 299, 300, + 301, 302, 303, 304, 305, 1103, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 1104, 330, + 1105, 332, 333, 334, 335, 0, 336, 337, 0, 339, + 1107, 810, 341, 1108, 343, 344, 345, 0, 346, 347, + 0, 0, 1109, 349, 350, 0, 0, 351, 352, 353, + 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, + 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, + 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, + 388, 389, 390, 1110, 392, 393, 394, 395, 0, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 0, 409, 410, 411, 412, 413, 414, 1111, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, + 434, 435, 436, 437, 0, 0, 439, 440, 1112, 442, + 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, + 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, + 469, 0, 470, 1113, 1114, 0, 0, 473, 474, 816, + 476, 817, 1115, 478, 479, 818, 481, 482, 483, 484, + 485, 0, 0, 486, 487, 488, 1116, 0, 489, 490, + 491, 492, 0, 493, 494, 495, 496, 497, 498, 1117, + 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, + 525, 526, 527, 528, 529, 530, 531, 0, 0, 0, + 0, 0, 121, 0, 1119, 1120, 1121, 0, 0, 1081, + 0, 1122, 0, 1123, 0, 0, 0, 0, 1124, 1125, + 1126, 1127, 122, 123, 124, 125, 126, 127, 128, 129, + 0, 130, 131, 132, 0, 0, 0, 0, 0, 1082, + 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 0, 0, + 148, 149, 150, 151, 152, 1086, 805, 153, 154, 155, + 156, 157, 158, 159, 0, 160, 161, 162, 163, 806, + 0, 807, 0, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, + 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, + 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 808, 0, 233, 0, 234, 235, 236, 237, 0, 238, + 0, 239, 240, 0, 241, 242, 243, 244, 245, 246, + 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 0, + 282, 0, 283, 284, 285, 286, 287, 288, 289, 290, + 0, 291, 292, 293, 0, 0, 294, 295, 296, 297, + 0, 298, 299, 300, 301, 302, 303, 304, 305, 1103, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 0, + 336, 337, 338, 339, 0, 810, 341, 342, 343, 344, + 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, + 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, + 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, + 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, + 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, + 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 815, 0, 0, 460, 461, 0, 462, 463, 464, + 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, + 0, 473, 474, 816, 476, 817, 0, 478, 479, 818, + 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, + 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, + 496, 497, 498, 499, 500, 0, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, + 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, + 531, 0, 0, 0, 0, 0, 539, 2032, 0, 0, + 0, 0, 2033, 1081, 0, 1122, 0, 2198, 0, 0, + 0, 0, 1124, 1125, 1126, 1127, 122, 123, 124, 125, + 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, + 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, + 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, + 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, + 161, 162, 163, 164, 0, 0, 0, 166, 167, 168, + 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, + 178, 179, 180, 181, 0, 0, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, + 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, + 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, + 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, + 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, + 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, + 294, 0, 296, 0, 0, 298, 299, 300, 301, 302, + 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, + 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, + 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, + 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, + 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, + 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, + 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, + 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, + 0, 462, 0, 464, 465, 466, 467, 468, 469, 0, + 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, + 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, + 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, + 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, + 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, + 527, 528, 529, 530, 531, 0, 0, 0, 539, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1124, 1125, 122, 123, + 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, + 0, 0, 0, 0, 0, 0, 1030, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, @@ -7625,22 +7623,22 @@ static const yytype_int16 yytable[] = 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, - 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, + 217, 218, 219, 220, -591, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 232, 0, 233, -591, + 234, 235, 236, 237, -591, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, - 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, + 277, 278, 279, 280, 281, -591, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, 293, - 0, 0, 294, 0, 296, 0, 0, 298, 299, 300, + 0, 0, 294, 0, 296, 0, -591, 298, 299, 300, 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, 337, 0, 339, - 0, 340, 341, 342, 343, 344, 345, 0, 346, 347, - 0, 0, 348, 349, 350, 0, 0, 351, 352, 353, + 0, 340, 341, 342, 343, 344, 345, -591, 346, 347, + 0, 0, 348, 349, 350, 0, -591, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, 378, 379, @@ -7656,470 +7654,317 @@ static const yytype_int16 yytable[] = 460, 461, 0, 462, 0, 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, - 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, + 485, -591, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, - 525, 526, 527, 528, 529, 530, 531, 0, 0, 0, - 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1124, 1125, - 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, - 131, 132, 0, 0, 0, 0, 0, 0, 1030, 0, - 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, - 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, - 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, - 158, 159, 0, 160, 161, 162, 163, 164, 0, 0, - 0, 166, 167, 168, 169, 170, 171, 0, 173, 174, - 175, 0, 176, 177, 178, 179, 180, 181, 0, 0, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, + 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1199, 0, 0, 122, 123, 124, + 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, + 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, + 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, + 0, 0, 153, 154, 155, 156, 157, 158, 159, 0, + 160, 161, 162, 163, 164, 0, 0, 0, 166, 167, + 168, 169, 170, 171, 0, 173, 174, 175, 0, 176, + 177, 178, 179, 180, 181, 0, 0, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, + 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, + 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 0, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, + 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, + 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, + 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, + 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, + 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, + 286, 0, 288, 289, 290, 0, 291, 292, 293, 0, + 0, 294, 0, 296, 0, 0, 298, 299, 300, 301, + 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, + 332, 333, 334, 335, 0, 336, 337, 0, 339, 0, + 340, 341, 342, 343, 344, 345, 0, 346, 347, 0, + 0, 348, 349, 350, 0, 0, 351, 352, 353, 0, + 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, + 371, 372, 0, 374, 375, 376, 377, 378, 379, 0, + 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, + 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, + 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, + 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, + 461, 0, 462, 0, 464, 465, 466, 467, 468, 469, + 0, 470, 471, 472, 0, 0, 473, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, + 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, + 492, 0, 493, 494, 495, 496, 497, 498, 499, 500, + 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, + 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, + 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, + 526, 527, 528, 529, 530, 531, 2462, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 2600, 3414, 0, 0, 122, 123, 124, 125, + 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, + 0, 1293, 0, 0, 0, 0, 2463, 134, 135, 0, + 2464, 137, 138, 2465, 140, 141, 142, 0, 0, 2466, + 0, 0, 0, 1298, 148, 149, 150, 151, 152, 0, + 0, 153, 154, 155, 156, 0, 0, 159, 0, 160, + 161, 162, 163, 0, 0, 2467, 0, 2468, 167, 168, + 169, 170, 171, 2469, 173, 174, 175, 0, 176, 177, + 178, 179, 180, 181, 0, 2470, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 0, 194, 195, 0, + 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 0, 221, 222, 223, 224, 0, 226, 227, + 228, 229, 230, 231, 0, 0, 233, 0, 234, 235, + 0, 237, 0, 238, 0, 239, 2471, 0, 2472, 242, + 243, 2473, 2474, 246, 247, 248, 0, 0, 0, 251, + 252, 0, 253, 254, 255, 256, 257, 258, 259, 2475, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 0, 272, 2476, 0, 275, 276, 277, 278, + 279, 0, 0, 0, 0, 0, 283, 2477, 2478, 286, + 2479, 288, 289, 290, 0, 291, 292, 293, 0, 0, + 294, 2480, 296, 2481, 0, 298, 299, 300, 301, 302, + 303, 304, 305, 2482, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 0, 2483, 0, 332, + 333, 334, 0, 0, 336, 337, 2484, 339, 0, 0, + 341, 0, 343, 344, 345, 0, 346, 347, 0, 0, + 348, 349, 350, 0, 0, 351, 352, 0, 2485, 355, + 2486, 0, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, + 0, 2487, 374, 375, 0, 377, 378, 379, 0, 380, + 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, + 390, 0, 392, 393, 394, 395, 0, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 0, 409, 410, 2488, 412, 413, 414, 0, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 0, 1322, 429, 430, 431, 432, 433, 434, 0, + 436, 437, 0, 2489, 439, 440, 0, 442, 0, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 2490, 458, 0, 0, 0, 460, 461, + 0, 462, 2491, 464, 465, 466, 467, 468, 469, 0, + 470, 0, 0, 0, 0, 473, 474, 0, 476, 0, + 0, 478, 479, 2492, 481, 482, 483, 484, 485, 0, + 0, 486, 487, 488, 2493, 0, 489, 490, 491, 492, + 0, 493, 494, 495, 496, 497, 0, 0, 500, 0, + 501, 2494, 503, 504, 505, 506, 507, 508, 509, 0, + 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, + 2462, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 528, 529, 530, 531, 0, 0, 0, 0, 0, + 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, + 131, 132, 2495, 0, 0, 1293, 0, 0, 0, 0, + 2463, 134, 135, 0, 2464, 137, 138, 2465, 140, 141, + 142, 0, 0, 2466, 0, 0, 0, 1298, 148, 149, + 150, 151, 152, 0, 0, 153, 154, 155, 156, 0, + 0, 159, 0, 160, 161, 162, 163, 0, 0, 2467, + 0, 2468, 167, 168, 169, 170, 171, 2469, 173, 174, + 175, 0, 176, 177, 178, 179, 180, 181, 0, 2470, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 0, 194, 195, 0, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, -585, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 232, 0, - 233, -585, 234, 235, 236, 237, -585, 238, 0, 239, - 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, - 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, - 275, 276, 277, 278, 279, 280, 281, -585, 282, 0, - 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, - 292, 293, 0, 0, 294, 0, 296, 0, -585, 298, - 299, 300, 301, 302, 303, 304, 305, 541, 307, 308, + 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, + 224, 0, 226, 227, 228, 229, 230, 231, 0, 0, + 233, 0, 234, 235, 0, 237, 0, 238, 0, 239, + 2471, 0, 2472, 242, 243, 2473, 2474, 246, 247, 248, + 0, 0, 0, 251, 252, 0, 253, 254, 255, 256, + 257, 258, 259, 2475, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 0, 272, 2476, 0, + 275, 276, 277, 278, 279, 0, 0, 0, 0, 0, + 283, 2477, 2478, 286, 2479, 288, 289, 290, 0, 291, + 292, 293, 0, 0, 294, 2480, 296, 2481, 0, 298, + 299, 300, 301, 302, 303, 304, 305, 2482, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 0, 331, 332, 333, 334, 335, 0, 336, 337, - 0, 339, 0, 340, 341, 342, 343, 344, 345, -585, - 346, 347, 0, 0, 348, 349, 350, 0, -585, 351, - 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, + 0, 2483, 0, 332, 333, 334, 0, 0, 336, 337, + 2484, 339, 0, 0, 341, 0, 343, 344, 345, 0, + 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, + 352, 0, 2485, 355, 2486, 0, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, - 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, + 0, 0, 370, 371, 0, 2487, 374, 375, 0, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 386, 387, 388, 389, 390, 0, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, - 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, - 0, 0, 460, 461, 0, 462, 0, 464, 465, 466, - 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, - 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, - 483, 484, 485, -585, 0, 486, 487, 488, 0, 0, + 405, 406, 407, 408, 0, 409, 410, 2488, 412, 413, + 414, 0, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, 427, 428, 0, 1322, 429, 430, 431, + 432, 433, 434, 0, 436, 437, 0, 2489, 439, 440, + 0, 442, 0, 443, 444, 445, 446, 447, 448, 449, + 450, 451, 452, 453, 454, 455, 456, 2490, 458, 0, + 0, 0, 460, 461, 0, 462, 2491, 464, 465, 466, + 467, 468, 469, 0, 470, 0, 0, 0, 0, 473, + 474, 0, 476, 0, 0, 478, 479, 2492, 481, 482, + 483, 484, 485, 0, 0, 486, 487, 488, 2493, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, + 0, 0, 500, 0, 501, 2494, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, - 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, - 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1199, 0, 0, 122, - 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, - 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, - 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, - 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, - 159, 0, 160, 161, 162, 163, 164, 0, 0, 0, - 166, 167, 168, 169, 170, 171, 0, 173, 174, 175, - 0, 176, 177, 178, 179, 180, 181, 0, 0, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, - 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, - 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 0, 233, - 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, - 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, - 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, - 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, - 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, - 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, - 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, - 293, 0, 0, 294, 0, 296, 0, 0, 298, 299, - 300, 301, 302, 303, 304, 305, 541, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 0, 331, 332, 333, 334, 335, 0, 336, 337, 0, - 339, 0, 340, 341, 342, 343, 344, 345, 0, 346, - 347, 0, 0, 348, 349, 350, 0, 0, 351, 352, - 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, - 0, 370, 371, 372, 0, 374, 375, 376, 377, 378, - 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, - 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 0, 409, 410, 0, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, - 433, 434, 435, 436, 437, 0, 0, 439, 440, 441, - 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, - 0, 460, 461, 0, 462, 0, 464, 465, 466, 467, - 468, 469, 0, 470, 471, 472, 0, 0, 473, 474, - 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, - 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, - 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, - 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, - 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, - 524, 525, 526, 527, 528, 529, 530, 531, 2461, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 2599, 3460, 0, 0, 122, 123, + 513, 514, 515, 516, 0, 0, 0, 0, 994, 0, + 0, 0, 0, 0, 0, 528, 529, 530, 531, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, + 124, 125, 126, 127, 128, 129, 3166, 130, 131, 132, + 3, 4, 0, 575, 0, 0, 0, 0, 580, 134, + 135, 0, 582, 137, 138, 583, 140, 141, 142, 584, + 585, 586, 587, 588, 0, 590, 148, 149, 150, 151, + 152, 0, 0, 153, 154, 155, 156, 593, 594, 159, + 0, 160, 161, 162, 163, 596, 0, 598, 0, 600, + 167, 168, 169, 170, 171, 601, 173, 174, 175, 0, + 176, 177, 178, 179, 180, 181, 0, 604, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 606, 194, + 195, 607, 197, 0, 198, 0, 199, 200, 201, 202, + 203, 204, 14, 15, 205, 206, 207, 208, 0, 0, + 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 0, 221, 222, 223, 224, 617, + 226, 227, 228, 229, 230, 231, 618, 0, 233, 0, + 234, 235, 621, 237, 0, 238, 0, 239, 624, 23, + 626, 242, 243, 627, 628, 246, 247, 248, 0, 630, + 631, 251, 252, 0, 253, 254, 255, 256, 257, 258, + 259, 633, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 0, 272, 636, 637, 275, 276, + 277, 278, 279, 638, 639, 0, 641, 0, 283, 643, + 644, 286, 645, 288, 289, 290, 0, 291, 292, 293, + 0, 0, 294, 649, 296, 650, 0, 298, 299, 300, + 301, 302, 303, 304, 305, 652, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 653, 654, + 655, 332, 333, 334, 656, 0, 336, 337, 658, 339, + 0, 660, 341, 661, 343, 344, 345, 0, 346, 347, + 0, 0, 348, 349, 350, 0, 0, 351, 352, 667, + 668, 355, 669, 670, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 26, 27, 28, 0, + 370, 371, 675, 676, 374, 375, 677, 377, 378, 379, + 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, + 388, 389, 390, 680, 392, 393, 394, 395, 0, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 0, 409, 410, 683, 412, 413, 414, 684, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 33, 686, 429, 430, 431, 432, 433, + 434, 687, 436, 437, 35, 689, 439, 440, 690, 442, + 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 692, 458, 693, 37, 0, + 460, 461, 38, 462, 697, 464, 465, 466, 467, 468, + 469, 0, 470, 699, 700, 0, 0, 473, 474, 703, + 476, 704, 0, 478, 479, 706, 481, 482, 483, 484, + 485, 0, 0, 486, 487, 488, 709, 40, 489, 490, + 491, 492, 0, 493, 494, 495, 496, 497, 995, 713, + 500, 0, 501, 715, 503, 504, 505, 506, 507, 508, + 509, 0, 0, 510, 0, 44, 511, 512, 513, 514, + 515, 516, 720, 721, 722, 723, 724, 725, 726, 727, + 728, 729, 730, 528, 529, 530, 531, 0, 121, 45, + 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 46, 0, 0, 0, 0, 122, 123, + 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, + 0, 0, 0, 0, 0, 0, 0, 0, 133, 134, + 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 0, 0, 148, 149, 150, 151, + 152, 0, 805, 153, 154, 155, 156, 157, 158, 159, + 0, 160, 161, 162, 163, 806, 0, 807, 0, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, + 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, + 203, 204, 14, 15, 205, 206, 207, 208, 0, 0, + 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 808, 0, 233, 0, + 234, 235, 236, 237, 0, 238, 0, 239, 240, 23, + 241, 242, 243, 244, 245, 246, 247, 248, 0, 249, + 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 0, 282, 0, 283, 284, + 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, + 809, 0, 294, 295, 296, 297, 0, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 0, 336, 337, 338, 339, + 0, 810, 341, 342, 343, 344, 345, 0, 346, 347, + 0, 811, 348, 349, 350, 0, 0, 351, 352, 353, + 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 26, 27, 28, 0, + 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, + 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 0, 409, 410, 411, 412, 413, 414, 415, + 814, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 33, 0, 429, 430, 431, 432, 433, + 434, 435, 436, 437, 35, 438, 439, 440, 441, 442, + 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 457, 458, 815, 37, 0, + 460, 461, 38, 462, 463, 464, 465, 466, 467, 468, + 469, 0, 470, 471, 472, 0, 0, 473, 474, 816, + 476, 817, 0, 478, 479, 818, 481, 482, 483, 484, + 485, 0, 0, 486, 487, 488, 0, 40, 489, 490, + 491, 492, 0, 493, 494, 495, 496, 497, 819, 499, + 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 0, 0, 510, 0, 44, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, + 525, 526, 527, 528, 529, 530, 531, 0, 121, 45, + 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 820, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, - 0, 0, 0, 1293, 0, 0, 0, 0, 2462, 134, - 135, 0, 2463, 137, 138, 2464, 140, 141, 142, 0, - 0, 2465, 0, 0, 0, 1298, 148, 149, 150, 151, - 152, 0, 0, 153, 154, 155, 156, 0, 0, 159, - 0, 160, 161, 162, 163, 0, 0, 2466, 0, 2467, - 167, 168, 169, 170, 171, 2468, 173, 174, 175, 0, - 176, 177, 178, 179, 180, 181, 0, 2469, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 0, 194, - 195, 0, 197, 0, 198, 0, 199, 200, 201, 202, + 0, 0, 0, 0, 0, 0, 0, 0, 133, 134, + 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 0, 0, 148, 149, 150, 151, + 152, 0, 805, 153, 154, 155, 156, 157, 158, 159, + 0, 160, 161, 162, 163, 806, 0, 807, 0, 166, + 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, + 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 0, 221, 222, 223, 224, 0, - 226, 227, 228, 229, 230, 231, 0, 0, 233, 0, - 234, 235, 0, 237, 0, 238, 0, 239, 2470, 0, - 2471, 242, 243, 2472, 2473, 246, 247, 248, 0, 0, - 0, 251, 252, 0, 253, 254, 255, 256, 257, 258, - 259, 2474, 261, 262, 263, 264, 0, 265, 266, 267, - 268, 269, 270, 271, 0, 272, 2475, 0, 275, 276, - 277, 278, 279, 0, 0, 0, 0, 0, 283, 2476, - 2477, 286, 2478, 288, 289, 290, 0, 291, 292, 293, - 0, 0, 294, 2479, 296, 2480, 0, 298, 299, 300, - 301, 302, 303, 304, 305, 2481, 307, 308, 309, 310, + 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 230, 231, 808, 0, 233, 0, + 234, 235, 236, 237, 0, 238, 0, 239, 240, 0, + 241, 242, 243, 244, 245, 246, 247, 248, 0, 249, + 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, + 277, 278, 279, 280, 281, 0, 282, 0, 283, 284, + 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, + 809, 0, 294, 295, 296, 297, 0, 298, 299, 300, + 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 0, 2482, - 0, 332, 333, 334, 0, 0, 336, 337, 2483, 339, - 0, 0, 341, 0, 343, 344, 345, 0, 346, 347, - 0, 0, 348, 349, 350, 0, 0, 351, 352, 0, - 2484, 355, 2485, 0, 358, 359, 360, 361, 362, 363, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, 335, 0, 336, 337, 338, 339, + 0, 810, 341, 342, 343, 344, 345, 0, 346, 347, + 0, 811, 348, 349, 350, 0, 0, 351, 352, 353, + 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, - 370, 371, 0, 2486, 374, 375, 0, 377, 378, 379, + 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, - 388, 389, 390, 0, 392, 393, 394, 395, 0, 396, + 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 2487, 412, 413, 414, 0, - 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, - 426, 427, 428, 0, 1322, 429, 430, 431, 432, 433, - 434, 0, 436, 437, 0, 2488, 439, 440, 0, 442, + 407, 408, 0, 409, 410, 411, 412, 413, 414, 415, + 814, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, + 434, 435, 436, 437, 0, 438, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, - 452, 453, 454, 455, 456, 2489, 458, 0, 0, 0, - 460, 461, 0, 462, 2490, 464, 465, 466, 467, 468, - 469, 0, 470, 0, 0, 0, 0, 473, 474, 0, - 476, 0, 0, 478, 479, 2491, 481, 482, 483, 484, - 485, 0, 0, 486, 487, 488, 2492, 0, 489, 490, - 491, 492, 0, 493, 494, 495, 496, 497, 0, 0, - 500, 0, 501, 2493, 503, 504, 505, 506, 507, 508, - 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, - 515, 516, 2461, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 528, 529, 530, 531, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 2494, 0, 0, 1293, 0, 0, - 0, 0, 2462, 134, 135, 0, 2463, 137, 138, 2464, - 140, 141, 142, 0, 0, 2465, 0, 0, 0, 1298, - 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, - 156, 0, 0, 159, 0, 160, 161, 162, 163, 0, - 0, 2466, 0, 2467, 167, 168, 169, 170, 171, 2468, - 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, - 0, 2469, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 0, 194, 195, 0, 197, 0, 198, 0, - 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, - 222, 223, 224, 0, 226, 227, 228, 229, 230, 231, - 0, 0, 233, 0, 234, 235, 0, 237, 0, 238, - 0, 239, 2470, 0, 2471, 242, 243, 2472, 2473, 246, - 247, 248, 0, 0, 0, 251, 252, 0, 253, 254, - 255, 256, 257, 258, 259, 2474, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, - 2475, 0, 275, 276, 277, 278, 279, 0, 0, 0, - 0, 0, 283, 2476, 2477, 286, 2478, 288, 289, 290, - 0, 291, 292, 293, 0, 0, 294, 2479, 296, 2480, - 0, 298, 299, 300, 301, 302, 303, 304, 305, 2481, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 0, 2482, 0, 332, 333, 334, 0, 0, - 336, 337, 2483, 339, 0, 0, 341, 0, 343, 344, - 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, - 0, 351, 352, 0, 2484, 355, 2485, 0, 358, 359, - 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 0, 0, 0, 0, 370, 371, 0, 2486, 374, 375, - 0, 377, 378, 379, 0, 380, 381, 382, 383, 384, - 385, 0, 386, 387, 388, 389, 390, 0, 392, 393, - 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 0, 409, 410, 2487, - 412, 413, 414, 0, 416, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 427, 428, 0, 1322, 429, - 430, 431, 432, 433, 434, 0, 436, 437, 0, 2488, - 439, 440, 0, 442, 0, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 2489, - 458, 0, 0, 0, 460, 461, 0, 462, 2490, 464, - 465, 466, 467, 468, 469, 0, 470, 0, 0, 0, - 0, 473, 474, 0, 476, 0, 0, 478, 479, 2491, - 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, - 2492, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 0, 0, 500, 0, 501, 2493, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, - 511, 512, 513, 514, 515, 516, 0, 0, 0, 0, - 994, 0, 0, 0, 0, 0, 0, 528, 529, 530, - 531, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 3212, 130, - 131, 132, 3, 4, 0, 575, 0, 0, 0, 0, - 580, 134, 135, 0, 582, 137, 138, 583, 140, 141, - 142, 584, 585, 586, 587, 588, 0, 590, 148, 149, - 150, 151, 152, 0, 0, 153, 154, 155, 156, 593, - 594, 159, 0, 160, 161, 162, 163, 596, 0, 598, - 0, 600, 167, 168, 169, 170, 171, 601, 173, 174, - 175, 0, 176, 177, 178, 179, 180, 181, 0, 604, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 606, 194, 195, 607, 197, 0, 198, 0, 199, 200, - 201, 202, 203, 204, 14, 15, 205, 206, 207, 208, - 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, - 224, 617, 226, 227, 228, 229, 230, 231, 618, 0, - 233, 0, 234, 235, 621, 237, 0, 238, 0, 239, - 624, 23, 626, 242, 243, 627, 628, 246, 247, 248, - 0, 630, 631, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 633, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 636, 637, - 275, 276, 277, 278, 279, 638, 639, 0, 641, 0, - 283, 643, 644, 286, 645, 288, 289, 290, 0, 291, - 292, 293, 0, 0, 294, 649, 296, 650, 0, 298, - 299, 300, 301, 302, 303, 304, 305, 652, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 653, 654, 655, 332, 333, 334, 656, 0, 336, 337, - 658, 339, 0, 660, 341, 661, 343, 344, 345, 0, - 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, - 352, 667, 668, 355, 669, 670, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 26, 27, - 28, 0, 370, 371, 675, 676, 374, 375, 677, 377, - 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, - 386, 387, 388, 389, 390, 680, 392, 393, 394, 395, - 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 683, 412, 413, - 414, 684, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 33, 686, 429, 430, 431, - 432, 433, 434, 687, 436, 437, 35, 689, 439, 440, - 690, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 692, 458, 693, - 37, 0, 460, 461, 38, 462, 697, 464, 465, 466, - 467, 468, 469, 0, 470, 699, 700, 0, 0, 473, - 474, 703, 476, 704, 0, 478, 479, 706, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 709, 40, - 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 995, 713, 500, 0, 501, 715, 503, 504, 505, 506, - 507, 508, 509, 0, 0, 510, 0, 44, 511, 512, - 513, 514, 515, 516, 720, 721, 722, 723, 724, 725, - 726, 727, 728, 729, 730, 528, 529, 530, 531, 0, - 121, 45, 564, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 46, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, - 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, - 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 0, 0, 148, 149, - 150, 151, 152, 0, 805, 153, 154, 155, 156, 157, - 158, 159, 0, 160, 161, 162, 163, 806, 0, 807, - 0, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, - 201, 202, 203, 204, 14, 15, 205, 206, 207, 208, - 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 808, 0, - 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, - 240, 23, 241, 242, 243, 244, 245, 246, 247, 248, - 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, - 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, - 292, 293, 809, 0, 294, 295, 296, 297, 0, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 0, 336, 337, - 338, 339, 0, 810, 341, 342, 343, 344, 345, 0, - 346, 347, 0, 811, 348, 349, 350, 0, 0, 351, - 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 26, 27, - 28, 0, 370, 371, 813, 373, 374, 375, 376, 377, - 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, - 414, 415, 814, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 33, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 35, 438, 439, 440, - 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, - 37, 0, 460, 461, 38, 462, 463, 464, 465, 466, - 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, - 474, 816, 476, 817, 0, 478, 479, 818, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 0, 40, - 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 819, 499, 500, 0, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 0, 0, 510, 0, 44, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, - 523, 524, 525, 526, 527, 528, 529, 530, 531, 0, - 121, 45, 564, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 820, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, - 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, - 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, - 142, 143, 144, 145, 146, 147, 0, 0, 148, 149, - 150, 151, 152, 0, 805, 153, 154, 155, 156, 157, - 158, 159, 0, 160, 161, 162, 163, 806, 0, 807, - 0, 166, 167, 168, 169, 170, 171, 172, 173, 174, - 175, 0, 176, 177, 178, 179, 180, 181, 0, 182, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, - 224, 225, 226, 227, 228, 229, 230, 231, 808, 0, - 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, - 240, 0, 241, 242, 243, 244, 245, 246, 247, 248, - 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, - 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, - 292, 293, 809, 0, 294, 295, 296, 297, 0, 298, - 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, 335, 0, 336, 337, - 338, 339, 0, 810, 341, 342, 343, 344, 345, 0, - 346, 347, 0, 811, 348, 349, 350, 0, 0, 351, - 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, - 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, - 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, - 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, - 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 411, 412, 413, - 414, 415, 814, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, - 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, - 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 457, 458, 815, - 0, 0, 460, 461, 0, 462, 463, 464, 465, 466, - 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, - 474, 816, 476, 817, 0, 478, 479, 818, 481, 482, - 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, - 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 819, 499, 500, 0, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, - 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, - 523, 524, 525, 526, 527, 528, 529, 530, 531, 121, - 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 820, 0, 0, 0, 122, - 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, - 132, 0, 0, 0, 0, 0, 0, 0, 0, 133, - 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, - 143, 144, 145, 146, 147, 0, 0, 148, 149, 150, - 151, 152, 0, 805, 153, 154, 155, 156, 157, 158, - 159, 0, 160, 161, 162, 163, 806, 0, 807, 0, - 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, - 0, 176, 177, 178, 179, 180, 181, 0, 182, 183, - 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, - 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, - 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, - 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 808, 0, 233, - 0, 234, 235, 236, 237, 0, 238, 0, 239, 240, - 0, 241, 242, 243, 244, 245, 246, 247, 248, 0, - 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, - 267, 268, 269, 270, 271, 0, 272, 273, 274, 275, - 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, - 284, 285, 286, 287, 288, 289, 290, 0, 291, 292, - 293, 0, 0, 294, 295, 296, 297, 0, 298, 299, - 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, 335, 0, 336, 337, 338, - 339, 0, 810, 341, 342, 343, 344, 345, 0, 346, - 347, 0, 811, 348, 349, 350, 0, 0, 351, 352, - 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, - 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, - 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, - 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 0, 409, 410, 411, 412, 413, 414, - 415, 814, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, - 433, 434, 435, 436, 437, 0, 438, 439, 440, 441, - 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 456, 457, 458, 815, 0, - 0, 460, 461, 0, 462, 463, 464, 465, 466, 467, - 468, 469, 0, 470, 471, 472, 0, 0, 473, 474, - 816, 476, 817, 0, 478, 479, 818, 481, 482, 483, - 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, - 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, - 499, 500, 0, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, - 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, - 524, 525, 526, 527, 528, 529, 530, 531, 121, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1038, 0, 0, 0, 122, 123, - 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, - 0, 0, 0, 0, 0, 0, 0, 0, 133, 134, - 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, - 144, 145, 146, 147, 0, 0, 148, 149, 150, 151, - 152, 0, 805, 153, 154, 155, 156, 157, 158, 159, - 0, 160, 161, 162, 163, 806, 0, 807, 0, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 0, - 176, 177, 178, 179, 180, 181, 0, 182, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, - 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, - 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, - 226, 227, 228, 229, 230, 231, 808, 0, 233, 0, - 234, 235, 236, 237, 0, 238, 0, 239, 240, 0, - 241, 242, 243, 244, 245, 246, 247, 248, 0, 249, - 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, - 268, 269, 270, 271, 0, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 0, 282, 0, 283, 284, - 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, - 0, 0, 294, 295, 296, 297, 0, 298, 299, 300, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, 335, 0, 336, 337, 338, 339, - 0, 810, 341, 342, 343, 344, 345, 0, 346, 347, - 0, 0, 348, 349, 350, 0, 0, 351, 352, 353, - 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, - 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, - 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, - 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 411, 412, 413, 414, 415, - 814, 417, 418, 419, 420, 421, 422, 423, 424, 425, - 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, - 434, 435, 436, 437, 0, 438, 439, 440, 441, 442, - 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, - 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, - 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, - 469, 0, 470, 471, 472, 0, 0, 473, 474, 816, - 476, 817, 0, 478, 479, 818, 481, 482, 483, 484, - 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, - 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, - 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, + 452, 453, 454, 455, 456, 457, 458, 815, 0, 0, + 460, 461, 0, 462, 463, 464, 465, 466, 467, 468, + 469, 0, 470, 471, 472, 0, 0, 473, 474, 816, + 476, 817, 0, 478, 479, 818, 481, 482, 483, 484, + 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, + 491, 492, 0, 493, 494, 495, 496, 497, 819, 499, + 500, 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, - 525, 526, 527, 528, 529, 530, 531, 121, 0, 0, + 525, 526, 527, 528, 529, 530, 531, 121, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 46, 0, 0, 0, 122, 123, 124, + 0, 0, 0, 820, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, 140, 141, 142, 143, 144, @@ -8147,14 +7992,14 @@ static const yytype_int16 yytable[] = 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 0, 336, 337, 338, 339, 0, 810, 341, 342, 343, 344, 345, 0, 346, 347, 0, - 0, 348, 349, 350, 0, 0, 351, 352, 353, 354, + 811, 348, 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 0, 409, 410, 411, 412, 413, 414, 415, 416, + 408, 0, 409, 410, 411, 412, 413, 414, 415, 814, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, 439, 440, 441, 442, 0, @@ -8168,264 +8013,264 @@ static const yytype_int16 yytable[] = 0, 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, - 526, 527, 528, 529, 530, 531, 539, 0, 0, 0, + 526, 527, 528, 529, 530, 531, 121, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 3556, 0, 0, 0, 122, 123, 124, 125, + 0, 0, 1038, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, - 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, - 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, - 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, - 161, 162, 163, 164, 0, 0, 0, 166, 167, 168, - 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 0, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, - 14, 15, 205, 206, 207, 208, 0, 0, 209, 210, - 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, - 236, 237, 0, 238, 0, 239, 0, 23, 0, 242, - 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, - 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, - 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, - 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, - 294, 0, 296, 0, 0, 298, 299, 300, 301, 302, - 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, - 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, - 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, - 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, - 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 26, 27, 28, 0, 370, 371, - 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, - 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, - 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 33, 0, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 35, 0, 439, 440, 441, 442, 0, 443, - 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 542, 458, 459, 37, 0, 460, 461, - 38, 462, 0, 464, 465, 466, 467, 468, 469, 0, - 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, - 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 0, 40, 489, 490, 491, 492, - 0, 493, 494, 495, 496, 497, 819, 499, 500, 0, - 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, - 0, 510, 0, 44, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 0, 539, 45, 564, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 46, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 128, 129, 910, 130, 131, 132, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, - 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, + 0, 0, 0, 0, 0, 0, 133, 134, 135, 0, + 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, - 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, - 161, 162, 163, 164, 0, 0, 0, 166, 167, 168, - 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 0, 183, 184, 185, 186, + 805, 153, 154, 155, 156, 157, 158, 159, 0, 160, + 161, 162, 163, 806, 0, 807, 0, 166, 167, 168, + 169, 170, 171, 172, 173, 174, 175, 0, 176, 177, + 178, 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, - 236, 237, 0, 238, 0, 239, 0, 23, 0, 242, - 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, + 228, 229, 230, 231, 808, 0, 233, 0, 234, 235, + 236, 237, 0, 238, 0, 239, 240, 0, 241, 242, + 243, 244, 245, 246, 247, 248, 0, 249, 250, 251, + 252, 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, - 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, - 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, - 294, 0, 296, 0, 0, 298, 299, 300, 301, 302, - 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, + 270, 271, 0, 272, 273, 274, 275, 276, 277, 278, + 279, 280, 281, 0, 282, 0, 283, 284, 285, 286, + 287, 288, 289, 290, 0, 291, 292, 293, 0, 0, + 294, 295, 296, 297, 0, 298, 299, 300, 301, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, - 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, + 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, 335, 0, 336, 337, 338, 339, 0, 810, 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, - 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, - 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 26, 27, 28, 0, 370, 371, - 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, + 348, 349, 350, 0, 0, 351, 352, 353, 354, 355, + 356, 812, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, + 813, 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, + 0, 409, 410, 411, 412, 413, 414, 415, 814, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 33, 0, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, + 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, + 436, 437, 0, 438, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, - 38, 911, 0, 464, 465, 466, 467, 468, 469, 0, - 470, 912, 472, 0, 0, 913, 474, 475, 476, 477, - 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 0, 40, 489, 490, 491, 492, - 0, 493, 494, 495, 496, 497, 819, 499, 500, 0, - 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, - 0, 510, 0, 44, 511, 512, 513, 514, 515, 516, + 454, 455, 456, 457, 458, 815, 0, 0, 460, 461, + 0, 462, 463, 464, 465, 466, 467, 468, 469, 0, + 470, 471, 472, 0, 0, 473, 474, 816, 476, 817, + 0, 478, 479, 818, 481, 482, 483, 484, 485, 0, + 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, + 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 0, + 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 0, 539, 45, 564, 0, + 527, 528, 529, 530, 531, 121, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 46, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, - 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, - 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, - 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, - 161, 162, 163, 164, 0, 0, 0, 166, 167, 168, - 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 0, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, - 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, - 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, - 236, 237, 0, 238, 0, 239, 0, 23, 0, 242, - 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, - 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, - 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, - 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, - 294, 0, 296, 0, 0, 298, 299, 300, 301, 302, - 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, - 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, - 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, - 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, - 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 26, 27, 28, 0, 370, 371, - 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, - 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, - 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 33, 0, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, - 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, - 38, 462, 0, 464, 465, 466, 467, 468, 469, 0, - 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, - 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 0, 40, 489, 490, 491, 492, - 0, 493, 494, 495, 496, 497, 819, 499, 500, 0, - 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, - 0, 510, 0, 44, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 0, 539, 45, 564, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 46, 0, 0, 0, 0, 122, 123, 124, 125, - 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, - 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, - 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, - 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, - 161, 162, 163, 164, 0, 0, 0, 166, 167, 168, - 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, - 178, 179, 180, 181, 0, 0, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, - 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, - 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, - 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, - 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, - 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, - 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, - 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, - 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, - 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, - 294, 0, 296, 0, 0, 298, 299, 300, 301, 302, - 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, - 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, - 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, - 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, - 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, - 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, - 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, - 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, - 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, - 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, - 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, - 0, 462, 0, 464, 465, 466, 467, 468, 469, 0, - 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, - 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, - 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, - 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, - 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, - 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, - 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1014, 0, 0, 0, 122, 123, 124, 125, 126, + 0, 46, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, - 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, - 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, + 0, 0, 0, 0, 0, 133, 134, 135, 0, 136, + 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, + 147, 0, 0, 148, 149, 150, 151, 152, 0, 805, 153, 154, 155, 156, 157, 158, 159, 0, 160, 161, - 162, 163, 164, 0, 0, 0, 166, 167, 168, 169, - 170, 171, 0, 173, 174, 175, 0, 176, 177, 178, - 179, 180, 181, 0, 0, 183, 184, 185, 186, 187, + 162, 163, 806, 0, 807, 0, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 0, 176, 177, 178, + 179, 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, - 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, - 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, - 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, + 229, 230, 231, 808, 0, 233, 0, 234, 235, 236, + 237, 0, 238, 0, 239, 240, 0, 241, 242, 243, + 244, 245, 246, 247, 248, 0, 249, 250, 251, 252, + 0, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, - 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, - 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, + 271, 0, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 0, 282, 0, 283, 284, 285, 286, 287, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, - 0, 296, 0, 0, 298, 299, 300, 301, 302, 303, - 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, + 295, 296, 297, 0, 298, 299, 300, 301, 302, 303, + 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, - 334, 335, 0, 336, 337, 0, 339, 0, 340, 341, + 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, + 334, 335, 0, 336, 337, 338, 339, 0, 810, 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, 348, - 349, 350, 0, 0, 351, 352, 353, 0, 355, 0, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, - 0, 374, 375, 376, 377, 378, 379, 0, 380, 381, + 349, 350, 0, 0, 351, 352, 353, 354, 355, 356, + 812, 358, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 0, 0, 0, 0, 370, 371, 813, + 373, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, - 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, - 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, + 437, 0, 438, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, - 462, 0, 464, 465, 466, 467, 468, 469, 0, 470, - 471, 472, 0, 0, 473, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, + 455, 456, 457, 458, 815, 0, 0, 460, 461, 0, + 462, 463, 464, 465, 466, 467, 468, 469, 0, 470, + 471, 472, 0, 0, 473, 474, 816, 476, 817, 0, + 478, 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, 501, - 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, + 502, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, - 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, + 528, 529, 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1525, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 3560, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, + 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, + 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, + 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, + 163, 164, 0, 0, 0, 166, 167, 168, 169, 170, + 171, 0, 173, 174, 175, 0, 176, 177, 178, 179, + 180, 181, 0, 0, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, + 198, 0, 199, 200, 201, 202, 203, 204, 14, 15, + 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, + 0, 238, 0, 239, 0, 23, 0, 242, 243, 540, + 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, + 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, + 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, + 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, + 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, + 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, + 296, 0, 0, 298, 299, 300, 301, 302, 303, 304, + 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, + 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, + 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, + 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 26, 27, 28, 0, 370, 371, 372, 0, + 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, + 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, + 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 33, + 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 35, 0, 439, 440, 441, 442, 0, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 542, 458, 459, 37, 0, 460, 461, 38, 462, + 0, 464, 465, 466, 467, 468, 469, 0, 470, 471, + 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, + 487, 488, 0, 40, 489, 490, 491, 492, 0, 493, + 494, 495, 496, 497, 819, 499, 500, 0, 501, 0, + 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, + 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + 529, 530, 531, 0, 539, 45, 564, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 128, 129, 910, 130, 131, 132, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, + 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, + 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, + 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, + 163, 164, 0, 0, 0, 166, 167, 168, 169, 170, + 171, 0, 173, 174, 175, 0, 176, 177, 178, 179, + 180, 181, 0, 0, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, + 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, + 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, + 0, 238, 0, 239, 0, 23, 0, 242, 243, 540, + 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, + 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, + 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, + 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, + 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, + 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, + 296, 0, 0, 298, 299, 300, 301, 302, 303, 304, + 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, + 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, + 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, + 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 26, 27, 28, 0, 370, 371, 372, 0, + 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, + 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, + 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 33, + 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 542, 458, 459, 0, 0, 460, 461, 38, 911, + 0, 464, 465, 466, 467, 468, 469, 0, 470, 912, + 472, 0, 0, 913, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, + 487, 488, 0, 40, 489, 490, 491, 492, 0, 493, + 494, 495, 496, 497, 819, 499, 500, 0, 501, 0, + 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, + 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + 529, 530, 531, 0, 539, 45, 564, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, + 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, + 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, + 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, + 163, 164, 0, 0, 0, 166, 167, 168, 169, 170, + 171, 0, 173, 174, 175, 0, 176, 177, 178, 179, + 180, 181, 0, 0, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, + 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, + 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, + 0, 238, 0, 239, 0, 23, 0, 242, 243, 540, + 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, + 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, + 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, + 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, + 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, + 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, + 296, 0, 0, 298, 299, 300, 301, 302, 303, 304, + 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, + 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, + 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, + 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 26, 27, 28, 0, 370, 371, 372, 0, + 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, + 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, + 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, + 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 33, + 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 542, 458, 459, 0, 0, 460, 461, 38, 462, + 0, 464, 465, 466, 467, 468, 469, 0, 470, 471, + 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, + 487, 488, 0, 40, 489, 490, 491, 492, 0, 493, + 494, 495, 496, 497, 819, 499, 500, 0, 501, 0, + 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, + 0, 44, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + 529, 530, 531, 0, 539, 45, 564, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, @@ -8475,7 +8320,7 @@ static const yytype_int16 yytable[] = 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 2159, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1014, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, @@ -8526,7 +8371,7 @@ static const yytype_int16 yytable[] = 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 2306, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1525, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, @@ -8577,7 +8422,7 @@ static const yytype_int16 yytable[] = 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 2599, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 2159, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, @@ -8628,7 +8473,7 @@ static const yytype_int16 yytable[] = 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 2742, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 2306, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, @@ -8679,7 +8524,7 @@ static const yytype_int16 yytable[] = 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 2969, 0, 0, 0, 122, + 0, 0, 0, 0, 0, 2600, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, @@ -8729,8 +8574,8 @@ static const yytype_int16 yytable[] = 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 3455, 0, 0, 0, 122, 123, + 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2743, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, @@ -8779,9 +8624,9 @@ static const yytype_int16 yytable[] = 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, - 525, 526, 527, 528, 529, 530, 531, 539, 0, 0, - 0, 0, 0, 0, 0, 0, 3791, 0, 0, 0, - 0, 0, 0, 2266, 0, 0, 0, 122, 123, 124, + 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 2971, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, @@ -8832,7 +8677,7 @@ static const yytype_int16 yytable[] = 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 2266, 0, 0, 0, 122, 123, 124, 125, + 0, 0, 3409, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, @@ -8881,276 +8726,9 @@ static const yytype_int16 yytable[] = 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 3101, 1395, 836, 0, 0, - 2133, 1080, 0, 0, 0, 0, 0, 2134, 2135, 0, - 0, 3306, 2136, 2137, 2138, 122, 123, 124, 125, 126, - 127, 128, 129, 571, 130, 131, 132, 572, 573, 574, - 3102, 576, 577, 578, 579, 3103, 134, 135, 581, 3104, - 137, 138, 3105, 140, 141, 142, 0, 1539, 3106, 1541, - 1542, 589, 3107, 148, 149, 150, 151, 152, 591, 592, - 153, 154, 155, 156, 1544, 1545, 159, 595, 160, 161, - 162, 163, 0, 597, 3108, 599, 3109, 167, 168, 169, - 170, 171, 3110, 173, 174, 175, 602, 176, 177, 178, - 179, 180, 181, 603, 3111, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 1550, 194, 195, 1551, 197, - 608, 198, 609, 199, 200, 201, 202, 203, 204, 610, - 611, 205, 206, 207, 208, 612, 613, 209, 210, 1093, - 212, 213, 614, 214, 215, 216, 615, 217, 218, 219, - 220, 616, 221, 222, 223, 224, 0, 226, 227, 228, - 229, 230, 231, 0, 619, 233, 620, 234, 235, 1552, - 237, 622, 238, 623, 239, 3112, 625, 3113, 242, 243, - 2472, 3114, 246, 247, 248, 629, 0, 0, 251, 252, - 632, 253, 254, 255, 256, 257, 258, 259, 3115, 261, - 262, 263, 264, 634, 265, 266, 267, 268, 269, 270, - 271, 635, 272, 3116, 0, 275, 276, 277, 278, 279, - 1558, 1559, 640, 1560, 642, 283, 3117, 3118, 286, 3119, - 288, 289, 290, 646, 291, 292, 293, 647, 648, 294, - 3120, 296, 3121, 651, 298, 299, 300, 301, 302, 303, - 304, 305, 3122, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 1567, 3123, 1569, 332, 333, - 334, 3124, 657, 336, 337, 3125, 339, 659, 0, 341, - 1571, 343, 344, 345, 662, 346, 347, 663, 664, 3126, - 349, 350, 665, 666, 351, 352, 0, 3127, 355, 3128, - 0, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 671, 672, 673, 674, 370, 371, 0, - 3129, 374, 375, 0, 377, 378, 379, 678, 380, 381, - 382, 383, 384, 385, 679, 386, 387, 388, 389, 390, - 1575, 392, 393, 394, 395, 681, 396, 397, 398, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 682, - 409, 410, 3130, 412, 413, 414, 1577, 416, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, - 685, 3131, 429, 430, 431, 432, 433, 434, 3132, 436, - 437, 688, 3133, 439, 440, 1581, 442, 691, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 3134, 458, 0, 694, 695, 460, 461, 696, - 462, 3135, 464, 465, 466, 467, 468, 469, 698, 470, - 1584, 1585, 701, 702, 473, 474, 0, 476, 0, 705, - 478, 479, 3136, 481, 482, 483, 484, 485, 3137, 708, - 486, 487, 488, 3138, 710, 489, 490, 491, 492, 711, - 493, 494, 495, 496, 497, 0, 1589, 500, 714, 501, - 3139, 503, 504, 505, 506, 507, 508, 509, 716, 717, - 510, 718, 719, 511, 512, 513, 514, 515, 516, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 528, 529, 530, 531, 0, 539, 0, 2139, 2140, 2141, - 2133, 3140, 3141, 2144, 2145, 2146, 2147, 2134, 2135, 0, - 0, 0, 2136, 2137, 2138, 122, 123, 124, 125, 126, - 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, - 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, - 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, - 153, 154, 155, 156, 157, 158, 159, 0, 160, 161, - 162, 163, 164, 0, 0, 0, 166, 167, 168, 169, - 170, 171, 0, 173, 174, 175, 0, 176, 177, 178, - 179, 180, 181, 0, 0, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 0, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, - 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, - 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, - 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, - 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, - 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, - 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, - 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, - 0, 296, 0, 0, 298, 299, 300, 301, 302, 303, - 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, - 334, 335, 0, 336, 337, 0, 339, 0, 340, 341, - 342, 343, 344, 345, 0, 346, 347, 0, 0, 348, - 349, 350, 0, 0, 351, 352, 353, 0, 355, 0, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, - 0, 374, 375, 376, 377, 378, 379, 0, 380, 381, - 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, - 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, - 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, - 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, - 462, 0, 464, 465, 466, 467, 468, 469, 0, 470, - 471, 472, 0, 0, 473, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, - 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, - 493, 494, 495, 496, 497, 498, 499, 500, 0, 501, - 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, - 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, - 528, 529, 530, 531, 0, 0, 0, 2139, 2140, 2141, - 0, 2142, 2143, 2144, 2145, 2146, 2147, 1676, 0, 0, - 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, - 1683, 1684, 0, 0, 0, 1676, 0, 0, 1677, 0, - 0, 0, 1678, 1679, 1680, 1681, 1685, 1682, 1683, 1684, - 0, 0, 0, 0, 0, 0, 1687, 0, 0, 0, - 0, 0, 0, 1688, 1685, 0, 0, 0, 0, 0, - 1676, 0, 0, 1677, 1687, 0, 0, 1678, 1679, 1680, - 1681, 1688, 1682, 1683, 1684, 0, 0, 0, 1676, 0, - 1689, 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 1685, - 1682, 1683, 1684, 0, 0, 0, 0, 0, 1689, 1687, - 0, 0, 0, 0, 0, 0, 1688, 1685, 0, 0, - 0, 0, 0, 1676, 0, 0, 1677, 1687, 0, 0, - 1678, 1679, 1680, 1681, 1688, 1682, 1683, 1684, 0, 0, - 0, 0, 0, 1689, 0, 0, 0, 0, 0, 0, - 0, 0, 1685, 0, 0, 0, 0, 0, 0, 0, - 0, 1689, 1687, 0, 0, 1676, 0, 0, 1677, 1688, - 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, - 0, 0, 0, 0, 0, 0, 0, 0, 1690, 0, - 0, 0, 0, 0, 1685, 0, 1689, 0, 0, 0, - 0, 0, 0, 0, 1687, 1691, 1690, 0, 0, 0, - 1692, 1688, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1691, 0, 0, 0, 0, 1692, 0, - 0, 0, 0, 1693, 1694, 0, 0, 0, 1689, 0, - 0, 1690, 0, 0, 0, 0, 0, 0, 0, 1695, - 0, 1693, 1694, 0, 0, 0, 0, 0, 1691, 1690, - 0, 0, 0, 1692, 0, 0, 0, 1695, 0, 0, - 0, 0, 0, 0, 0, 0, 1691, 0, 0, 0, - 0, 1692, 0, 0, 0, 0, 1693, 1694, 0, 1696, - 0, 0, 1697, 0, 1690, 0, 0, 0, 0, 0, - 0, 0, 1695, 0, 1693, 1694, 1698, 1696, 0, 1699, - 1697, 1691, 0, 0, 0, 0, 1692, 0, 0, 0, - 1695, 0, 0, 0, 1698, 0, 0, 1699, 0, 0, - 0, 0, 0, 0, 0, 0, 1690, 0, 0, 1693, - 1694, 0, 1696, 0, 0, 1697, 0, 0, 0, 0, - 0, 0, 0, 1691, 0, 1695, 0, 0, 1692, 1698, - 1696, 0, 1699, 1697, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1698, 0, 0, - 1699, 1693, 1694, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1696, 0, 1695, 1697, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1700, - 0, 0, 1698, 0, 0, 1699, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, - 0, 0, 0, 0, 0, 1676, 0, 1696, 1677, 0, - 1697, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, - 0, 0, 0, 0, 1698, 0, 0, 1699, 0, 0, - 0, 0, 1700, 0, 1685, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1687, 0, 0, 0, 0, 0, - 1700, 1688, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1689, 0, - 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, - 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, - 1707, 1708, 1709, 1710, 0, 0, 0, 0, 3478, 1701, - 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, - 1709, 1710, 0, 0, 0, 0, 3506, 1700, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, 1704, - 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, - 0, 3610, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, - 1706, 1707, 1708, 1709, 1710, 0, 1690, 0, 0, 3670, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1691, 0, 0, 0, 1701, 1692, 0, - 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, - 0, 0, 0, 0, 3692, 0, 1676, 0, 0, 1677, - 0, 1693, 1694, 1678, 1679, 1680, 1681, 0, 1682, 1683, - 1684, 0, 0, 0, 0, 0, 0, 1695, 0, 1701, - 0, 0, 1702, 1703, 1704, 1685, 1705, 1706, 1707, 1708, - 1709, 1710, 0, 0, 2994, 1687, 0, 0, 0, 0, - 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1696, 0, 0, - 1697, 0, 0, 0, 0, 0, 0, 0, 0, 1689, - 0, 0, 0, 0, 1698, 0, 0, 1699, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1690, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, - 0, 0, 0, 0, 1691, 0, 0, 0, 0, 1692, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1695, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1696, 0, - 0, 1697, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1698, 0, 0, 1699, 1701, - 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, - 1709, 1710, 0, 0, 3468, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1700, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 570, 0, 0, 0, - 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, - 1708, 1709, 1710, 0, 0, 3650, 122, 123, 124, 125, - 126, 127, 128, 129, 571, 130, 131, 132, 572, 573, - 574, 575, 576, 577, 578, 579, 580, 134, 135, 581, - 582, 137, 138, 583, 140, 141, 142, 584, 585, 586, - 587, 588, 589, 590, 148, 149, 150, 151, 152, 591, - 592, 153, 154, 155, 156, 593, 594, 159, 595, 160, - 161, 162, 163, 596, 597, 598, 599, 600, 167, 168, - 169, 170, 171, 601, 173, 174, 175, 602, 176, 177, - 178, 179, 180, 181, 603, 604, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 606, 194, 195, 607, - 197, 608, 198, 609, 199, 200, 201, 202, 203, 204, - 610, 611, 205, 206, 207, 208, 612, 613, 209, 210, - 211, 212, 213, 614, 214, 215, 216, 615, 217, 218, - 219, 220, 616, 221, 222, 223, 224, 617, 226, 227, - 228, 229, 230, 231, 618, 619, 233, 620, 234, 235, - 621, 237, 622, 238, 623, 239, 624, 625, 626, 242, - 243, 627, 628, 246, 247, 248, 629, 630, 631, 251, - 252, 632, 253, 254, 255, 256, 257, 258, 259, 633, - 261, 262, 263, 264, 634, 265, 266, 267, 268, 269, - 270, 271, 635, 272, 636, 637, 275, 276, 277, 278, - 279, 638, 639, 640, 641, 642, 283, 643, 644, 286, - 645, 288, 289, 290, 646, 291, 292, 293, 647, 648, - 294, 649, 296, 650, 651, 298, 299, 300, 301, 302, - 303, 304, 305, 652, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 653, 654, 655, 332, - 333, 334, 656, 657, 336, 337, 658, 339, 659, 660, - 341, 661, 343, 344, 345, 662, 346, 347, 663, 664, - 348, 349, 350, 665, 666, 351, 352, 667, 668, 355, - 669, 670, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 671, 672, 673, 674, 370, 371, - 675, 676, 374, 375, 677, 377, 378, 379, 678, 380, - 381, 382, 383, 384, 385, 679, 386, 387, 388, 389, - 390, 680, 392, 393, 394, 395, 681, 396, 397, 398, - 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 682, 409, 410, 683, 412, 413, 414, 684, 416, 417, - 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 685, 686, 429, 430, 431, 432, 433, 434, 687, - 436, 437, 688, 689, 439, 440, 690, 442, 691, 443, - 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 692, 458, 693, 694, 695, 460, 461, - 696, 462, 697, 464, 465, 466, 467, 468, 469, 698, - 470, 699, 700, 701, 702, 473, 474, 703, 476, 704, - 705, 478, 479, 706, 481, 482, 483, 484, 485, 707, - 708, 486, 487, 488, 709, 710, 489, 490, 491, 492, - 711, 493, 494, 495, 496, 497, 712, 713, 500, 714, - 501, 715, 503, 504, 505, 506, 507, 508, 509, 716, - 717, 510, 718, 719, 511, 512, 513, 514, 515, 516, - 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, - 730, 528, 529, 530, 531, 539, 0, 0, 0, 0, - 0, 0, 0, 0, 2172, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, + 527, 528, 529, 530, 531, 539, 0, 0, 0, 0, + 0, 0, 0, 0, 3808, 0, 0, 0, 0, 0, + 0, 2266, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, @@ -9200,8 +8778,8 @@ static const yytype_int16 yytable[] = 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 0, 0, 0, 0, - 0, 0, 0, 2886, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 2266, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, @@ -9250,364 +8828,269 @@ static const yytype_int16 yytable[] = 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 994, 1395, 836, 0, 0, 0, 1080, - 0, 0, 2889, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, - 129, 0, 130, 131, 132, 0, 0, 0, 575, 0, - 0, 0, 0, 580, 134, 135, 0, 582, 137, 138, - 583, 140, 141, 142, 584, 585, 586, 587, 588, 0, - 590, 148, 149, 150, 151, 152, 0, 0, 153, 154, - 155, 156, 593, 594, 159, 0, 160, 161, 162, 163, - 596, 0, 598, 0, 600, 167, 168, 169, 170, 171, - 601, 173, 174, 175, 0, 176, 177, 178, 179, 180, - 181, 0, 604, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 606, 194, 195, 607, 197, 0, 198, + 529, 530, 531, 3472, 1395, 836, 0, 0, 2133, 1080, + 0, 0, 0, 0, 0, 2134, 2135, 0, 0, 3260, + 2136, 2137, 2138, 122, 123, 124, 125, 126, 127, 128, + 129, 571, 130, 131, 132, 572, 573, 574, 3473, 576, + 577, 578, 579, 3474, 134, 135, 581, 3475, 137, 138, + 3476, 140, 141, 142, 0, 1539, 3477, 1541, 1542, 589, + 3478, 148, 149, 150, 151, 152, 591, 592, 153, 154, + 155, 156, 1544, 1545, 159, 595, 160, 161, 162, 163, + 0, 597, 3479, 599, 3480, 167, 168, 169, 170, 171, + 3481, 173, 174, 175, 602, 176, 177, 178, 179, 180, + 181, 603, 3482, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 1550, 194, 195, 1551, 197, 608, 198, + 609, 199, 200, 201, 202, 203, 204, 610, 611, 205, + 206, 207, 208, 612, 613, 209, 210, 1093, 212, 213, + 614, 214, 215, 216, 615, 217, 218, 219, 220, 616, + 221, 222, 223, 224, 0, 226, 227, 228, 229, 230, + 231, 0, 619, 233, 620, 234, 235, 1552, 237, 622, + 238, 623, 239, 3483, 625, 3484, 242, 243, 2473, 3485, + 246, 247, 248, 629, 0, 0, 251, 252, 632, 253, + 254, 255, 256, 257, 258, 259, 3486, 261, 262, 263, + 264, 634, 265, 266, 267, 268, 269, 270, 271, 635, + 272, 3487, 0, 275, 276, 277, 278, 279, 1558, 1559, + 640, 1560, 642, 283, 3488, 3489, 286, 3490, 288, 289, + 290, 646, 291, 292, 293, 647, 648, 294, 3491, 296, + 3492, 651, 298, 299, 300, 301, 302, 303, 304, 305, + 3493, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 1567, 3494, 1569, 332, 333, 334, 3495, + 657, 336, 337, 3496, 339, 659, 0, 341, 1571, 343, + 344, 345, 662, 346, 347, 663, 664, 3497, 349, 350, + 665, 666, 351, 352, 0, 3498, 355, 3499, 0, 358, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 671, 672, 673, 674, 370, 371, 0, 3500, 374, + 375, 0, 377, 378, 379, 678, 380, 381, 382, 383, + 384, 385, 679, 386, 387, 388, 389, 390, 1575, 392, + 393, 394, 395, 681, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 682, 409, 410, + 3501, 412, 413, 414, 1577, 416, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 685, 3502, + 429, 430, 431, 432, 433, 434, 3503, 436, 437, 688, + 3504, 439, 440, 1581, 442, 691, 443, 444, 445, 446, + 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, + 3505, 458, 0, 694, 695, 460, 461, 696, 462, 3506, + 464, 465, 466, 467, 468, 469, 698, 470, 1584, 1585, + 701, 702, 473, 474, 0, 476, 0, 705, 478, 479, + 3507, 481, 482, 483, 484, 485, 3508, 708, 486, 487, + 488, 3509, 710, 489, 490, 491, 492, 711, 493, 494, + 495, 496, 497, 0, 1589, 500, 714, 501, 3510, 503, + 504, 505, 506, 507, 508, 509, 716, 717, 510, 718, + 719, 511, 512, 513, 514, 515, 516, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 528, 529, + 530, 531, 0, 539, 0, 2139, 2140, 2141, 2133, 3511, + 3512, 2144, 2145, 2146, 2147, 2134, 2135, 0, 0, 0, + 2136, 2137, 2138, 122, 123, 124, 125, 126, 127, 128, + 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, + 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, + 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, + 155, 156, 157, 158, 159, 0, 160, 161, 162, 163, + 164, 0, 0, 0, 166, 167, 168, 169, 170, 171, + 0, 173, 174, 175, 0, 176, 177, 178, 179, 180, + 181, 0, 0, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, - 221, 222, 223, 224, 617, 226, 227, 228, 229, 230, - 231, 618, 1396, 233, 0, 234, 235, 621, 237, 0, - 238, 0, 239, 624, 0, 626, 242, 243, 627, 628, - 246, 247, 248, 0, 630, 631, 251, 252, 0, 253, - 254, 255, 256, 257, 258, 259, 633, 261, 262, 263, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, + 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, + 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, + 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, - 272, 636, 637, 275, 276, 277, 278, 279, 638, 639, - 0, 641, 0, 283, 643, 644, 286, 645, 288, 289, - 290, 0, 291, 292, 293, 0, 0, 294, 649, 296, - 650, 0, 298, 299, 300, 301, 302, 303, 304, 305, - 652, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, + 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, + 290, 0, 291, 292, 293, 0, 0, 294, 0, 296, + 0, 0, 298, 299, 300, 301, 302, 303, 304, 305, + 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 653, 654, 655, 332, 333, 334, 656, - 0, 336, 337, 658, 339, 0, 660, 341, 661, 343, - 344, 345, 0, 346, 347, 1397, 0, 348, 349, 350, - 0, 0, 351, 352, 667, 668, 355, 669, 670, 358, + 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, + 0, 336, 337, 0, 339, 0, 340, 341, 342, 343, + 344, 345, 0, 346, 347, 0, 0, 348, 349, 350, + 0, 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, - 369, 0, 0, 0, 0, 370, 371, 675, 676, 374, - 375, 677, 377, 378, 379, 0, 380, 381, 382, 383, - 384, 385, 0, 386, 387, 388, 389, 390, 680, 392, + 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, + 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, + 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, - 683, 412, 413, 414, 684, 416, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 426, 427, 428, 0, 686, - 429, 430, 431, 432, 433, 434, 687, 436, 437, 0, - 689, 439, 440, 690, 442, 0, 443, 444, 445, 446, + 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, + 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, + 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, - 692, 458, 693, 0, 0, 460, 461, 0, 462, 697, - 464, 465, 466, 467, 468, 469, 0, 470, 699, 700, - 0, 0, 473, 474, 703, 476, 704, 1398, 478, 479, - 706, 481, 482, 483, 484, 485, 0, 0, 486, 487, - 488, 709, 0, 489, 490, 491, 492, 0, 493, 494, - 495, 496, 497, 712, 713, 500, 0, 501, 715, 503, + 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, + 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, + 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, + 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, + 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, + 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, - 0, 511, 512, 513, 514, 515, 516, 720, 721, 722, - 723, 724, 725, 726, 727, 728, 729, 730, 528, 529, - 530, 531, 0, 0, 1676, 0, 0, 1677, 0, 1399, - 1400, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, - 0, 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, - 1679, 1680, 1681, 1685, 1682, 1683, 1684, 0, 2272, 0, - 0, 0, 0, 1687, 0, 0, 0, 0, 0, 0, - 1688, 1685, 0, 0, 0, 0, 0, 1676, 0, 0, - 1677, 1687, 0, 0, 1678, 1679, 1680, 1681, 1688, 1682, - 1683, 1684, 0, 0, 0, 1676, 0, 1689, 1677, 0, - 0, 0, 1678, 1679, 1680, 1681, 1685, 1682, 1683, 1684, - 0, 0, 0, 0, 0, 1689, 1687, 0, 0, 0, - 0, 0, 0, 1688, 1685, 0, 0, 0, 1979, 0, + 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, + 530, 531, 0, 0, 0, 2139, 2140, 2141, 0, 2142, + 2143, 2144, 2145, 2146, 2147, 1676, 0, 0, 1677, 0, + 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, + 0, 0, 0, 1676, 0, 0, 1677, 0, 0, 0, + 1678, 1679, 1680, 1681, 1685, 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, 1687, 0, 0, 0, 0, 0, - 0, 1688, 0, 2273, 0, 0, 0, 0, 0, 0, - 1689, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1688, 1685, 0, 0, 0, 0, 0, 1676, 0, + 0, 1677, 1687, 0, 0, 1678, 1679, 1680, 1681, 1688, + 1682, 1683, 1684, 0, 0, 0, 1676, 0, 1689, 1677, + 0, 0, 0, 1678, 1679, 1680, 1681, 1685, 1682, 1683, + 1684, 0, 0, 0, 0, 0, 1689, 1687, 0, 0, + 0, 0, 0, 0, 1688, 1685, 0, 0, 0, 0, + 0, 1676, 0, 0, 1677, 1687, 0, 0, 1678, 1679, + 1680, 1681, 1688, 1682, 1683, 1684, 0, 0, 0, 0, + 0, 1689, 0, 0, 0, 0, 0, 0, 0, 0, + 1685, 0, 0, 0, 0, 0, 0, 0, 0, 1689, + 1687, 0, 0, 1676, 0, 0, 1677, 1688, 0, 0, + 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, + 0, 0, 0, 0, 0, 0, 1690, 0, 0, 0, + 0, 0, 1685, 0, 1689, 0, 0, 0, 0, 0, + 0, 0, 1687, 1691, 1690, 0, 0, 0, 1692, 1688, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1691, 0, 0, 0, 0, 1692, 0, 0, 0, + 0, 1693, 1694, 0, 0, 0, 1689, 0, 0, 1690, + 0, 0, 0, 0, 0, 0, 0, 1695, 0, 1693, + 1694, 0, 0, 0, 0, 0, 1691, 1690, 0, 0, + 0, 1692, 0, 0, 0, 1695, 0, 0, 0, 0, + 0, 0, 0, 0, 1691, 0, 0, 0, 0, 1692, + 0, 0, 0, 0, 1693, 1694, 0, 1696, 0, 0, + 1697, 0, 1690, 0, 0, 0, 0, 0, 0, 0, + 1695, 0, 1693, 1694, 1698, 1696, 0, 1699, 1697, 1691, + 0, 0, 0, 0, 1692, 0, 0, 0, 1695, 0, + 0, 0, 1698, 0, 0, 1699, 0, 0, 0, 0, + 0, 0, 0, 0, 1690, 0, 0, 1693, 1694, 0, + 1696, 0, 0, 1697, 0, 0, 0, 0, 0, 0, + 0, 1691, 0, 1695, 0, 0, 1692, 1698, 1696, 0, + 1699, 1697, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1698, 0, 0, 1699, 1693, + 1694, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1696, 0, 1695, 1697, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, + 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, + 0, 0, 0, 1676, 0, 1696, 1677, 0, 1697, 0, + 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, + 0, 0, 1698, 0, 0, 1699, 0, 0, 0, 0, + 1700, 0, 1685, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1687, 0, 0, 0, 0, 0, 1700, 1688, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1689, 0, 0, 0, + 0, 0, 0, 1700, 0, 0, 0, 0, 0, 1701, + 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, + 1709, 1710, 0, 0, 0, 0, 2975, 1701, 0, 0, + 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, + 0, 0, 0, 0, 3049, 1700, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, + 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, 3252, + 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, + 1708, 1709, 1710, 0, 1690, 0, 0, 3259, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1691, 0, 0, 0, 1701, 1692, 0, 1702, 1703, + 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, + 0, 0, 3346, 0, 1676, 0, 0, 1677, 0, 1693, + 1694, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, + 0, 0, 0, 0, 0, 1695, 0, 1701, 0, 0, + 1702, 1703, 1704, 1685, 1705, 1706, 1707, 1708, 1709, 1710, + 0, 0, 0, 1687, 3432, 1676, 0, 0, 1677, 0, + 1688, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, + 0, 0, 0, 0, 0, 1696, 0, 0, 1697, 0, + 0, 0, 0, 0, 1685, 0, 0, 1689, 0, 0, + 0, 0, 1698, 0, 1687, 1699, 0, 0, 0, 0, + 0, 1688, 0, 0, 1676, 0, 0, 1677, 0, 0, + 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1689, 0, - 0, 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, + 0, 0, 0, 1685, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1687, 0, 0, 0, 0, 0, 0, + 1688, 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, - 0, 0, 0, 0, 0, 1690, 0, 0, 0, 0, - 0, 1685, 0, 2015, 0, 0, 0, 0, 2016, 0, - 0, 1687, 1691, 1690, 0, 0, 0, 1692, 1688, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1691, 0, 0, 0, 0, 1692, 0, 3779, 0, 0, - 1693, 1694, 0, 0, 0, 1689, 0, 0, 1690, 0, - 0, 0, 0, 0, 0, 0, 1695, 0, 1693, 1694, - 0, 0, 0, 0, 0, 1691, 1690, 0, 0, 0, - 1692, 0, 0, 0, 1695, 0, 0, 0, 0, 0, - 0, 0, 0, 1691, 0, 0, 0, 0, 1692, 0, - 0, 0, 0, 1693, 1694, 0, 1696, 0, 0, 1697, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1695, - 0, 1693, 1694, 1698, 1696, 0, 1699, 1697, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1695, 0, 0, - 0, 1698, 0, 0, 1699, 0, 0, 0, 0, 0, - 0, 0, 0, 1690, 0, 0, 0, 0, 0, 1696, - 0, 0, 1697, 0, 0, 0, 0, 0, 0, 0, - 1691, 0, 0, 0, 0, 1692, 1698, 1696, 0, 1699, - 1697, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1698, 0, 0, 1699, 1693, 1694, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 3780, - 0, 0, 0, 0, 1695, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1676, - 0, 0, 1677, 0, 1700, 0, 1678, 1679, 1680, 1681, - 0, 1682, 1683, 1684, 1696, 0, 0, 1697, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 1685, 0, - 0, 1698, 2021, 0, 1699, 0, 0, 0, 1687, 1700, - 0, 0, 0, 0, 0, 1688, 0, 0, 0, 0, - 0, 0, 0, 2276, 0, 0, 0, 1700, 1986, 0, + 0, 0, 0, 0, 0, 0, 0, 1689, 0, 0, + 0, 1685, 0, 0, 0, 1690, 0, 0, 0, 0, + 0, 1687, 0, 0, 0, 1700, 0, 0, 1688, 0, + 0, 0, 1691, 0, 0, 0, 1676, 1692, 0, 1677, + 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, + 1684, 0, 0, 0, 0, 1689, 1690, 0, 0, 0, + 1693, 1694, 0, 0, 0, 1685, 0, 0, 0, 0, + 0, 0, 0, 1691, 0, 1687, 1695, 0, 1692, 0, + 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1689, 0, 0, 0, 0, 0, 0, 0, + 0, 1693, 1694, 0, 0, 1690, 0, 0, 0, 1689, + 0, 0, 0, 0, 0, 0, 1696, 1695, 0, 1697, + 0, 0, 1691, 0, 0, 0, 0, 1692, 0, 0, + 0, 0, 0, 1698, 0, 0, 1699, 1701, 0, 0, + 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, + 1693, 1694, 0, 1690, 3460, 0, 0, 1696, 0, 0, + 1697, 0, 0, 0, 0, 0, 1695, 0, 0, 0, + 1691, 0, 0, 0, 1698, 1692, 0, 1699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1693, 1694, + 0, 0, 0, 0, 0, 0, 1696, 1690, 0, 1697, + 0, 0, 0, 0, 1695, 0, 0, 0, 0, 0, + 0, 0, 0, 1698, 1691, 0, 1699, 0, 0, 1692, + 0, 0, 0, 0, 0, 0, 1700, 1676, 0, 0, + 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, + 1683, 1684, 1693, 1694, 1696, 0, 0, 1697, 0, 0, + 0, 0, 0, 0, 0, 0, 1685, 0, 1695, 0, + 0, 1698, 0, 0, 1699, 0, 1687, 1700, 0, 0, + 0, 0, 0, 1688, 0, 0, 0, 0, 1676, 0, + 0, 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, + 1682, 1683, 1684, 0, 0, 0, 0, 0, 1696, 0, + 1689, 1697, 0, 0, 0, 0, 0, 1685, 0, 0, + 0, 0, 0, 0, 0, 1698, 1700, 1687, 1699, 0, + 0, 0, 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 0, 0, 0, 0, 0, 1701, 0, 0, 1702, - 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, - 0, 0, 0, 0, 1700, 0, 1676, 0, 0, 1677, - 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, - 1684, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, - 1707, 1708, 1709, 1710, 0, 1685, 0, 0, 0, 1701, - 1690, 0, 1702, 1703, 1704, 1687, 1705, 1706, 1707, 1708, - 1709, 1710, 1688, 0, 0, 0, 0, 1691, 1676, 0, - 0, 1677, 1692, 0, 0, 1678, 1679, 1680, 1681, 0, - 1682, 1683, 1684, 0, 0, 0, 0, 0, 0, 1689, - 0, 0, 0, 0, 0, 1693, 1694, 1685, 0, 0, - 0, 2028, 0, 0, 0, 0, 0, 1687, 0, 0, - 0, 1695, 0, 0, 1688, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1701, 0, 0, 1702, - 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, - 0, 1689, 0, 0, 0, 0, 0, 0, 0, 1676, - 0, 1696, 1677, 0, 1697, 0, 1678, 1679, 1680, 1681, - 0, 1682, 1683, 1684, 0, 0, 0, 0, 1698, 0, - 0, 1699, 0, 0, 0, 0, 0, 0, 1685, 0, - 0, 0, 2026, 0, 0, 0, 0, 1690, 1687, 0, - 0, 0, 0, 0, 0, 1688, 0, 0, 0, 0, - 0, 0, 0, 0, 1691, 0, 0, 0, 0, 1692, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1689, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1693, 1694, 0, 0, 0, 0, 0, 1690, - 0, 0, 0, 0, 0, 0, 0, 0, 1695, 0, - 0, 0, 0, 0, 0, 0, 1691, 0, 0, 0, - 0, 1692, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1693, 1694, 0, 0, 1696, 0, - 0, 1697, 0, 0, 0, 0, 0, 0, 0, 0, - 1695, 0, 0, 0, 0, 1698, 0, 0, 1699, 0, - 2164, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1690, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1691, 0, 0, - 1696, 0, 1692, 1697, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1698, 0, 0, - 1699, 0, 0, 0, 0, 1693, 1694, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1695, 0, 1701, 0, 0, 1702, 1703, 1704, 0, - 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, - 0, 0, 0, 1676, 0, 0, 1677, 0, 1700, 0, - 1678, 1679, 1680, 1681, 2637, 1682, 1683, 1684, 0, 0, - 0, 1696, 0, 0, 1697, 0, 0, 0, 0, 0, - 0, 0, 1685, 0, 0, 0, 0, 0, 1698, 0, - 0, 1699, 1687, 0, 0, 0, 0, 0, 0, 1688, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1689, 0, 0, 0, - 1676, 0, 0, 1677, 0, 0, 0, 1678, 1679, 1680, - 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1685, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1687, - 1701, 0, 0, 1702, 1703, 1704, 1688, 1705, 1706, 1707, - 1708, 1709, 1710, 0, 0, 0, 0, 0, 0, 0, - 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1689, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1701, 0, 1690, 1702, 1703, 1704, 0, 1705, - 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, 0, - 0, 1691, 0, 0, 1676, 0, 1692, 1677, 0, 0, - 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1693, - 1694, 0, 0, 1685, 0, 0, 0, 2968, 0, 0, - 0, 0, 0, 1687, 0, 1695, 0, 0, 0, 0, - 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1690, 0, 1701, 0, 0, 1702, 1703, 1704, 0, - 1705, 1706, 1707, 1708, 1709, 1710, 0, 1689, 1691, 0, - 0, 0, 0, 1692, 1676, 1696, 0, 1677, 1697, 0, - 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, - 0, 0, 1698, 0, 0, 1699, 1693, 1694, 0, 0, - 0, 0, 0, 1685, 0, 0, 0, 0, 0, 0, - 0, 0, 1695, 1687, 0, 0, 0, 0, 0, 0, - 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1689, 0, 0, - 0, 0, 1696, 0, 0, 1697, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1690, 0, 0, 0, 1698, - 0, 0, 1699, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1691, 0, 0, 0, 0, 1692, 0, 0, - 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1695, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1690, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1691, 0, 0, 0, 1696, 1692, 0, 1697, - 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 1698, 0, 0, 1699, 0, 0, 0, - 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1695, 1701, 2952, 0, - 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, - 0, 0, 0, 0, 0, 1676, 0, 0, 1677, 0, - 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, - 0, 0, 0, 0, 0, 0, 1696, 0, 0, 1697, - 0, 0, 0, 0, 1685, 0, 0, 0, 0, 0, - 0, 0, 0, 1698, 1687, 0, 1699, 0, 0, 0, - 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1701, 0, 1700, 1702, 1703, 1704, - 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 1689, 0, - 0, 0, 0, 1676, 0, 0, 1677, 0, 0, 0, - 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1685, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1687, 0, 0, 0, 0, 0, 0, 1688, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1689, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 1690, 0, 1701, 0, - 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 0, 0, 1691, 0, 0, 0, 0, 1692, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 1889, 1694, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1695, 0, 0, + 1710, 1689, 0, 0, 0, 3614, 0, 0, 0, 0, + 0, 0, 0, 0, 1700, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1701, + 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, + 1709, 1710, 0, 0, 0, 0, 3677, 0, 1690, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1690, 0, 0, 0, 1701, 0, + 0, 0, 0, 0, 0, 1691, 0, 0, 1700, 0, + 1692, 0, 0, 0, 0, 0, 0, 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, - 1710, 1691, 0, 0, 0, 0, 1692, 1696, 0, 0, - 1697, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 1698, 0, 0, 1699, 0, 1693, - 1694, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1695, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1696, 0, 0, 1697, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 1698, 0, 0, 1699, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, + 1710, 0, 0, 1693, 1694, 3703, 0, 0, 0, 1690, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1695, + 0, 0, 0, 0, 0, 0, 1691, 0, 0, 0, + 0, 1692, 0, 0, 0, 0, 1701, 0, 0, 1702, + 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, + 0, 1876, 0, 0, 1693, 1694, 0, 0, 0, 1696, + 0, 0, 1697, 0, 0, 0, 0, 0, 0, 0, + 1695, 0, 0, 0, 0, 0, 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, + 1708, 1709, 1710, 0, 0, 2996, 0, 0, 0, 0, + 1696, 0, 0, 1697, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1698, 0, 0, + 1699, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 1701, - 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, - 1709, 1710, 0, 0, 0, 0, 0, 0, 0, 0, + 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 570, 0, 2188, 0, 0, 0, 0, 1701, 0, 0, - 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 2293, 1710, - 122, 123, 124, 125, 126, 127, 128, 129, 571, 130, - 131, 132, 572, 573, 574, 575, 576, 577, 578, 579, - 580, 134, 135, 581, 582, 137, 138, 583, 140, 141, - 142, 584, 585, 586, 587, 588, 589, 590, 148, 149, - 150, 151, 152, 591, 592, 153, 154, 155, 156, 593, - 594, 159, 595, 160, 161, 162, 163, 596, 597, 598, - 599, 600, 167, 168, 169, 170, 171, 601, 173, 174, - 175, 602, 176, 177, 178, 179, 180, 181, 603, 604, - 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 606, 194, 195, 607, 197, 608, 198, 609, 199, 200, - 201, 202, 203, 204, 610, 611, 205, 206, 207, 208, - 612, 613, 209, 210, 211, 212, 213, 614, 214, 215, - 216, 615, 217, 218, 219, 220, 616, 221, 222, 223, - 224, 617, 226, 227, 228, 229, 230, 231, 618, 619, - 233, 620, 234, 235, 621, 237, 622, 238, 623, 239, - 624, 625, 626, 242, 243, 627, 628, 246, 247, 248, - 629, 630, 631, 251, 252, 632, 253, 254, 255, 256, - 257, 258, 259, 633, 261, 262, 263, 264, 634, 265, - 266, 267, 268, 269, 270, 271, 635, 272, 636, 637, - 275, 276, 277, 278, 279, 638, 639, 640, 641, 642, - 283, 643, 644, 286, 645, 288, 289, 290, 646, 291, - 292, 293, 647, 648, 294, 649, 296, 650, 651, 298, - 299, 300, 301, 302, 303, 304, 305, 652, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 653, 654, 655, 332, 333, 334, 656, 657, 336, 337, - 658, 339, 659, 660, 341, 661, 343, 344, 345, 662, - 346, 347, 663, 664, 348, 349, 350, 665, 666, 351, - 352, 667, 668, 355, 669, 670, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 671, 672, - 673, 674, 370, 371, 675, 676, 374, 375, 677, 377, - 378, 379, 678, 380, 381, 382, 383, 384, 385, 679, - 386, 387, 388, 389, 390, 680, 392, 393, 394, 395, - 681, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 682, 409, 410, 683, 412, 413, - 414, 684, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 685, 686, 429, 430, 431, - 432, 433, 434, 687, 436, 437, 688, 689, 439, 440, - 690, 442, 691, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 692, 458, 693, - 694, 695, 460, 461, 696, 462, 697, 464, 465, 466, - 467, 468, 469, 698, 470, 699, 700, 701, 702, 473, - 474, 703, 476, 704, 705, 478, 479, 706, 481, 482, - 483, 484, 485, 707, 708, 486, 487, 488, 709, 710, - 489, 490, 491, 492, 711, 493, 494, 495, 496, 497, - 712, 713, 500, 714, 501, 715, 503, 504, 505, 506, - 507, 508, 509, 716, 717, 510, 718, 719, 511, 512, - 513, 514, 515, 516, 720, 721, 722, 723, 724, 725, - 726, 727, 728, 729, 730, 528, 529, 530, 531, 570, + 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, + 1707, 1708, 1709, 1710, 0, 0, 3422, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, - 123, 124, 125, 126, 127, 128, 129, 571, 130, 131, - 132, 572, 573, 574, 575, 576, 577, 578, 579, 580, - 134, 135, 581, 582, 137, 138, 583, 140, 141, 142, - 584, 585, 586, 587, 588, 589, 590, 148, 149, 150, - 151, 152, 591, 592, 153, 154, 155, 156, 593, 594, - 159, 595, 160, 161, 162, 163, 596, 597, 598, 599, - 600, 167, 168, 169, 170, 171, 601, 173, 174, 175, - 602, 176, 177, 178, 179, 180, 181, 603, 604, 183, - 184, 185, 186, 187, 188, 605, 190, 191, 192, 606, - 194, 195, 607, 197, 608, 198, 609, 199, 200, 201, - 202, 203, 204, 610, 611, 205, 206, 207, 208, 612, - 613, 209, 210, 211, 212, 213, 614, 214, 215, 216, - 615, 217, 218, 219, 220, 616, 221, 222, 223, 224, - 617, 226, 227, 228, 229, 230, 231, 618, 619, 233, - 620, 234, 235, 621, 237, 622, 238, 623, 239, 624, - 625, 626, 242, 243, 627, 628, 246, 247, 248, 629, - 630, 631, 251, 252, 632, 253, 254, 255, 256, 257, - 258, 259, 633, 261, 262, 263, 264, 634, 265, 266, - 267, 268, 269, 270, 271, 635, 272, 636, 637, 275, - 276, 277, 278, 279, 638, 639, 640, 641, 642, 283, - 643, 644, 286, 645, 288, 289, 290, 646, 291, 292, - 293, 647, 648, 294, 649, 296, 650, 651, 298, 299, - 300, 301, 302, 303, 304, 305, 652, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, 321, 322, 323, 324, 325, 326, 327, 328, 653, - 654, 655, 332, 333, 334, 656, 657, 336, 337, 658, - 339, 659, 660, 341, 661, 343, 344, 345, 662, 346, - 347, 663, 664, 348, 349, 350, 665, 666, 351, 352, - 667, 668, 355, 669, 670, 358, 359, 360, 361, 362, - 363, 364, 365, 366, 367, 368, 369, 671, 672, 673, - 674, 370, 371, 675, 676, 374, 375, 677, 377, 378, - 379, 678, 380, 381, 382, 383, 384, 385, 679, 386, - 387, 388, 389, 390, 680, 392, 393, 394, 395, 681, - 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, - 406, 407, 408, 682, 409, 410, 683, 412, 413, 414, - 684, 416, 417, 418, 419, 420, 421, 422, 423, 424, - 425, 426, 427, 428, 685, 686, 429, 430, 431, 432, - 433, 434, 687, 436, 437, 688, 689, 439, 440, 690, - 442, 691, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, 456, 692, 458, 693, 694, - 695, 460, 461, 696, 462, 697, 464, 465, 466, 467, - 468, 469, 698, 470, 699, 700, 701, 702, 473, 474, - 703, 476, 704, 705, 478, 479, 706, 481, 482, 483, - 484, 485, 707, 708, 486, 487, 488, 709, 710, 489, - 490, 491, 492, 711, 493, 494, 495, 496, 497, 712, - 713, 500, 714, 501, 715, 503, 504, 505, 506, 507, - 508, 509, 716, 717, 510, 718, 719, 511, 512, 513, - 514, 515, 516, 720, 721, 722, 723, 724, 725, 726, - 727, 728, 729, 730, 528, 529, 530, 531, 570, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, + 0, 0, 0, 0, 0, 0, 0, 0, 570, 0, + 0, 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, + 1706, 1707, 1708, 1709, 1710, 0, 0, 3657, 122, 123, 124, 125, 126, 127, 128, 129, 571, 130, 131, 132, 572, 573, 574, 575, 576, 577, 578, 579, 580, 134, 135, 581, 582, 137, 138, 583, 140, 141, 142, 584, @@ -9624,7 +9107,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 229, 230, 231, 618, 619, 233, 620, 234, 235, 621, 237, 622, 238, 623, 239, 624, 625, 626, 242, 243, 627, 628, 246, 247, 248, 629, 630, - 631, 251, 252, 632, 253, 254, 255, 256, 257, 970, + 631, 251, 252, 632, 253, 254, 255, 256, 257, 258, 259, 633, 261, 262, 263, 264, 634, 265, 266, 267, 268, 269, 270, 271, 635, 272, 636, 637, 275, 276, 277, 278, 279, 638, 639, 640, 641, 642, 283, 643, @@ -9656,112 +9139,112 @@ static const yytype_int16 yytable[] = 500, 714, 501, 715, 503, 504, 505, 506, 507, 508, 509, 716, 717, 510, 718, 719, 511, 512, 513, 514, 515, 516, 720, 721, 722, 723, 724, 725, 726, 727, - 728, 729, 730, 528, 529, 530, 531, 570, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 728, 729, 730, 528, 529, 530, 531, 539, 0, 0, + 0, 0, 0, 0, 0, 0, 2172, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, - 125, 126, 127, 128, 129, 571, 130, 131, 132, 572, - 573, 574, 575, 576, 577, 578, 579, 580, 134, 135, - 581, 582, 137, 138, 583, 140, 141, 142, 584, 585, - 586, 587, 588, 589, 590, 148, 149, 150, 151, 152, - 591, 592, 153, 154, 155, 156, 593, 594, 159, 595, - 160, 161, 162, 163, 596, 597, 598, 599, 600, 167, - 168, 169, 170, 171, 601, 173, 174, 175, 602, 176, - 177, 178, 179, 180, 181, 603, 604, 183, 184, 185, - 186, 187, 188, 189, 190, 191, 192, 606, 194, 195, - 607, 197, 608, 198, 609, 199, 200, 201, 202, 203, - 204, 610, 611, 205, 206, 207, 208, 612, 613, 209, - 210, 211, 212, 213, 614, 214, 215, 216, 615, 217, - 218, 219, 220, 616, 221, 222, 223, 224, 617, 226, - 227, 228, 229, 230, 231, 618, 619, 233, 620, 234, - 235, 621, 237, 622, 238, 623, 239, 624, 625, 626, - 242, 243, 627, 628, 246, 247, 248, 629, 630, 631, - 251, 252, 632, 253, 254, 255, 256, 257, 258, 259, - 633, 261, 262, 263, 264, 634, 265, 266, 267, 268, - 269, 270, 271, 635, 272, 636, 637, 275, 276, 277, - 278, 279, 638, 639, 640, 641, 642, 283, 643, 644, - 286, 645, 288, 289, 290, 646, 291, 292, 293, 647, - 648, 294, 649, 296, 650, 651, 298, 299, 300, 301, - 302, 303, 304, 305, 652, 307, 308, 309, 310, 311, + 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, + 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, + 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, + 0, 0, 153, 154, 155, 156, 157, 158, 159, 0, + 160, 161, 162, 163, 164, 0, 0, 0, 166, 167, + 168, 169, 170, 171, 0, 173, 174, 175, 0, 176, + 177, 178, 179, 180, 181, 0, 0, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, + 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, + 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 0, 221, 222, 223, 224, 225, 226, + 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, + 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, + 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, + 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, + 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, + 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, + 286, 0, 288, 289, 290, 0, 291, 292, 293, 0, + 0, 294, 0, 296, 0, 0, 298, 299, 300, 301, + 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, - 322, 323, 324, 325, 326, 327, 328, 653, 654, 655, - 332, 333, 334, 656, 657, 336, 337, 658, 339, 659, - 660, 341, 661, 343, 344, 345, 662, 346, 347, 663, - 664, 348, 349, 350, 665, 666, 351, 352, 667, 668, - 355, 669, 670, 358, 359, 360, 361, 362, 363, 364, - 365, 366, 367, 368, 369, 671, 672, 673, 674, 370, - 371, 675, 676, 374, 375, 677, 377, 378, 379, 678, - 380, 381, 382, 383, 384, 385, 679, 386, 387, 388, - 389, 390, 680, 392, 393, 394, 395, 681, 396, 397, + 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, + 332, 333, 334, 335, 0, 336, 337, 0, 339, 0, + 340, 341, 342, 343, 344, 345, 0, 346, 347, 0, + 0, 348, 349, 350, 0, 0, 351, 352, 353, 0, + 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, + 371, 372, 0, 374, 375, 376, 377, 378, 379, 0, + 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, + 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 682, 409, 410, 683, 412, 413, 414, 684, 416, + 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 427, 428, 685, 686, 429, 430, 431, 432, 433, 434, - 687, 436, 437, 688, 689, 439, 440, 690, 442, 691, + 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, + 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, 456, 692, 458, 693, 694, 695, 460, - 461, 696, 462, 697, 464, 465, 466, 467, 468, 469, - 698, 470, 699, 700, 701, 702, 473, 474, 703, 476, - 704, 705, 478, 479, 706, 481, 482, 483, 484, 485, - 707, 708, 486, 487, 488, 709, 710, 489, 490, 491, - 492, 711, 493, 494, 495, 496, 497, 712, 713, 500, - 714, 501, 715, 503, 504, 505, 506, 507, 508, 509, - 716, 717, 510, 718, 719, 511, 512, 513, 514, 515, - 516, 720, 721, 722, 723, 724, 725, 726, 727, 728, - 729, 730, 528, 529, 530, 531, 570, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, + 461, 0, 462, 0, 464, 465, 466, 467, 468, 469, + 0, 470, 471, 472, 0, 0, 473, 474, 475, 476, + 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, + 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, + 492, 0, 493, 494, 495, 496, 497, 498, 499, 500, + 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, + 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, + 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, + 526, 527, 528, 529, 530, 531, 539, 0, 0, 0, + 0, 0, 0, 0, 0, 2888, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, - 2349, 127, 128, 129, 571, 130, 131, 132, 572, 573, - 574, 575, 576, 577, 578, 579, 580, 134, 135, 581, - 582, 137, 138, 583, 140, 141, 142, 584, 585, 586, - 587, 588, 589, 590, 148, 149, 150, 151, 152, 591, - 592, 153, 154, 155, 156, 593, 594, 159, 595, 160, - 161, 162, 163, 596, 597, 598, 599, 600, 167, 168, - 169, 170, 171, 601, 173, 174, 175, 602, 176, 177, - 178, 179, 180, 181, 603, 604, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 606, 194, 195, 607, - 197, 608, 198, 609, 199, 200, 201, 202, 203, 204, - 610, 611, 205, 206, 207, 208, 612, 613, 209, 210, - 211, 2350, 213, 614, 214, 215, 216, 615, 217, 218, - 219, 220, 616, 221, 222, 223, 224, 617, 226, 227, - 228, 229, 230, 231, 618, 619, 233, 620, 234, 235, - 621, 237, 622, 238, 623, 239, 624, 625, 626, 242, - 243, 627, 628, 246, 247, 248, 629, 630, 631, 251, - 252, 632, 253, 254, 255, 256, 257, 258, 259, 633, - 261, 262, 263, 264, 634, 265, 266, 267, 268, 269, - 270, 271, 635, 272, 636, 637, 275, 276, 277, 278, - 279, 638, 639, 640, 641, 642, 283, 643, 644, 286, - 645, 288, 289, 290, 646, 291, 292, 293, 647, 648, - 294, 649, 296, 650, 651, 298, 299, 300, 301, 302, - 303, 304, 305, 652, 307, 308, 309, 310, 311, 312, + 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, + 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, + 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, + 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, + 161, 162, 163, 164, 0, 0, 0, 166, 167, 168, + 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, + 178, 179, 180, 181, 0, 0, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, + 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, + 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, + 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, + 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, + 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, + 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, + 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, + 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, + 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, + 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, + 294, 0, 296, 0, 0, 298, 299, 300, 301, 302, + 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, 324, 325, 326, 327, 328, 653, 654, 655, 332, - 333, 334, 656, 657, 336, 337, 658, 339, 659, 660, - 341, 661, 343, 344, 345, 662, 346, 347, 663, 664, - 348, 349, 350, 665, 666, 351, 352, 667, 668, 355, - 669, 670, 358, 359, 360, 361, 362, 363, 364, 365, - 366, 367, 368, 369, 671, 672, 673, 674, 370, 371, - 675, 676, 374, 375, 677, 377, 378, 379, 678, 380, - 381, 382, 383, 384, 385, 679, 386, 387, 388, 389, - 390, 680, 392, 393, 394, 395, 681, 396, 397, 398, + 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, + 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, + 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, + 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, + 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, + 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, + 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, - 682, 409, 410, 683, 412, 413, 414, 684, 416, 417, + 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, - 428, 685, 686, 429, 430, 431, 432, 433, 2351, 687, - 436, 437, 688, 689, 439, 440, 690, 442, 691, 443, + 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, + 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, - 454, 455, 456, 692, 458, 693, 694, 695, 460, 461, - 696, 462, 697, 464, 465, 466, 467, 468, 469, 698, - 470, 699, 700, 701, 702, 473, 474, 703, 476, 704, - 705, 478, 479, 706, 481, 482, 483, 484, 485, 707, - 708, 486, 487, 488, 709, 710, 489, 490, 491, 492, - 711, 493, 494, 495, 496, 497, 712, 713, 500, 714, - 501, 715, 503, 504, 505, 506, 507, 508, 509, 716, - 717, 510, 718, 719, 511, 512, 513, 514, 515, 516, - 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, - 730, 528, 529, 530, 531, 994, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, + 0, 462, 0, 464, 465, 466, 467, 468, 469, 0, + 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, + 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, + 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, + 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, + 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, + 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, + 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, + 527, 528, 529, 530, 531, 994, 1395, 836, 0, 0, + 0, 1080, 0, 0, 2891, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, - 127, 128, 129, 0, 130, 131, 132, 3, 4, 0, + 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 575, 0, 0, 0, 0, 580, 134, 135, 0, 582, 137, 138, 583, 140, 141, 142, 584, 585, 586, 587, 588, 0, 590, 148, 149, 150, 151, 152, 0, 0, @@ -9774,7 +9257,7 @@ static const yytype_int16 yytable[] = 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 617, 226, 227, 228, - 229, 230, 231, 618, 0, 233, 0, 234, 235, 621, + 229, 230, 231, 618, 1396, 233, 0, 234, 235, 621, 237, 0, 238, 0, 239, 624, 0, 626, 242, 243, 627, 628, 246, 247, 248, 0, 630, 631, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 633, 261, @@ -9787,7 +9270,7 @@ static const yytype_int16 yytable[] = 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 653, 654, 655, 332, 333, 334, 656, 0, 336, 337, 658, 339, 0, 660, 341, - 661, 343, 344, 345, 0, 346, 347, 0, 0, 348, + 661, 343, 344, 345, 0, 346, 347, 1397, 0, 348, 349, 350, 0, 0, 351, 352, 667, 668, 355, 669, 670, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 675, @@ -9802,329 +9285,850 @@ static const yytype_int16 yytable[] = 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 692, 458, 693, 0, 0, 460, 461, 0, 462, 697, 464, 465, 466, 467, 468, 469, 0, 470, - 699, 700, 0, 0, 473, 474, 703, 476, 704, 0, + 699, 700, 0, 0, 473, 474, 703, 476, 704, 1398, 478, 479, 706, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 709, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 712, 713, 500, 0, 501, 715, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, - 528, 529, 530, 531, 121, 0, 0, 0, 0, 0, + 528, 529, 530, 531, 0, 0, 1676, 0, 0, 1677, + 0, 1399, 1400, 1678, 1679, 1680, 1681, 0, 1682, 1683, + 1684, 0, 0, 0, 1676, 0, 0, 1677, 0, 0, + 0, 1678, 1679, 1680, 1681, 1685, 1682, 1683, 1684, 0, + 2272, 0, 0, 0, 0, 1687, 0, 0, 0, 0, + 0, 0, 1688, 1685, 0, 0, 0, 0, 0, 1676, + 0, 0, 1677, 1687, 0, 0, 1678, 1679, 1680, 1681, + 1688, 1682, 1683, 1684, 0, 0, 0, 1676, 0, 1689, + 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 1685, 1682, + 1683, 1684, 0, 0, 0, 0, 0, 1689, 1687, 0, + 0, 0, 0, 0, 0, 1688, 1685, 0, 0, 0, + 1979, 0, 0, 0, 0, 0, 1687, 0, 0, 0, + 0, 0, 0, 1688, 0, 2273, 0, 0, 0, 0, + 0, 0, 1689, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, - 0, 0, 0, 0, 133, 134, 135, 0, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 0, 0, 148, 149, 150, 151, 152, 0, 805, 153, - 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, - 163, 806, 0, 807, 0, 166, 167, 168, 169, 170, - 171, 172, 173, 174, 175, 0, 176, 177, 178, 179, - 180, 181, 0, 182, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, - 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, - 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 808, 0, 233, 0, 234, 235, 236, 237, - 0, 238, 0, 239, 240, 0, 241, 242, 243, 244, - 245, 246, 247, 248, 0, 249, 250, 251, 252, 0, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, - 0, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 0, 282, 0, 283, 284, 285, 286, 287, 288, - 289, 290, 0, 291, 292, 293, 0, 0, 294, 295, - 296, 297, 0, 298, 299, 300, 301, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - 335, 0, 336, 337, 338, 339, 0, 810, 341, 342, - 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, - 350, 0, 0, 351, 352, 353, 354, 355, 356, 812, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 0, 0, 0, 0, 370, 371, 813, 373, - 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, - 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, - 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 0, 438, 439, 440, 441, 442, 0, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 457, 458, 815, 0, 0, 460, 461, 0, 462, - 463, 464, 465, 466, 467, 468, 469, 0, 470, 471, - 472, 0, 0, 473, 474, 816, 476, 817, 0, 478, - 479, 818, 481, 482, 483, 484, 485, 0, 0, 486, - 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 498, 499, 500, 0, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, - 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 121, 0, 0, 0, 0, 0, 0, + 1689, 0, 0, 0, 1676, 0, 0, 1677, 0, 0, + 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, + 0, 0, 0, 0, 0, 0, 0, 1690, 0, 0, + 0, 0, 0, 1685, 0, 2015, 0, 0, 0, 0, + 2016, 0, 0, 1687, 1691, 1690, 0, 0, 0, 1692, + 1688, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1691, 0, 0, 0, 0, 1692, 0, 3796, + 0, 0, 1693, 1694, 0, 0, 0, 1689, 0, 0, + 1690, 0, 0, 0, 0, 0, 0, 0, 1695, 0, + 1693, 1694, 0, 0, 0, 0, 0, 1691, 1690, 0, + 0, 0, 1692, 0, 0, 0, 1695, 0, 0, 0, + 0, 0, 0, 0, 0, 1691, 0, 0, 0, 0, + 1692, 0, 0, 0, 0, 1693, 1694, 0, 1696, 0, + 0, 1697, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1695, 0, 1693, 1694, 1698, 1696, 0, 1699, 1697, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1695, + 0, 0, 0, 1698, 0, 0, 1699, 0, 0, 0, + 0, 0, 0, 0, 0, 1690, 0, 0, 0, 0, + 0, 1696, 0, 0, 1697, 0, 0, 0, 0, 0, + 0, 0, 1691, 0, 0, 0, 0, 1692, 1698, 1696, + 0, 1699, 1697, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1698, 0, 0, 1699, + 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 3797, 0, 0, 0, 0, 1695, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, - 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, - 0, 0, 0, 133, 134, 135, 0, 136, 137, 138, - 139, 140, 141, 142, 143, 144, 145, 146, 147, 0, - 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, - 155, 156, 157, 158, 159, 0, 160, 161, 162, 163, - 164, 0, 165, 0, 166, 167, 168, 169, 170, 171, - 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, - 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, - 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, - 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, - 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, - 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, - 238, 0, 239, 240, 0, 241, 242, 243, 244, 245, - 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, - 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, - 0, 282, 0, 283, 284, 285, 286, 287, 288, 289, - 290, 0, 291, 292, 293, 0, 0, 294, 295, 296, - 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, - 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, - 0, 336, 337, 338, 339, 0, 340, 341, 342, 343, - 344, 345, 0, 346, 347, 0, 0, 348, 349, 350, - 0, 0, 351, 352, 353, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, - 369, 0, 0, 0, 0, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, - 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, - 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, - 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, - 438, 439, 440, 441, 442, 0, 443, 444, 445, 446, - 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, - 457, 458, 459, 0, 0, 460, 461, 0, 462, 463, - 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, - 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, - 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, - 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, - 495, 496, 497, 498, 499, 500, 0, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, - 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, - 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, - 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, + 0, 1676, 0, 0, 1677, 0, 1700, 0, 1678, 1679, + 1680, 1681, 0, 1682, 1683, 1684, 1696, 0, 0, 1697, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, - 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, - 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, - 156, 157, 158, 159, 1812, 160, 161, 162, 163, 164, - 0, 0, 1813, 166, 167, 168, 169, 170, 171, 0, - 173, 174, 175, 1814, 176, 177, 178, 179, 180, 181, - 0, 0, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, - 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, - 1815, 239, 0, 0, 0, 242, 243, 540, 0, 246, - 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, - 255, 256, 257, 1816, 259, 0, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, - 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, - 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, - 0, 291, 292, 293, 0, 0, 294, 0, 296, 0, - 0, 298, 299, 300, 301, 302, 303, 304, 305, 541, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, - 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, - 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, - 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, - 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, - 376, 377, 378, 379, 1817, 380, 381, 382, 383, 384, - 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, - 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, - 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, - 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, - 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 485, 0, 1818, 486, 487, 488, - 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, + 1685, 0, 0, 1698, 2021, 0, 1699, 0, 0, 0, + 1687, 1700, 0, 0, 0, 0, 0, 1688, 0, 0, + 0, 0, 0, 0, 0, 2276, 0, 0, 0, 1700, + 1986, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1689, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, - 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, - 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, - 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, - 157, 158, 159, 1812, 160, 161, 162, 163, 164, 0, - 0, 0, 166, 167, 168, 169, 170, 171, 0, 173, - 174, 175, 1814, 176, 177, 178, 179, 180, 181, 0, - 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, - 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, - 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, - 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 0, 233, 0, 234, 235, 236, 237, 0, 238, 1815, - 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, - 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, - 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, - 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, - 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, - 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, - 291, 292, 293, 0, 0, 294, 0, 296, 2440, 0, - 298, 299, 300, 301, 302, 303, 304, 305, 541, 307, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, - 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, - 0, 346, 347, 0, 0, 348, 349, 350, 0, 0, - 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, - 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, - 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, - 377, 378, 379, 1817, 380, 381, 382, 383, 384, 385, - 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, - 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, - 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, - 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, - 459, 0, 0, 460, 461, 0, 462, 0, 464, 465, - 466, 467, 468, 469, 0, 470, 471, 472, 0, 0, - 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, - 482, 483, 484, 485, 0, 1818, 486, 487, 488, 0, - 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, - 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, - 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, - 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, - 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, - 1534, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, - 131, 132, 0, 0, 0, 1535, 0, 0, -864, 0, - 1536, 134, 135, 0, 1537, 137, 138, 1538, 140, 141, - 142, 0, 1539, 1540, 1541, 1542, 0, 1543, 148, 149, - 150, 151, 152, 0, 0, 153, 154, 155, 156, 1544, - 1545, 159, 0, 160, 161, 162, 163, 0, 0, 1546, - 0, 1547, 167, 168, 169, 170, 171, 1548, 173, 174, - 175, 0, 176, 177, 178, 179, 180, 181, 0, 1549, + 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, + 1708, 1709, 1710, 0, 0, 0, 0, 0, 1701, 0, + 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, + 1710, 0, 0, 0, 0, 0, 1700, 0, 1676, 0, + 0, 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, + 1682, 1683, 1684, 1701, 0, 0, 1702, 1703, 1704, 0, + 1705, 1706, 1707, 1708, 1709, 1710, 0, 1685, 0, 0, + 0, 1701, 1690, 0, 1702, 1703, 1704, 1687, 1705, 1706, + 1707, 1708, 1709, 1710, 1688, 0, 0, 0, 0, 1691, + 1676, 0, 0, 1677, 1692, 0, 0, 1678, 1679, 1680, + 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, 0, + 0, 1689, 0, 0, 0, 0, 0, 1693, 1694, 1685, + 0, 0, 0, 2028, 0, 0, 0, 0, 0, 1687, + 0, 0, 0, 1695, 0, 0, 1688, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1701, 0, + 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, + 1710, 0, 0, 1689, 0, 0, 0, 0, 0, 0, + 0, 1676, 0, 1696, 1677, 0, 1697, 0, 1678, 1679, + 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, 0, + 1698, 0, 0, 1699, 0, 0, 0, 0, 0, 0, + 1685, 0, 0, 0, 2026, 0, 0, 0, 0, 1690, + 1687, 0, 0, 0, 0, 0, 0, 1688, 0, 0, + 0, 0, 0, 0, 0, 0, 1691, 0, 0, 0, + 0, 1692, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1689, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1693, 1694, 0, 0, 0, 0, + 0, 1690, 0, 0, 0, 0, 0, 0, 0, 0, + 1695, 0, 0, 0, 0, 0, 0, 0, 1691, 0, + 0, 0, 0, 1692, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1700, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1693, 1694, 0, 0, + 1696, 0, 0, 1697, 0, 0, 0, 0, 0, 0, + 0, 0, 1695, 0, 0, 0, 0, 1698, 0, 0, + 1699, 0, 2164, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1690, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1691, + 0, 0, 1696, 0, 1692, 1697, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1698, + 0, 0, 1699, 0, 0, 0, 0, 1693, 1694, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1695, 0, 1701, 0, 0, 1702, 1703, + 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, + 0, 0, 0, 0, 0, 1676, 0, 0, 1677, 0, + 1700, 0, 1678, 1679, 1680, 1681, 2638, 1682, 1683, 1684, + 0, 0, 0, 1696, 0, 0, 1697, 0, 0, 0, + 0, 0, 0, 0, 1685, 0, 0, 0, 0, 0, + 1698, 0, 0, 1699, 1687, 0, 0, 0, 0, 0, + 0, 1688, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1700, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1689, 0, + 0, 0, 1676, 0, 0, 1677, 0, 0, 0, 1678, + 1679, 1680, 1681, 0, 1682, 1683, 1684, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1685, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1687, 1701, 0, 0, 1702, 1703, 1704, 1688, 1705, + 1706, 1707, 1708, 1709, 1710, 0, 0, 0, 0, 0, + 0, 0, 0, 1700, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1689, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1701, 0, 1690, 1702, 1703, 1704, + 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 0, 0, + 0, 0, 0, 1691, 0, 0, 1676, 0, 1692, 1677, + 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, + 1684, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1693, 1694, 0, 0, 1685, 0, 0, 0, 2970, + 0, 0, 0, 0, 0, 1687, 0, 1695, 0, 0, + 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1690, 0, 1701, 0, 0, 1702, 1703, + 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, 1689, + 1691, 0, 0, 0, 0, 1692, 1676, 1696, 0, 1677, + 1697, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, + 1684, 0, 0, 0, 1698, 0, 0, 1699, 1693, 1694, + 0, 0, 0, 0, 0, 1685, 0, 0, 0, 0, + 0, 0, 0, 0, 1695, 1687, 0, 0, 0, 0, + 0, 0, 1688, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1689, + 0, 0, 0, 0, 1696, 0, 0, 1697, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1690, 0, 0, + 0, 1698, 0, 0, 1699, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1691, 0, 0, 0, 0, 1692, + 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1695, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1690, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1691, 0, 0, 0, 1696, 1692, + 0, 1697, 0, 0, 1700, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1698, 0, 0, 1699, 0, + 0, 0, 1693, 1694, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1695, 1701, + 2954, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, + 1709, 1710, 0, 0, 0, 0, 0, 1676, 0, 0, + 1677, 0, 0, 0, 1678, 1679, 1680, 1681, 0, 1682, + 1683, 1684, 0, 0, 0, 0, 0, 0, 1696, 0, + 0, 1697, 0, 0, 0, 0, 1685, 0, 0, 0, + 0, 0, 0, 0, 0, 1698, 1687, 0, 1699, 0, + 0, 0, 0, 1688, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1701, 0, 1700, 1702, + 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, 0, + 1689, 0, 0, 0, 0, 1676, 0, 0, 1677, 0, + 0, 0, 1678, 1679, 1680, 1681, 0, 1682, 1683, 1684, + 0, 0, 0, 0, 1676, 0, 0, 1677, 0, 0, + 0, 1678, 1679, 0, 1685, 0, 1682, 1683, 1684, 0, + 0, 0, 0, 0, 1687, 0, 0, 0, 0, 0, + 0, 1688, 0, 1685, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1687, 0, 0, 0, 0, 1700, 0, + 1688, 0, 0, 0, 0, 0, 0, 0, 1689, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1689, 1690, 0, + 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, + 1708, 1709, 1710, 0, 0, 1691, 0, 0, 0, 0, + 1692, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1676, 0, 0, 1677, 0, 0, 0, + 1678, 1679, 0, 1889, 1694, 1682, 1683, 1684, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1695, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1687, 0, 0, 0, 1690, 0, 0, 1688, + 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, + 1708, 1709, 1710, 1691, 0, 1690, 0, 0, 1692, 1696, + 0, 0, 1697, 0, 0, 0, 1689, 0, 0, 0, + 0, 0, 1691, 0, 0, 0, 1698, 1692, 0, 1699, + 0, 1693, 1694, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1695, 0, 0, + 1693, 1694, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 1695, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1696, 0, 0, + 1697, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1698, 0, 1696, 1699, 0, 1697, + 0, 0, 0, 0, 1690, 0, 0, 0, 0, 0, + 0, 0, 0, 1698, 0, 0, 1699, 0, 0, 1700, + 0, 1691, 0, 0, 0, 0, 1692, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1693, + 1694, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1695, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1700, 0, 0, + 0, 0, 0, 0, 0, 1696, 0, 0, 1697, 0, + 0, 0, 0, 0, 0, 0, 1700, 0, 0, 0, + 0, 0, 1698, 0, 0, 0, 0, 0, 0, 0, + 0, 1701, 0, 0, 1702, 1703, 1704, 0, 1705, 1706, + 1707, 1708, 1709, 1710, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1701, + 0, 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, + 2293, 1710, 0, 0, 0, 1700, 0, 0, 1701, 0, + 0, 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, + 1710, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 570, 0, 2188, 0, 0, 0, 0, 1701, 0, 0, + 1702, 1703, 1704, 0, 1705, 1706, 1707, 1708, 1709, 1710, + 122, 123, 124, 125, 126, 127, 128, 129, 571, 130, + 131, 132, 572, 573, 574, 575, 576, 577, 578, 579, + 580, 134, 135, 581, 582, 137, 138, 583, 140, 141, + 142, 584, 585, 586, 587, 588, 589, 590, 148, 149, + 150, 151, 152, 591, 592, 153, 154, 155, 156, 593, + 594, 159, 595, 160, 161, 162, 163, 596, 597, 598, + 599, 600, 167, 168, 169, 170, 171, 601, 173, 174, + 175, 602, 176, 177, 178, 179, 180, 181, 603, 604, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, - 1550, 194, 195, 1551, 197, 0, 198, 0, 199, 200, - 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, - 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, - 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, - 224, 0, 226, 227, 228, 229, 230, 231, 0, 0, - 233, 0, 234, 235, 1552, 237, 0, 238, 0, 239, - 1553, 0, 1554, 242, 243, -864, 1555, 246, 247, 248, - 0, 0, 0, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 1556, 261, 262, 263, 264, 0, 265, - 266, 267, 268, 269, 270, 271, 0, 272, 1557, 0, - 275, 276, 277, 278, 279, 1558, 1559, 0, 1560, 0, - 283, 1561, 1562, 286, 1563, 288, 289, 290, 0, 291, - 292, 293, 0, 0, 294, 1564, 296, 1565, 0, 298, - 299, 300, 301, 302, 303, 304, 305, 1566, 307, 308, + 606, 194, 195, 607, 197, 608, 198, 609, 199, 200, + 201, 202, 203, 204, 610, 611, 205, 206, 207, 208, + 612, 613, 209, 210, 211, 212, 213, 614, 214, 215, + 216, 615, 217, 218, 219, 220, 616, 221, 222, 223, + 224, 617, 226, 227, 228, 229, 230, 231, 618, 619, + 233, 620, 234, 235, 621, 237, 622, 238, 623, 239, + 624, 625, 626, 242, 243, 627, 628, 246, 247, 248, + 629, 630, 631, 251, 252, 632, 253, 254, 255, 256, + 257, 258, 259, 633, 261, 262, 263, 264, 634, 265, + 266, 267, 268, 269, 270, 271, 635, 272, 636, 637, + 275, 276, 277, 278, 279, 638, 639, 640, 641, 642, + 283, 643, 644, 286, 645, 288, 289, 290, 646, 291, + 292, 293, 647, 648, 294, 649, 296, 650, 651, 298, + 299, 300, 301, 302, 303, 304, 305, 652, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, - 1567, 1568, 1569, 332, 333, 334, 0, 0, 336, 337, - 1570, 339, 0, 0, 341, 1571, 343, 344, 345, 0, - 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, - 352, 0, 1572, 355, 1573, 0, 358, 359, 360, 361, - 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, - 0, 0, 370, 371, 0, 1574, 374, 375, 0, 377, - 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, - 386, 387, 388, 389, 390, 1575, 392, 393, 394, 395, - 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, - 405, 406, 407, 408, 0, 409, 410, 1576, 412, 413, - 414, 1577, 416, 417, 418, 419, 420, 421, 422, 423, - 424, 425, 426, 427, 428, 0, 1578, 429, 430, 431, - 432, 433, 434, 1579, 436, 437, 0, 1580, 439, 440, - 1581, 442, 0, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, 456, 1582, 458, 0, - 0, 0, 460, 461, 0, 462, 1583, 464, 465, 466, - 467, 468, 469, 0, 470, 1584, 1585, 0, 0, 473, - 474, 0, 476, 0, 0, 478, 479, 1586, 481, 482, - 483, 484, 485, 1587, 0, 486, 487, 488, 1588, 0, - 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, - 0, 1589, 500, 0, 501, 1590, 503, 504, 505, 506, - 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, - 513, 514, 515, 516, 539, 0, 564, 0, 0, 0, - 0, 0, 0, 0, 0, 528, 529, 530, 531, 0, - 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 128, 129, 0, 130, 131, 132, 3, 4, 0, 0, - 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, - 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, - 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, - 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, - 163, 164, 0, 0, 0, 166, 167, 168, 169, 170, - 171, 0, 173, 174, 175, 0, 176, 177, 178, 179, - 180, 181, 0, 0, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, - 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, - 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, - 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, - 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, - 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, - 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, - 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, - 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, - 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, - 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, - 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, - 296, 0, 0, 298, 299, 300, 301, 302, 303, 304, - 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, - 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, - 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, - 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, - 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, - 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, - 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, - 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, - 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, - 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, - 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, - 0, 464, 465, 466, 467, 468, 469, 0, 470, 471, - 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, - 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, - 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 498, 499, 500, 0, 501, 0, - 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, - 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, - 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, - 129, 565, 130, 131, 132, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, - 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, - 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, - 155, 156, 157, 158, 159, 0, 160, 161, 162, 163, - 164, 0, 0, 0, 166, 167, 168, 169, 170, 171, - 0, 173, 174, 175, 0, 176, 177, 178, 179, 180, - 181, 0, 0, 183, 184, 185, 186, 187, 188, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, + 653, 654, 655, 332, 333, 334, 656, 657, 336, 337, + 658, 339, 659, 660, 341, 661, 343, 344, 345, 662, + 346, 347, 663, 664, 348, 349, 350, 665, 666, 351, + 352, 667, 668, 355, 669, 670, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 671, 672, + 673, 674, 370, 371, 675, 676, 374, 375, 677, 377, + 378, 379, 678, 380, 381, 382, 383, 384, 385, 679, + 386, 387, 388, 389, 390, 680, 392, 393, 394, 395, + 681, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 682, 409, 410, 683, 412, 413, + 414, 684, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, 427, 428, 685, 686, 429, 430, 431, + 432, 433, 434, 687, 436, 437, 688, 689, 439, 440, + 690, 442, 691, 443, 444, 445, 446, 447, 448, 449, + 450, 451, 452, 453, 454, 455, 456, 692, 458, 693, + 694, 695, 460, 461, 696, 462, 697, 464, 465, 466, + 467, 468, 469, 698, 470, 699, 700, 701, 702, 473, + 474, 703, 476, 704, 705, 478, 479, 706, 481, 482, + 483, 484, 485, 707, 708, 486, 487, 488, 709, 710, + 489, 490, 491, 492, 711, 493, 494, 495, 496, 497, + 712, 713, 500, 714, 501, 715, 503, 504, 505, 506, + 507, 508, 509, 716, 717, 510, 718, 719, 511, 512, + 513, 514, 515, 516, 720, 721, 722, 723, 724, 725, + 726, 727, 728, 729, 730, 528, 529, 530, 531, 570, + 0, 836, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, + 123, 124, 125, 126, 127, 128, 129, 571, 130, 131, + 132, 572, 573, 574, 575, 576, 577, 578, 579, 580, + 134, 135, 581, 582, 137, 138, 583, 140, 141, 142, + 584, 585, 586, 587, 588, 589, 590, 148, 149, 150, + 151, 152, 591, 592, 153, 154, 155, 156, 593, 594, + 159, 595, 160, 161, 162, 163, 596, 597, 598, 599, + 600, 167, 168, 169, 170, 171, 601, 173, 174, 175, + 602, 176, 177, 178, 179, 180, 181, 603, 604, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 606, + 194, 195, 607, 197, 608, 198, 609, 199, 200, 201, + 202, 203, 204, 610, 611, 205, 206, 207, 208, 612, + 613, 209, 210, 211, 212, 213, 614, 214, 215, 216, + 615, 217, 218, 219, 220, 616, 221, 222, 223, 224, + 617, 226, 227, 228, 229, 230, 231, 618, 619, 233, + 620, 234, 235, 621, 237, 622, 238, 623, 239, 624, + 625, 626, 242, 243, 627, 628, 246, 247, 248, 629, + 630, 631, 251, 252, 632, 253, 254, 255, 256, 257, + 258, 259, 633, 261, 262, 263, 264, 634, 265, 266, + 267, 268, 269, 270, 271, 635, 272, 636, 637, 275, + 276, 277, 278, 279, 638, 639, 640, 641, 642, 283, + 643, 644, 286, 645, 288, 289, 290, 646, 291, 292, + 293, 647, 648, 294, 649, 296, 650, 651, 298, 299, + 300, 301, 302, 303, 304, 305, 652, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 653, + 654, 655, 332, 333, 334, 656, 657, 336, 337, 658, + 339, 659, 660, 341, 661, 343, 344, 345, 662, 346, + 347, 663, 664, 348, 349, 350, 665, 666, 351, 352, + 667, 668, 355, 669, 670, 358, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 671, 672, 673, + 674, 370, 371, 675, 676, 374, 375, 677, 377, 378, + 379, 678, 380, 381, 382, 383, 384, 385, 679, 386, + 387, 388, 389, 390, 680, 392, 393, 394, 395, 681, + 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 682, 409, 410, 683, 412, 413, 414, + 684, 416, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 428, 685, 686, 429, 430, 431, 432, + 433, 434, 687, 436, 437, 688, 689, 439, 440, 690, + 442, 691, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 692, 458, 693, 694, + 695, 460, 461, 696, 462, 697, 464, 465, 466, 467, + 468, 469, 698, 470, 699, 700, 701, 702, 473, 474, + 703, 476, 704, 705, 478, 479, 706, 481, 482, 483, + 484, 485, 707, 708, 486, 487, 488, 709, 710, 489, + 490, 491, 492, 711, 493, 494, 495, 496, 497, 712, + 713, 500, 714, 501, 715, 503, 504, 505, 506, 507, + 508, 509, 716, 717, 510, 718, 719, 511, 512, 513, + 514, 515, 516, 720, 721, 722, 723, 724, 725, 726, + 727, 728, 729, 730, 528, 529, 530, 531, 570, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, + 124, 125, 126, 127, 128, 129, 571, 130, 131, 132, + 572, 573, 574, 575, 576, 577, 578, 579, 580, 134, + 135, 581, 582, 137, 138, 583, 140, 141, 142, 584, + 585, 586, 587, 588, 589, 590, 148, 149, 150, 151, + 152, 591, 592, 153, 154, 155, 156, 593, 594, 159, + 595, 160, 161, 162, 163, 596, 597, 598, 599, 600, + 167, 168, 169, 170, 171, 601, 173, 174, 175, 602, + 176, 177, 178, 179, 180, 181, 603, 604, 183, 184, + 185, 186, 187, 188, 605, 190, 191, 192, 606, 194, + 195, 607, 197, 608, 198, 609, 199, 200, 201, 202, + 203, 204, 610, 611, 205, 206, 207, 208, 612, 613, + 209, 210, 211, 212, 213, 614, 214, 215, 216, 615, + 217, 218, 219, 220, 616, 221, 222, 223, 224, 617, + 226, 227, 228, 229, 230, 231, 618, 619, 233, 620, + 234, 235, 621, 237, 622, 238, 623, 239, 624, 625, + 626, 242, 243, 627, 628, 246, 247, 248, 629, 630, + 631, 251, 252, 632, 253, 254, 255, 256, 257, 258, + 259, 633, 261, 262, 263, 264, 634, 265, 266, 267, + 268, 269, 270, 271, 635, 272, 636, 637, 275, 276, + 277, 278, 279, 638, 639, 640, 641, 642, 283, 643, + 644, 286, 645, 288, 289, 290, 646, 291, 292, 293, + 647, 648, 294, 649, 296, 650, 651, 298, 299, 300, + 301, 302, 303, 304, 305, 652, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + 321, 322, 323, 324, 325, 326, 327, 328, 653, 654, + 655, 332, 333, 334, 656, 657, 336, 337, 658, 339, + 659, 660, 341, 661, 343, 344, 345, 662, 346, 347, + 663, 664, 348, 349, 350, 665, 666, 351, 352, 667, + 668, 355, 669, 670, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 671, 672, 673, 674, + 370, 371, 675, 676, 374, 375, 677, 377, 378, 379, + 678, 380, 381, 382, 383, 384, 385, 679, 386, 387, + 388, 389, 390, 680, 392, 393, 394, 395, 681, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 682, 409, 410, 683, 412, 413, 414, 684, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 685, 686, 429, 430, 431, 432, 433, + 434, 687, 436, 437, 688, 689, 439, 440, 690, 442, + 691, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 692, 458, 693, 694, 695, + 460, 461, 696, 462, 697, 464, 465, 466, 467, 468, + 469, 698, 470, 699, 700, 701, 702, 473, 474, 703, + 476, 704, 705, 478, 479, 706, 481, 482, 483, 484, + 485, 707, 708, 486, 487, 488, 709, 710, 489, 490, + 491, 492, 711, 493, 494, 495, 496, 497, 712, 713, + 500, 714, 501, 715, 503, 504, 505, 506, 507, 508, + 509, 716, 717, 510, 718, 719, 511, 512, 513, 514, + 515, 516, 720, 721, 722, 723, 724, 725, 726, 727, + 728, 729, 730, 528, 529, 530, 531, 570, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, + 125, 126, 127, 128, 129, 571, 130, 131, 132, 572, + 573, 574, 575, 576, 577, 578, 579, 580, 134, 135, + 581, 582, 137, 138, 583, 140, 141, 142, 584, 585, + 586, 587, 588, 589, 590, 148, 149, 150, 151, 152, + 591, 592, 153, 154, 155, 156, 593, 594, 159, 595, + 160, 161, 162, 163, 596, 597, 598, 599, 600, 167, + 168, 169, 170, 171, 601, 173, 174, 175, 602, 176, + 177, 178, 179, 180, 181, 603, 604, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 606, 194, 195, + 607, 197, 608, 198, 609, 199, 200, 201, 202, 203, + 204, 610, 611, 205, 206, 207, 208, 612, 613, 209, + 210, 211, 212, 213, 614, 214, 215, 216, 615, 217, + 218, 219, 220, 616, 221, 222, 223, 224, 617, 226, + 227, 228, 229, 230, 231, 618, 619, 233, 620, 234, + 235, 621, 237, 622, 238, 623, 239, 624, 625, 626, + 242, 243, 627, 628, 246, 247, 248, 629, 630, 631, + 251, 252, 632, 253, 254, 255, 256, 257, 970, 259, + 633, 261, 262, 263, 264, 634, 265, 266, 267, 268, + 269, 270, 271, 635, 272, 636, 637, 275, 276, 277, + 278, 279, 638, 639, 640, 641, 642, 283, 643, 644, + 286, 645, 288, 289, 290, 646, 291, 292, 293, 647, + 648, 294, 649, 296, 650, 651, 298, 299, 300, 301, + 302, 303, 304, 305, 652, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 653, 654, 655, + 332, 333, 334, 656, 657, 336, 337, 658, 339, 659, + 660, 341, 661, 343, 344, 345, 662, 346, 347, 663, + 664, 348, 349, 350, 665, 666, 351, 352, 667, 668, + 355, 669, 670, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 671, 672, 673, 674, 370, + 371, 675, 676, 374, 375, 677, 377, 378, 379, 678, + 380, 381, 382, 383, 384, 385, 679, 386, 387, 388, + 389, 390, 680, 392, 393, 394, 395, 681, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 682, 409, 410, 683, 412, 413, 414, 684, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 685, 686, 429, 430, 431, 432, 433, 434, + 687, 436, 437, 688, 689, 439, 440, 690, 442, 691, + 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, + 453, 454, 455, 456, 692, 458, 693, 694, 695, 460, + 461, 696, 462, 697, 464, 465, 466, 467, 468, 469, + 698, 470, 699, 700, 701, 702, 473, 474, 703, 476, + 704, 705, 478, 479, 706, 481, 482, 483, 484, 485, + 707, 708, 486, 487, 488, 709, 710, 489, 490, 491, + 492, 711, 493, 494, 495, 496, 497, 712, 713, 500, + 714, 501, 715, 503, 504, 505, 506, 507, 508, 509, + 716, 717, 510, 718, 719, 511, 512, 513, 514, 515, + 516, 720, 721, 722, 723, 724, 725, 726, 727, 728, + 729, 730, 528, 529, 530, 531, 570, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, + 126, 127, 128, 129, 571, 130, 131, 132, 572, 573, + 574, 575, 576, 577, 578, 579, 580, 134, 135, 581, + 582, 137, 138, 583, 140, 141, 142, 584, 585, 586, + 587, 588, 589, 590, 148, 149, 150, 151, 152, 591, + 592, 153, 154, 155, 156, 593, 594, 159, 595, 160, + 161, 162, 163, 596, 597, 598, 599, 600, 167, 168, + 169, 170, 171, 601, 173, 174, 175, 602, 176, 177, + 178, 179, 180, 181, 603, 604, 183, 184, 185, 186, + 187, 188, 189, 190, 191, 192, 606, 194, 195, 607, + 197, 608, 198, 609, 199, 200, 201, 202, 203, 204, + 610, 611, 205, 206, 207, 208, 612, 613, 209, 210, + 211, 212, 213, 614, 214, 215, 216, 615, 217, 218, + 219, 220, 616, 221, 222, 223, 224, 617, 226, 227, + 228, 229, 230, 231, 618, 619, 233, 620, 234, 235, + 621, 237, 622, 238, 623, 239, 624, 625, 626, 242, + 243, 627, 628, 246, 247, 248, 629, 630, 631, 251, + 252, 632, 253, 254, 255, 256, 257, 258, 259, 633, + 261, 262, 263, 264, 634, 265, 266, 267, 268, 269, + 270, 271, 635, 272, 636, 637, 275, 276, 277, 278, + 279, 638, 639, 640, 641, 642, 283, 643, 644, 286, + 645, 288, 289, 290, 646, 291, 292, 293, 647, 648, + 294, 649, 296, 650, 651, 298, 299, 300, 301, 302, + 303, 304, 305, 652, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, + 323, 324, 325, 326, 327, 328, 653, 654, 655, 332, + 333, 334, 656, 657, 336, 337, 658, 339, 659, 660, + 341, 661, 343, 344, 345, 662, 346, 347, 663, 664, + 348, 349, 350, 665, 666, 351, 352, 667, 668, 355, + 669, 670, 358, 359, 360, 361, 362, 363, 364, 365, + 366, 367, 368, 369, 671, 672, 673, 674, 370, 371, + 675, 676, 374, 375, 677, 377, 378, 379, 678, 380, + 381, 382, 383, 384, 385, 679, 386, 387, 388, 389, + 390, 680, 392, 393, 394, 395, 681, 396, 397, 398, + 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, + 682, 409, 410, 683, 412, 413, 414, 684, 416, 417, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 685, 686, 429, 430, 431, 432, 433, 434, 687, + 436, 437, 688, 689, 439, 440, 690, 442, 691, 443, + 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, + 454, 455, 456, 692, 458, 693, 694, 695, 460, 461, + 696, 462, 697, 464, 465, 466, 467, 468, 469, 698, + 470, 699, 700, 701, 702, 473, 474, 703, 476, 704, + 705, 478, 479, 706, 481, 482, 483, 484, 485, 707, + 708, 486, 487, 488, 709, 710, 489, 490, 491, 492, + 711, 493, 494, 495, 496, 497, 712, 713, 500, 714, + 501, 715, 503, 504, 505, 506, 507, 508, 509, 716, + 717, 510, 718, 719, 511, 512, 513, 514, 515, 516, + 720, 721, 722, 723, 724, 725, 726, 727, 728, 729, + 730, 528, 529, 530, 531, 570, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 122, 123, 124, 125, 2349, + 127, 128, 129, 571, 130, 131, 132, 572, 573, 574, + 575, 576, 577, 578, 579, 580, 134, 135, 581, 582, + 137, 138, 583, 140, 141, 142, 584, 585, 586, 587, + 588, 589, 590, 148, 149, 150, 151, 152, 591, 592, + 153, 154, 155, 156, 593, 594, 159, 595, 160, 161, + 162, 163, 596, 597, 598, 599, 600, 167, 168, 169, + 170, 171, 601, 173, 174, 175, 602, 176, 177, 178, + 179, 180, 181, 603, 604, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 606, 194, 195, 607, 197, + 608, 198, 609, 199, 200, 201, 202, 203, 204, 610, + 611, 205, 206, 207, 208, 612, 613, 209, 210, 211, + 2350, 213, 614, 214, 215, 216, 615, 217, 218, 219, + 220, 616, 221, 222, 223, 224, 617, 226, 227, 228, + 229, 230, 231, 618, 619, 233, 620, 234, 235, 621, + 237, 622, 238, 623, 239, 624, 625, 626, 242, 243, + 627, 628, 246, 247, 248, 629, 630, 631, 251, 252, + 632, 253, 254, 255, 256, 257, 258, 259, 633, 261, + 262, 263, 264, 634, 265, 266, 267, 268, 269, 270, + 271, 635, 272, 636, 637, 275, 276, 277, 278, 279, + 638, 639, 640, 641, 642, 283, 643, 644, 286, 645, + 288, 289, 290, 646, 291, 292, 293, 647, 648, 294, + 649, 296, 650, 651, 298, 299, 300, 301, 302, 303, + 304, 305, 652, 307, 308, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, + 324, 325, 326, 327, 328, 653, 654, 655, 332, 333, + 334, 656, 657, 336, 337, 658, 339, 659, 660, 341, + 661, 343, 344, 345, 662, 346, 347, 663, 664, 348, + 349, 350, 665, 666, 351, 352, 667, 668, 355, 669, + 670, 358, 359, 360, 361, 362, 363, 364, 365, 366, + 367, 368, 369, 671, 672, 673, 674, 370, 371, 675, + 676, 374, 375, 677, 377, 378, 379, 678, 380, 381, + 382, 383, 384, 385, 679, 386, 387, 388, 389, 390, + 680, 392, 393, 394, 395, 681, 396, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 682, + 409, 410, 683, 412, 413, 414, 684, 416, 417, 418, + 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, + 685, 686, 429, 430, 431, 432, 433, 2351, 687, 436, + 437, 688, 689, 439, 440, 690, 442, 691, 443, 444, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, 456, 692, 458, 693, 694, 695, 460, 461, 696, + 462, 697, 464, 465, 466, 467, 468, 469, 698, 470, + 699, 700, 701, 702, 473, 474, 703, 476, 704, 705, + 478, 479, 706, 481, 482, 483, 484, 485, 707, 708, + 486, 487, 488, 709, 710, 489, 490, 491, 492, 711, + 493, 494, 495, 496, 497, 712, 713, 500, 714, 501, + 715, 503, 504, 505, 506, 507, 508, 509, 716, 717, + 510, 718, 719, 511, 512, 513, 514, 515, 516, 720, + 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, + 528, 529, 530, 531, 994, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, + 128, 129, 0, 130, 131, 132, 3, 4, 0, 575, + 0, 0, 0, 0, 580, 134, 135, 0, 582, 137, + 138, 583, 140, 141, 142, 584, 585, 586, 587, 588, + 0, 590, 148, 149, 150, 151, 152, 0, 0, 153, + 154, 155, 156, 593, 594, 159, 0, 160, 161, 162, + 163, 596, 0, 598, 0, 600, 167, 168, 169, 170, + 171, 601, 173, 174, 175, 0, 176, 177, 178, 179, + 180, 181, 0, 604, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 606, 194, 195, 607, 197, 0, + 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, + 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, + 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, + 0, 221, 222, 223, 224, 617, 226, 227, 228, 229, + 230, 231, 618, 0, 233, 0, 234, 235, 621, 237, + 0, 238, 0, 239, 624, 0, 626, 242, 243, 627, + 628, 246, 247, 248, 0, 630, 631, 251, 252, 0, + 253, 254, 255, 256, 257, 258, 259, 633, 261, 262, + 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, + 0, 272, 636, 637, 275, 276, 277, 278, 279, 638, + 639, 0, 641, 0, 283, 643, 644, 286, 645, 288, + 289, 290, 0, 291, 292, 293, 0, 0, 294, 649, + 296, 650, 0, 298, 299, 300, 301, 302, 303, 304, + 305, 652, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 653, 654, 655, 332, 333, 334, + 656, 0, 336, 337, 658, 339, 0, 660, 341, 661, + 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, + 350, 0, 0, 351, 352, 667, 668, 355, 669, 670, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, + 368, 369, 0, 0, 0, 0, 370, 371, 675, 676, + 374, 375, 677, 377, 378, 379, 0, 380, 381, 382, + 383, 384, 385, 0, 386, 387, 388, 389, 390, 680, + 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, + 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, + 410, 683, 412, 413, 414, 684, 416, 417, 418, 419, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, + 686, 429, 430, 431, 432, 433, 434, 687, 436, 437, + 0, 689, 439, 440, 690, 442, 0, 443, 444, 445, + 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, + 456, 692, 458, 693, 0, 0, 460, 461, 0, 462, + 697, 464, 465, 466, 467, 468, 469, 0, 470, 699, + 700, 0, 0, 473, 474, 703, 476, 704, 0, 478, + 479, 706, 481, 482, 483, 484, 485, 0, 0, 486, + 487, 488, 709, 0, 489, 490, 491, 492, 0, 493, + 494, 495, 496, 497, 712, 713, 500, 0, 501, 715, + 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, + 0, 0, 511, 512, 513, 514, 515, 516, 720, 721, + 722, 723, 724, 725, 726, 727, 728, 729, 730, 528, + 529, 530, 531, 121, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, + 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, + 0, 0, 0, 133, 134, 135, 0, 136, 137, 138, + 139, 140, 141, 142, 143, 144, 145, 146, 147, 0, + 0, 148, 149, 150, 151, 152, 0, 805, 153, 154, + 155, 156, 157, 158, 159, 0, 160, 161, 162, 163, + 806, 0, 807, 0, 166, 167, 168, 169, 170, 171, + 172, 173, 174, 175, 0, 176, 177, 178, 179, 180, + 181, 0, 182, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, + 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, + 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, + 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, + 231, 808, 0, 233, 0, 234, 235, 236, 237, 0, + 238, 0, 239, 240, 0, 241, 242, 243, 244, 245, + 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, + 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, + 0, 282, 0, 283, 284, 285, 286, 287, 288, 289, + 290, 0, 291, 292, 293, 0, 0, 294, 295, 296, + 297, 0, 298, 299, 300, 301, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, + 0, 336, 337, 338, 339, 0, 810, 341, 342, 343, + 344, 345, 0, 346, 347, 0, 0, 348, 349, 350, + 0, 0, 351, 352, 353, 354, 355, 356, 812, 358, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 0, 0, 0, 0, 370, 371, 813, 373, 374, + 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, + 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, + 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, + 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, + 438, 439, 440, 441, 442, 0, 443, 444, 445, 446, + 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, + 457, 458, 815, 0, 0, 460, 461, 0, 462, 463, + 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, + 0, 0, 473, 474, 816, 476, 817, 0, 478, 479, + 818, 481, 482, 483, 484, 485, 0, 0, 486, 487, + 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, + 495, 496, 497, 498, 499, 500, 0, 501, 502, 503, + 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, + 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, + 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, + 530, 531, 121, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, + 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, + 0, 0, 133, 134, 135, 0, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 0, 0, + 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, + 156, 157, 158, 159, 0, 160, 161, 162, 163, 164, + 0, 165, 0, 166, 167, 168, 169, 170, 171, 172, + 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, + 0, 182, 183, 184, 185, 186, 187, 188, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, + 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, + 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, + 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, + 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, + 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, + 0, 239, 240, 0, 241, 242, 243, 244, 245, 246, + 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 0, + 282, 0, 283, 284, 285, 286, 287, 288, 289, 290, + 0, 291, 292, 293, 0, 0, 294, 295, 296, 297, + 0, 298, 299, 300, 301, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, 335, 0, + 336, 337, 338, 339, 0, 340, 341, 342, 343, 344, + 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, + 0, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 0, 0, 0, 0, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, + 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, + 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, + 403, 404, 405, 406, 407, 408, 0, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, + 430, 431, 432, 433, 434, 435, 436, 437, 0, 438, + 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 0, 0, 460, 461, 0, 462, 463, 464, + 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, + 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, + 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, + 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, + 496, 497, 498, 499, 500, 0, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, + 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, + 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, + 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, + 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, + 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, + 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, + 157, 158, 159, 1812, 160, 161, 162, 163, 164, 0, + 0, 1813, 166, 167, 168, 169, 170, 171, 0, 173, + 174, 175, 1814, 176, 177, 178, 179, 180, 181, 0, + 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, + 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 0, 233, 0, 234, 235, 236, 237, 0, 238, 1815, + 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, + 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, + 256, 257, 1816, 259, 0, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, + 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, + 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, + 291, 292, 293, 0, 0, 294, 0, 296, 0, 0, + 298, 299, 300, 301, 302, 303, 304, 305, 541, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, + 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, + 0, 346, 347, 0, 0, 348, 349, 350, 0, 0, + 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, + 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, + 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, + 377, 378, 379, 1817, 380, 381, 382, 383, 384, 385, + 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, + 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, + 459, 0, 0, 460, 461, 0, 462, 0, 464, 465, + 466, 467, 468, 469, 0, 470, 471, 472, 0, 0, + 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 485, 0, 1818, 486, 487, 488, 0, + 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, + 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, + 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, + 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, + 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, + 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, + 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, + 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, + 158, 159, 1812, 160, 161, 162, 163, 164, 0, 0, + 0, 166, 167, 168, 169, 170, 171, 0, 173, 174, + 175, 1814, 176, 177, 178, 179, 180, 181, 0, 0, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, + 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, + 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, + 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 0, + 233, 0, 234, 235, 236, 237, 0, 238, 1815, 239, + 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, + 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, + 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, + 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, + 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, + 292, 293, 0, 0, 294, 0, 296, 2441, 0, 298, + 299, 300, 301, 302, 303, 304, 305, 541, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 329, 0, 331, 332, 333, 334, 335, 0, 336, 337, + 0, 339, 0, 340, 341, 342, 343, 344, 345, 0, + 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, + 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, + 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, + 378, 379, 1817, 380, 381, 382, 383, 384, 385, 0, + 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, + 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, + 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, + 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, + 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, + 0, 0, 460, 461, 0, 462, 0, 464, 465, 466, + 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, + 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, + 483, 484, 485, 0, 1818, 486, 487, 488, 0, 0, + 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, + 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, + 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, + 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, + 523, 524, 525, 526, 527, 528, 529, 530, 531, 1534, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, + 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, + 132, 0, 0, 0, 1535, 0, 0, -870, 0, 1536, + 134, 135, 0, 1537, 137, 138, 1538, 140, 141, 142, + 0, 1539, 1540, 1541, 1542, 0, 1543, 148, 149, 150, + 151, 152, 0, 0, 153, 154, 155, 156, 1544, 1545, + 159, 0, 160, 161, 162, 163, 0, 0, 1546, 0, + 1547, 167, 168, 169, 170, 171, 1548, 173, 174, 175, + 0, 176, 177, 178, 179, 180, 181, 0, 1549, 183, + 184, 185, 186, 187, 188, 189, 190, 191, 192, 1550, + 194, 195, 1551, 197, 0, 198, 0, 199, 200, 201, + 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, + 0, 209, 210, 1093, 212, 213, 0, 214, 215, 216, + 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, + 0, 226, 227, 228, 229, 230, 231, 0, 0, 233, + 0, 234, 235, 1552, 237, 0, 238, 0, 239, 1553, + 0, 1554, 242, 243, -870, 1555, 246, 247, 248, 0, + 0, 0, 251, 252, 0, 253, 254, 255, 256, 257, + 258, 259, 1556, 261, 262, 263, 264, 0, 265, 266, + 267, 268, 269, 270, 271, 0, 272, 1557, 0, 275, + 276, 277, 278, 279, 1558, 1559, 0, 1560, 0, 283, + 1561, 1562, 286, 1563, 288, 289, 290, 0, 291, 292, + 293, 0, 0, 294, 1564, 296, 1565, 0, 298, 299, + 300, 301, 302, 303, 304, 305, 1566, 307, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, 327, 328, 1567, + 1568, 1569, 332, 333, 334, 0, 0, 336, 337, 1570, + 339, 0, 0, 341, 1571, 343, 344, 345, 0, 346, + 347, 0, 0, 348, 349, 350, 0, 0, 351, 352, + 0, 1572, 355, 1573, 0, 358, 359, 360, 361, 362, + 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, + 0, 370, 371, 0, 1574, 374, 375, 0, 377, 378, + 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, + 387, 388, 389, 390, 1575, 392, 393, 394, 395, 0, + 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, + 406, 407, 408, 0, 409, 410, 1576, 412, 413, 414, + 1577, 416, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 428, 0, 1578, 429, 430, 431, 432, + 433, 434, 1579, 436, 437, 0, 1580, 439, 440, 1581, + 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, + 451, 452, 453, 454, 455, 456, 1582, 458, 0, 0, + 0, 460, 461, 0, 462, 1583, 464, 465, 466, 467, + 468, 469, 0, 470, 1584, 1585, 0, 0, 473, 474, + 0, 476, 0, 0, 478, 479, 1586, 481, 482, 483, + 484, 485, 1587, 0, 486, 487, 488, 1588, 0, 489, + 490, 491, 492, 0, 493, 494, 495, 496, 497, 0, + 1589, 500, 0, 501, 1590, 503, 504, 505, 506, 507, + 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, + 514, 515, 516, 539, 0, 564, 0, 0, 0, 0, + 0, 0, 0, 0, 528, 529, 530, 531, 0, 0, + 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, + 129, 0, 130, 131, 132, 3, 4, 0, 0, 0, + 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, + 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, + 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, + 155, 156, 157, 158, 159, 0, 160, 161, 162, 163, + 164, 0, 0, 0, 166, 167, 168, 169, 170, 171, + 0, 173, 174, 175, 0, 176, 177, 178, 179, 180, + 181, 0, 0, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, @@ -10146,7 +10150,7 @@ static const yytype_int16 yytable[] = 0, 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, - 375, 376, 566, 378, 379, 0, 380, 381, 382, 383, + 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, @@ -10167,7 +10171,7 @@ static const yytype_int16 yytable[] = 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, + 565, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, @@ -10193,11 +10197,11 @@ static const yytype_int16 yytable[] = 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, - 345, 0, 346, 347, 0, 811, 348, 349, 350, 0, + 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, - 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, + 376, 566, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, @@ -10234,7 +10238,7 @@ static const yytype_int16 yytable[] = 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, - 256, 257, 923, 259, 0, 261, 262, 263, 264, 0, + 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, @@ -10268,7 +10272,7 @@ static const yytype_int16 yytable[] = 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 122, 123, 124, 125, 126, 127, 128, 129, 968, 130, + 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, @@ -10285,7 +10289,7 @@ static const yytype_int16 yytable[] = 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, + 257, 923, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, @@ -10295,7 +10299,7 @@ static const yytype_int16 yytable[] = 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, 0, - 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, + 346, 347, 0, 811, 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, @@ -10319,7 +10323,7 @@ static const yytype_int16 yytable[] = 523, 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, - 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, + 123, 124, 125, 126, 127, 128, 129, 968, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, @@ -10332,7 +10336,7 @@ static const yytype_int16 yytable[] = 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, - 225, 226, 227, 228, 229, 1207, 231, 232, 0, 233, + 225, 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, @@ -10346,7 +10350,7 @@ static const yytype_int16 yytable[] = 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, 0, 346, - 347, 0, 811, 348, 349, 350, 0, 0, 351, 352, + 347, 0, 0, 348, 349, 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, 378, @@ -10367,209 +10371,209 @@ static const yytype_int16 yytable[] = 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, - 524, 525, 526, 527, 528, 529, 530, 531, 1534, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 524, 525, 526, 527, 528, 529, 530, 531, 539, 0, + 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, - 0, 0, 0, 1535, 0, 0, 0, 0, 1536, 134, - 135, 0, 1537, 137, 138, 1538, 140, 141, 142, 0, - 1539, 1540, 1541, 1542, 0, 1543, 148, 149, 150, 151, - 152, 0, 0, 153, 154, 155, 156, 1544, 1545, 159, - 0, 160, 161, 162, 163, 0, 0, 1546, 0, 1547, - 167, 168, 169, 170, 171, 1548, 173, 174, 175, 0, - 176, 177, 178, 179, 180, 181, 0, 1549, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 1550, 194, - 195, 1551, 197, 0, 198, 0, 199, 200, 201, 202, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, + 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, + 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, + 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, + 0, 160, 161, 162, 163, 164, 0, 0, 0, 166, + 167, 168, 169, 170, 171, 0, 173, 174, 175, 0, + 176, 177, 178, 179, 180, 181, 0, 0, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, - 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 0, 221, 222, 223, 224, 0, - 226, 227, 228, 229, 230, 231, 0, 0, 233, 0, - 234, 235, 1552, 237, 0, 238, 0, 239, 1553, 0, - 1554, 242, 243, 0, 1555, 246, 247, 248, 0, 0, - 0, 251, 252, 0, 253, 254, 255, 256, 257, 258, - 259, 1556, 261, 262, 263, 264, 0, 265, 266, 267, - 268, 269, 270, 271, 0, 272, 1557, 0, 275, 276, - 277, 278, 279, 1558, 1559, 0, 1560, 0, 283, 1561, - 1562, 286, 1563, 288, 289, 290, 0, 291, 292, 293, - 0, 0, 294, 1564, 296, 1565, 0, 298, 299, 300, - 301, 302, 303, 304, 305, 1566, 307, 308, 309, 310, + 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, + 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, + 226, 227, 228, 229, 1207, 231, 232, 0, 233, 0, + 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, + 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, + 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, + 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, + 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, + 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, + 0, 286, 0, 288, 289, 290, 0, 291, 292, 293, + 0, 0, 294, 0, 296, 0, 0, 298, 299, 300, + 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 1567, 1568, - 1569, 332, 333, 334, 0, 0, 336, 337, 1570, 339, - 0, 0, 341, 1571, 343, 344, 345, 0, 346, 347, - 0, 0, 348, 349, 350, 0, 0, 351, 352, 0, - 1572, 355, 1573, 0, 358, 359, 360, 361, 362, 363, - 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, - 370, 371, 0, 1574, 374, 375, 0, 377, 378, 379, - 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, - 388, 389, 390, 1575, 392, 393, 394, 395, 0, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 1576, 412, 413, 414, 1577, - 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, - 426, 427, 428, 0, 1578, 429, 430, 431, 432, 433, - 434, 1579, 436, 437, 0, 1580, 439, 440, 1581, 442, - 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, - 452, 453, 454, 455, 456, 1582, 458, 0, 0, 0, - 460, 461, 0, 462, 1583, 464, 465, 466, 467, 468, - 469, 0, 470, 1584, 1585, 0, 0, 473, 474, 0, - 476, 0, 0, 478, 479, 1586, 481, 482, 483, 484, - 485, 1587, 0, 486, 487, 488, 1588, 0, 489, 490, - 491, 492, 0, 493, 494, 495, 496, 497, 0, 1589, - 500, 0, 501, 1590, 503, 504, 505, 506, 507, 508, - 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, - 515, 516, 539, 0, 564, 0, 0, 0, 0, 0, - 0, 0, 0, 528, 529, 530, 531, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, - 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, - 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, - 156, 157, 158, 159, 0, 160, 161, 162, 163, 164, - 0, 0, 0, 166, 167, 168, 169, 170, 171, 0, - 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, - 0, 0, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, - 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, - 0, 239, 0, 0, 0, 242, 243, 540, 0, 2042, - 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, - 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, - 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, - 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, - 0, 291, 292, 293, 0, 0, 294, 0, 296, 0, - 0, 298, 299, 2043, 301, 302, 303, 304, 305, 541, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, - 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, - 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, - 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, - 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, - 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, - 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, - 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, - 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, - 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, - 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, - 458, 459, 0, 0, 460, 461, 2044, 462, 0, 464, - 465, 2045, 467, 2046, 469, 0, 470, 471, 472, 0, - 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 485, 0, 0, 486, 487, 2047, - 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 1534, 0, 0, 0, 0, 0, 0, 0, 0, + 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, + 331, 332, 333, 334, 335, 0, 336, 337, 0, 339, + 0, 340, 341, 342, 343, 344, 345, 0, 346, 347, + 0, 811, 348, 349, 350, 0, 0, 351, 352, 353, + 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, + 370, 371, 372, 0, 374, 375, 376, 377, 378, 379, + 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, + 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, + 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, + 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, + 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, + 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, + 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, + 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, + 460, 461, 0, 462, 0, 464, 465, 466, 467, 468, + 469, 0, 470, 471, 472, 0, 0, 473, 474, 475, + 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, + 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, + 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, + 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, + 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, + 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, + 525, 526, 527, 528, 529, 530, 531, 1534, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, + 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, + 0, 0, 1535, 0, 0, 0, 0, 1536, 134, 135, + 0, 1537, 137, 138, 1538, 140, 141, 142, 0, 1539, + 1540, 1541, 1542, 0, 1543, 148, 149, 150, 151, 152, + 0, 0, 153, 154, 155, 156, 1544, 1545, 159, 0, + 160, 161, 162, 163, 0, 0, 1546, 0, 1547, 167, + 168, 169, 170, 171, 1548, 173, 174, 175, 0, 176, + 177, 178, 179, 180, 181, 0, 1549, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 1550, 194, 195, + 1551, 197, 0, 198, 0, 199, 200, 201, 202, 203, + 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, + 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 0, 221, 222, 223, 224, 0, 226, + 227, 228, 229, 230, 231, 0, 0, 233, 0, 234, + 235, 1552, 237, 0, 238, 0, 239, 1553, 0, 1554, + 242, 243, 0, 1555, 246, 247, 248, 0, 0, 0, + 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, + 1556, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 0, 272, 1557, 0, 275, 276, 277, + 278, 279, 1558, 1559, 0, 1560, 0, 283, 1561, 1562, + 286, 1563, 288, 289, 290, 0, 291, 292, 293, 0, + 0, 294, 1564, 296, 1565, 0, 298, 299, 300, 301, + 302, 303, 304, 305, 1566, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 1567, 1568, 1569, + 332, 333, 334, 0, 0, 336, 337, 1570, 339, 0, + 0, 341, 1571, 343, 344, 345, 0, 346, 347, 0, + 0, 348, 349, 350, 0, 0, 351, 352, 0, 1572, + 355, 1573, 0, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, + 371, 0, 1574, 374, 375, 0, 377, 378, 379, 0, + 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, + 389, 390, 1575, 392, 393, 394, 395, 0, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 0, 409, 410, 1576, 412, 413, 414, 1577, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 0, 1578, 429, 430, 431, 432, 433, 434, + 1579, 436, 437, 0, 1580, 439, 440, 1581, 442, 0, + 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, + 453, 454, 455, 456, 1582, 458, 0, 0, 0, 460, + 461, 0, 462, 1583, 464, 465, 466, 467, 468, 469, + 0, 470, 1584, 1585, 0, 0, 473, 474, 0, 476, + 0, 0, 478, 479, 1586, 481, 482, 483, 484, 485, + 1587, 0, 486, 487, 488, 1588, 0, 489, 490, 491, + 492, 0, 493, 494, 495, 496, 497, 0, 1589, 500, + 0, 501, 1590, 503, 504, 505, 506, 507, 508, 509, + 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, + 516, 539, 0, 564, 0, 0, 0, 0, 0, 0, + 0, 0, 528, 529, 530, 531, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, - 130, 131, 132, 0, 0, 0, 1535, 0, 0, 0, - 0, 1536, 134, 135, 0, 1537, 137, 138, 1538, 140, - 141, 142, 0, 1539, 1540, 1541, 1542, 0, 1543, 148, + 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, + 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, - 1544, 1545, 159, 0, 160, 161, 162, 163, 0, 0, - 1546, 0, 1547, 167, 168, 169, 170, 171, 1548, 173, + 157, 158, 159, 0, 160, 161, 162, 163, 164, 0, + 0, 0, 166, 167, 168, 169, 170, 171, 0, 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, - 1549, 183, 184, 185, 186, 187, 188, 189, 190, 191, - 192, 1550, 194, 195, 1551, 197, 0, 198, 0, 199, + 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, - 208, 0, 0, 209, 210, 1093, 212, 213, 0, 214, - 215, 216, 0, 2454, 218, 219, 220, 0, 221, 222, - 223, 224, 0, 226, 227, 228, 229, 230, 231, 0, - 0, 233, 0, 234, 235, 1552, 237, 0, 238, 0, - 239, 1553, 0, 1554, 242, 243, 0, 1555, 246, 247, - 248, 0, 0, 0, 251, 252, 0, 253, 254, 255, - 256, 257, 258, 259, 1556, 261, 262, 263, 264, 0, - 265, 266, 267, 268, 269, 270, 271, 0, 272, 1557, - 0, 275, 276, 277, 278, 279, 1558, 1559, 0, 1560, - 0, 283, 1561, 1562, 286, 1563, 288, 289, 290, 0, - 291, 292, 293, 0, 0, 294, 1564, 296, 1565, 0, - 298, 299, 300, 301, 302, 303, 304, 305, 1566, 307, + 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, + 239, 0, 0, 0, 242, 243, 540, 0, 2042, 247, + 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, + 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, + 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, + 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, + 291, 292, 293, 0, 0, 294, 0, 296, 0, 0, + 298, 299, 2043, 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, - 328, 1567, 1568, 1569, 332, 333, 334, 0, 0, 336, - 337, 1570, 339, 0, 0, 341, 1571, 343, 344, 345, + 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, + 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, 0, - 351, 352, 0, 1572, 355, 1573, 0, 358, 359, 360, + 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, - 0, 0, 0, 370, 371, 0, 1574, 374, 375, 0, + 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, - 0, 386, 387, 388, 389, 390, 1575, 392, 393, 394, + 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, - 404, 405, 406, 407, 408, 0, 409, 410, 1576, 412, - 413, 414, 1577, 416, 417, 418, 419, 420, 421, 422, - 423, 424, 425, 426, 427, 428, 0, 1578, 429, 430, - 431, 432, 433, 434, 1579, 436, 437, 0, 1580, 439, - 440, 1581, 442, 0, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, 456, 1582, 458, - 0, 0, 0, 460, 461, 0, 462, 1583, 464, 465, - 466, 467, 468, 469, 0, 470, 1584, 1585, 0, 0, - 473, 474, 0, 476, 0, 0, 478, 479, 1586, 481, - 482, 483, 484, 485, 1587, 0, 486, 487, 488, 1588, + 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, + 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, + 459, 0, 0, 460, 461, 2044, 462, 0, 464, 465, + 2045, 467, 2046, 469, 0, 470, 471, 472, 0, 0, + 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 485, 0, 0, 486, 487, 2047, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, - 497, 0, 1589, 500, 0, 501, 1590, 503, 504, 505, + 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, - 512, 513, 514, 515, 516, 539, 0, 564, 0, 0, - 0, 0, 0, 0, 0, 0, 528, 529, 530, 531, - 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, - 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, - 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, - 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, - 153, 154, 155, 156, 157, 158, 159, 0, 160, 161, - 162, 163, 164, 0, 0, 0, 166, 167, 168, 169, - 170, 171, 0, 173, 174, 175, 0, 176, 177, 178, - 179, 180, 181, 0, 0, 183, 184, 185, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, - 0, 205, 206, 207, 208, 0, 0, 209, 210, 211, - 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, - 220, 0, 221, 222, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, - 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, - 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, - 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, - 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, - 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, - 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, - 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, - 0, 296, 0, 0, 298, 299, 300, 301, 302, 303, - 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, - 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, - 334, 335, 0, 336, 337, 0, 339, 0, 340, 341, - 342, 343, 344, 345, 0, 346, 347, 0, 0, 348, - 349, 350, 0, 0, 351, 352, 353, 0, 355, 0, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, - 0, 374, 375, 376, 377, 378, 379, 0, 380, 381, - 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, - 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, - 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, - 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, - 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, - 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, - 462, 0, 464, 465, 466, 467, 468, 469, 0, 470, - 471, 472, 0, 0, 473, 474, 475, 476, 477, 0, - 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, - 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, - 493, 494, 495, 496, 497, 498, 499, 500, 0, 501, - 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, - 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, - 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, - 528, 529, 530, 531, 539, 0, 836, 0, 0, 0, + 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, + 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, + 1534, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, + 131, 132, 0, 0, 0, 1535, 0, 0, 0, 0, + 1536, 134, 135, 0, 1537, 137, 138, 1538, 140, 141, + 142, 0, 1539, 1540, 1541, 1542, 0, 1543, 148, 149, + 150, 151, 152, 0, 0, 153, 154, 155, 156, 1544, + 1545, 159, 0, 160, 161, 162, 163, 0, 0, 1546, + 0, 1547, 167, 168, 169, 170, 171, 1548, 173, 174, + 175, 0, 176, 177, 178, 179, 180, 181, 0, 1549, + 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, + 1550, 194, 195, 1551, 197, 0, 198, 0, 199, 200, + 201, 202, 203, 204, 0, 0, 205, 206, 207, 208, + 0, 0, 209, 210, 1093, 212, 213, 0, 214, 215, + 216, 0, 2455, 218, 219, 220, 0, 221, 222, 223, + 224, 0, 226, 227, 228, 229, 230, 231, 0, 0, + 233, 0, 234, 235, 1552, 237, 0, 238, 0, 239, + 1553, 0, 1554, 242, 243, 0, 1555, 246, 247, 248, + 0, 0, 0, 251, 252, 0, 253, 254, 255, 256, + 257, 258, 259, 1556, 261, 262, 263, 264, 0, 265, + 266, 267, 268, 269, 270, 271, 0, 272, 1557, 0, + 275, 276, 277, 278, 279, 1558, 1559, 0, 1560, 0, + 283, 1561, 1562, 286, 1563, 288, 289, 290, 0, 291, + 292, 293, 0, 0, 294, 1564, 296, 1565, 0, 298, + 299, 300, 301, 302, 303, 304, 305, 1566, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, + 1567, 1568, 1569, 332, 333, 334, 0, 0, 336, 337, + 1570, 339, 0, 0, 341, 1571, 343, 344, 345, 0, + 346, 347, 0, 0, 348, 349, 350, 0, 0, 351, + 352, 0, 1572, 355, 1573, 0, 358, 359, 360, 361, + 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, + 0, 0, 370, 371, 0, 1574, 374, 375, 0, 377, + 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, + 386, 387, 388, 389, 390, 1575, 392, 393, 394, 395, + 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 0, 409, 410, 1576, 412, 413, + 414, 1577, 416, 417, 418, 419, 420, 421, 422, 423, + 424, 425, 426, 427, 428, 0, 1578, 429, 430, 431, + 432, 433, 434, 1579, 436, 437, 0, 1580, 439, 440, + 1581, 442, 0, 443, 444, 445, 446, 447, 448, 449, + 450, 451, 452, 453, 454, 455, 456, 1582, 458, 0, + 0, 0, 460, 461, 0, 462, 1583, 464, 465, 466, + 467, 468, 469, 0, 470, 1584, 1585, 0, 0, 473, + 474, 0, 476, 0, 0, 478, 479, 1586, 481, 482, + 483, 484, 485, 1587, 0, 486, 487, 488, 1588, 0, + 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, + 0, 1589, 500, 0, 501, 1590, 503, 504, 505, 506, + 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, + 513, 514, 515, 516, 539, 0, 564, 0, 0, 0, + 0, 0, 0, 0, 0, 528, 529, 530, 531, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, @@ -10619,10 +10623,10 @@ static const yytype_int16 yytable[] = 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, - 529, 530, 531, 539, 0, 0, 0, 0, 0, 0, + 529, 530, 531, 539, 0, 836, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, - 129, 842, 130, 131, 132, 0, 0, 0, 0, 0, + 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, @@ -10637,13 +10641,13 @@ static const yytype_int16 yytable[] = 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, - 843, 247, 248, 0, 249, 250, 251, 252, 0, 253, + 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, 296, - 0, 0, 298, 299, 844, 301, 302, 303, 304, 305, + 0, 0, 298, 299, 300, 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, @@ -10658,22 +10662,22 @@ static const yytype_int16 yytable[] = 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, - 429, 430, 431, 432, 845, 434, 435, 436, 437, 0, + 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, - 464, 465, 466, 467, 468, 469, 0, 470, 846, 472, - 0, 0, 847, 474, 475, 476, 477, 0, 478, 479, + 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, + 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, - 495, 496, 497, 498, 499, 848, 0, 501, 0, 503, + 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, - 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, + 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, + 842, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, @@ -10687,14 +10691,14 @@ static const yytype_int16 yytable[] = 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, - 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, + 0, 239, 0, 0, 0, 242, 243, 540, 0, 843, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, 296, 0, - 0, 298, 299, 300, 301, 302, 303, 304, 305, 541, + 0, 298, 299, 844, 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, @@ -10705,19 +10709,19 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, - 881, 395, 0, 396, 397, 398, 399, 400, 401, 402, + 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, + 430, 431, 432, 845, 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, - 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, - 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, + 465, 466, 467, 468, 469, 0, 470, 846, 472, 0, + 0, 847, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, + 496, 497, 498, 499, 848, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, @@ -10740,7 +10744,7 @@ static const yytype_int16 yytable[] = 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, - 256, 257, 918, 259, 0, 261, 262, 263, 264, 0, + 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, @@ -10755,7 +10759,7 @@ static const yytype_int16 yytable[] = 361, 362, 363, 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, - 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 0, 386, 387, 388, 389, 390, 391, 392, 393, 881, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, @@ -10791,7 +10795,7 @@ static const yytype_int16 yytable[] = 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 921, 259, 0, 261, 262, 263, 264, 0, 265, + 257, 918, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, @@ -10842,7 +10846,7 @@ static const yytype_int16 yytable[] = 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, - 925, 259, 0, 261, 262, 263, 264, 0, 265, 266, + 921, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, @@ -10892,7 +10896,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, - 250, 251, 252, 0, 253, 254, 255, 256, 257, 956, + 250, 251, 252, 0, 253, 254, 255, 256, 257, 925, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, @@ -10943,7 +10947,7 @@ static const yytype_int16 yytable[] = 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, - 251, 252, 0, 253, 254, 255, 256, 257, 984, 259, + 251, 252, 0, 253, 254, 255, 256, 257, 956, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, @@ -10994,7 +10998,7 @@ static const yytype_int16 yytable[] = 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 987, 259, 0, + 252, 0, 253, 254, 255, 256, 257, 984, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, @@ -11026,11 +11030,11 @@ static const yytype_int16 yytable[] = 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 539, 0, 0, 0, 0, + 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, - 0, 0, 0, 1030, 0, 0, 134, 135, 0, 0, + 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, 161, @@ -11045,7 +11049,7 @@ static const yytype_int16 yytable[] = 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, - 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, + 0, 253, 254, 255, 256, 257, 987, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, @@ -11081,7 +11085,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, - 0, 0, 1057, 0, 0, 134, 135, 0, 0, 137, + 0, 0, 1030, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, @@ -11131,8 +11135,8 @@ static const yytype_int16 yytable[] = 529, 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, - 129, 842, 130, 131, 132, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, + 129, 0, 130, 131, 132, 0, 0, 0, 0, 0, + 0, 1057, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, 163, @@ -11171,18 +11175,18 @@ static const yytype_int16 yytable[] = 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, - 464, 465, 466, 467, 468, 469, 0, 470, 846, 472, - 0, 0, 847, 474, 475, 476, 477, 0, 478, 479, + 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, + 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, - 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, + 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, + 842, 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, @@ -11198,7 +11202,7 @@ static const yytype_int16 yytable[] = 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, - 255, 256, 257, 1355, 259, 0, 261, 262, 263, 264, + 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, @@ -11222,8 +11226,8 @@ static const yytype_int16 yytable[] = 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, - 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, - 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, + 465, 466, 467, 468, 469, 0, 470, 846, 472, 0, + 0, 847, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, @@ -11249,7 +11253,7 @@ static const yytype_int16 yytable[] = 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, - 256, 257, 1357, 259, 0, 261, 262, 263, 264, 0, + 256, 257, 1355, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, @@ -11300,7 +11304,7 @@ static const yytype_int16 yytable[] = 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 1360, 259, 0, 261, 262, 263, 264, 0, 265, + 257, 1357, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, @@ -11351,7 +11355,7 @@ static const yytype_int16 yytable[] = 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, - 1362, 259, 0, 261, 262, 263, 264, 0, 265, 266, + 1360, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, @@ -11401,7 +11405,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, - 250, 251, 252, 0, 253, 254, 255, 256, 257, 1364, + 250, 251, 252, 0, 253, 254, 255, 256, 257, 1362, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, @@ -11452,7 +11456,7 @@ static const yytype_int16 yytable[] = 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, - 251, 252, 0, 253, 254, 255, 256, 257, 2345, 259, + 251, 252, 0, 253, 254, 255, 256, 257, 1364, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, @@ -11503,7 +11507,7 @@ static const yytype_int16 yytable[] = 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 3185, 259, 0, + 252, 0, 253, 254, 255, 256, 257, 2345, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, @@ -11535,7 +11539,7 @@ static const yytype_int16 yytable[] = 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, - 527, 528, 529, 530, 531, 539, 0, 0, 0, 0, + 527, 528, 529, 530, 531, 539, 0, 564, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, 0, 0, @@ -11554,7 +11558,7 @@ static const yytype_int16 yytable[] = 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, - 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, + 0, 253, 254, 255, 256, 257, 3139, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, @@ -11604,13 +11608,13 @@ static const yytype_int16 yytable[] = 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, - 0, 858, 247, 248, 0, 249, 250, 251, 252, 0, + 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, - 296, 0, 0, 298, 299, 859, 301, 302, 303, 304, + 296, 0, 0, 298, 299, 300, 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, @@ -11624,16 +11628,16 @@ static const yytype_int16 yytable[] = 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, - 860, 421, 422, 423, 424, 425, 426, 427, 428, 0, - 0, 429, 430, 431, 432, 861, 434, 435, 436, 437, + 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, + 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, - 0, 464, 465, 466, 467, 468, 469, 0, 470, 862, + 0, 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 498, 499, 863, 0, 501, 0, + 494, 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, @@ -11655,13 +11659,13 @@ static const yytype_int16 yytable[] = 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, - 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, - 254, 255, 256, 257, 916, 259, 0, 261, 262, 263, + 858, 247, 248, 0, 249, 250, 251, 252, 0, 253, + 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, 296, - 0, 0, 298, 299, 300, 301, 302, 303, 304, 305, + 0, 0, 298, 299, 859, 301, 302, 303, 304, 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, 335, @@ -11674,17 +11678,17 @@ static const yytype_int16 yytable[] = 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, - 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 0, 412, 413, 414, 415, 416, 417, 418, 419, 860, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, - 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, + 429, 430, 431, 432, 861, 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, - 464, 465, 466, 467, 468, 469, 0, 470, 471, 472, + 464, 465, 466, 467, 468, 469, 0, 470, 862, 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, - 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, + 495, 496, 497, 498, 499, 863, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, 529, @@ -11707,7 +11711,7 @@ static const yytype_int16 yytable[] = 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, - 255, 256, 257, 980, 259, 0, 261, 262, 263, 264, + 255, 256, 257, 916, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, @@ -11758,7 +11762,7 @@ static const yytype_int16 yytable[] = 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, - 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, + 256, 257, 980, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, @@ -11776,13 +11780,13 @@ static const yytype_int16 yytable[] = 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, - 413, 414, 415, 416, 417, 418, 419, 860, 421, 422, + 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, 465, - 466, 467, 468, 469, 0, 470, 862, 472, 0, 0, + 466, 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, @@ -11809,7 +11813,7 @@ static const yytype_int16 yytable[] = 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, - 257, 1351, 259, 0, 261, 262, 263, 264, 0, 265, + 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, @@ -11827,13 +11831,13 @@ static const yytype_int16 yytable[] = 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, + 414, 415, 416, 417, 418, 419, 860, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, 465, 466, - 467, 468, 469, 0, 470, 471, 472, 0, 0, 473, + 467, 468, 469, 0, 470, 862, 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, 497, @@ -11860,7 +11864,7 @@ static const yytype_int16 yytable[] = 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, 253, 254, 255, 256, 257, - 1374, 259, 0, 261, 262, 263, 264, 0, 265, 266, + 1351, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, 291, 292, @@ -11895,7 +11899,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, - 0, 0, 0, 0, 0, 0, 1735, 0, 0, 134, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, @@ -11910,7 +11914,7 @@ static const yytype_int16 yytable[] = 226, 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, - 250, 251, 252, 0, 253, 254, 255, 256, 257, 258, + 250, 251, 252, 0, 253, 254, 255, 256, 257, 1374, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, @@ -11931,7 +11935,7 @@ static const yytype_int16 yytable[] = 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, 431, 432, 433, - 0, 435, 436, 437, 0, 0, 439, 440, 441, 442, + 434, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, 465, 466, 467, 468, @@ -11946,7 +11950,7 @@ static const yytype_int16 yytable[] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 134, 135, + 0, 0, 0, 0, 0, 1735, 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, 157, 158, 159, 0, @@ -11961,7 +11965,7 @@ static const yytype_int16 yytable[] = 227, 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, - 251, 252, 0, 253, 254, 255, 256, 257, 1937, 259, + 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, @@ -11981,7 +11985,7 @@ static const yytype_int16 yytable[] = 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 427, 428, 0, 0, 429, 430, 431, 432, 433, 434, + 427, 428, 0, 0, 429, 430, 431, 432, 433, 0, 435, 436, 437, 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, 459, 0, 0, 460, @@ -12012,7 +12016,7 @@ static const yytype_int16 yytable[] = 228, 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, - 252, 0, 253, 254, 255, 256, 257, 2327, 259, 0, + 252, 0, 253, 254, 255, 256, 257, 1937, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, @@ -12063,7 +12067,7 @@ static const yytype_int16 yytable[] = 229, 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, 248, 0, 249, 250, 251, 252, - 0, 253, 254, 255, 256, 257, 2347, 259, 0, 261, + 0, 253, 254, 255, 256, 257, 2327, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, 0, 283, 0, 0, 286, 0, @@ -12095,1690 +12099,1301 @@ static const yytype_int16 yytable[] = 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, - 528, 529, 530, 531, 3381, 0, 0, 0, 0, 0, + 528, 529, 530, 531, 539, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 122, 123, 124, 125, 126, 127, - 128, 129, 0, 130, 131, 132, 0, 0, 0, 3102, - 0, 0, 0, 0, 3103, 134, 135, 0, 3104, 137, - 138, 3105, 140, 141, 142, 0, 1539, 3106, 1541, 1542, - 0, 3107, 148, 149, 150, 151, 152, 0, 0, 153, - 154, 155, 156, 1544, 1545, 159, 0, 160, 161, 162, - 163, 0, 0, 3108, 0, 3109, 167, 168, 169, 170, - 171, 3110, 173, 174, 175, 0, 176, 177, 178, 179, - 180, 181, 0, 3111, 183, 184, 185, 186, 187, 188, - 189, 190, 191, 192, 1550, 194, 195, 1551, 197, 0, + 128, 129, 0, 130, 131, 132, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 134, 135, 0, 0, 137, + 138, 0, 140, 141, 142, 143, 144, 0, 146, 147, + 0, 0, 148, 149, 150, 151, 152, 0, 0, 153, + 154, 155, 156, 157, 158, 159, 0, 160, 161, 162, + 163, 164, 0, 0, 0, 166, 167, 168, 169, 170, + 171, 0, 173, 174, 175, 0, 176, 177, 178, 179, + 180, 181, 0, 0, 183, 184, 185, 186, 187, 188, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, 200, 201, 202, 203, 204, 0, 0, - 205, 206, 207, 208, 0, 0, 209, 210, 1093, 212, + 205, 206, 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, 215, 216, 0, 217, 218, 219, 220, - 0, 221, 222, 223, 224, 0, 226, 227, 228, 229, - 230, 231, 0, 0, 233, 0, 234, 235, 1552, 237, - 0, 238, 0, 239, 3112, 0, 3113, 242, 243, 2472, - 3114, 246, 247, 248, 0, 0, 0, 251, 252, 0, - 253, 254, 255, 256, 257, 258, 259, 3115, 261, 262, + 0, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 0, 233, 0, 234, 235, 236, 237, + 0, 238, 0, 239, 0, 0, 0, 242, 243, 540, + 0, 246, 247, 248, 0, 249, 250, 251, 252, 0, + 253, 254, 255, 256, 257, 2347, 259, 0, 261, 262, 263, 264, 0, 265, 266, 267, 268, 269, 270, 271, - 0, 272, 3116, 0, 275, 276, 277, 278, 279, 1558, - 1559, 0, 1560, 0, 283, 3117, 3118, 286, 3119, 288, - 289, 290, 0, 291, 292, 293, 0, 0, 294, 3120, - 296, 3121, 0, 298, 299, 300, 301, 302, 303, 304, - 305, 2481, 307, 308, 309, 310, 311, 312, 313, 314, + 0, 272, 0, 274, 275, 276, 277, 278, 279, 280, + 281, 0, 282, 0, 283, 0, 0, 286, 0, 288, + 289, 290, 0, 291, 292, 293, 0, 0, 294, 0, + 296, 0, 0, 298, 299, 300, 301, 302, 303, 304, + 305, 541, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, - 325, 326, 327, 328, 1567, 3123, 1569, 332, 333, 334, - 0, 0, 336, 337, 3125, 339, 0, 0, 341, 1571, + 325, 326, 327, 328, 329, 0, 331, 332, 333, 334, + 335, 0, 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, 0, 346, 347, 0, 0, 348, 349, - 350, 0, 0, 351, 352, 0, 3127, 355, 3128, 0, + 350, 0, 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 0, 0, 0, 0, 370, 371, 0, 3129, - 374, 375, 0, 377, 378, 379, 0, 380, 381, 382, - 383, 384, 385, 0, 386, 387, 388, 389, 390, 1575, + 368, 369, 0, 0, 0, 0, 370, 371, 372, 0, + 374, 375, 376, 377, 378, 379, 0, 380, 381, 382, + 383, 384, 385, 0, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 0, 409, - 410, 3130, 412, 413, 414, 0, 416, 417, 418, 419, + 410, 0, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 0, - 3131, 429, 430, 431, 432, 433, 434, 0, 436, 437, - 0, 3133, 439, 440, 1581, 442, 0, 443, 444, 445, + 0, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 0, 0, 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, - 456, 2489, 458, 0, 0, 0, 460, 461, 0, 462, - 3135, 464, 465, 466, 467, 468, 469, 0, 470, 1584, - 1585, 0, 0, 473, 474, 0, 476, 0, 0, 478, - 479, 3136, 481, 482, 483, 484, 485, 0, 0, 486, - 487, 488, 3138, 0, 489, 490, 491, 492, 0, 493, - 494, 495, 496, 497, 0, 1589, 500, 0, 501, 3139, + 456, 542, 458, 459, 0, 0, 460, 461, 0, 462, + 0, 464, 465, 466, 467, 468, 469, 0, 470, 471, + 472, 0, 0, 473, 474, 475, 476, 477, 0, 478, + 479, 480, 481, 482, 483, 484, 485, 0, 0, 486, + 487, 488, 0, 0, 489, 490, 491, 492, 0, 493, + 494, 495, 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, 506, 507, 508, 509, 0, 0, 510, - 0, 0, 511, 512, 513, 514, 515, 516, 1844, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 528, - 529, 530, 531, 0, 0, 0, 0, 0, 122, 123, - 124, 125, 126, 127, 128, 129, 0, 130, 131, 132, - 0, 0, 0, 1535, 0, 0, 0, 0, 1536, 134, - 135, 0, 1537, 137, 138, 1538, 140, 141, 142, 0, - 1539, 1540, 1541, 1542, 0, 1543, 148, 149, 150, 151, - 152, 0, 0, 153, 154, 155, 156, 1544, 1545, 159, - 0, 160, 161, 162, 163, 0, 0, 1546, 0, 1547, - 167, 168, 169, 170, 171, 1548, 173, 174, 175, 0, - 176, 177, 178, 179, 180, 181, 0, 1549, 183, 184, - 185, 186, 187, 188, 189, 190, 191, 192, 1550, 194, - 195, 1551, 197, 0, 198, 0, 199, 200, 201, 202, - 203, 204, 0, 0, 205, 206, 207, 208, 0, 0, - 209, 210, 1093, 212, 213, 0, 214, 215, 216, 0, - 217, 218, 219, 220, 0, 221, 222, 223, 224, 0, - 226, 227, 228, 229, 230, 231, 0, 0, 233, 0, - 234, 235, 1552, 237, 0, 238, 0, 239, 1553, 0, - 1554, 242, 243, 0, 1555, 246, 247, 248, 0, 0, - 0, 251, 252, 0, 253, 254, 255, 256, 257, 258, - 259, 1556, 261, 262, 263, 264, 0, 265, 266, 267, - 268, 269, 270, 271, 0, 272, 1557, 0, 275, 276, - 277, 278, 279, 1558, 1559, 0, 1560, 0, 283, 1561, - 1562, 286, 1563, 288, 289, 290, 0, 291, 292, 293, - 0, 0, 294, 1564, 296, 1565, 0, 298, 299, 300, - 301, 302, 303, 304, 305, 0, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - 321, 322, 323, 324, 325, 326, 327, 328, 1567, 1568, - 1569, 332, 333, 334, 0, 0, 336, 337, 1570, 339, - 0, 0, 341, 1571, 343, 344, 345, 0, 346, 347, - 0, 0, 348, 349, 350, 0, 0, 351, 352, 0, - 1572, 355, 1573, 0, 358, 359, 360, 361, 362, 363, - 364, 365, 366, 367, 368, 369, 0, 0, 0, 0, - 370, 371, 0, 1574, 374, 375, 0, 377, 378, 379, - 0, 380, 381, 382, 383, 384, 385, 0, 386, 387, - 388, 389, 390, 1575, 392, 393, 394, 395, 0, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 0, 409, 410, 1576, 412, 413, 414, 0, - 416, 417, 418, 419, 420, 421, 422, 423, 424, 425, - 426, 427, 428, 0, 1578, 429, 430, 431, 432, 433, - 434, 0, 436, 437, 0, 1580, 439, 440, 1581, 442, - 0, 443, 444, 445, 446, 447, 448, 449, 450, 451, - 452, 453, 454, 455, 456, 0, 458, 0, 0, 0, - 460, 461, 0, 462, 1583, 464, 465, 466, 467, 468, - 469, 0, 470, 1584, 1585, 0, 0, 473, 474, 0, - 476, 0, 0, 478, 479, 1586, 481, 482, 483, 484, - 485, 0, 0, 486, 487, 488, 1588, 0, 489, 490, - 491, 492, 0, 493, 494, 495, 496, 497, 0, 1589, - 500, 0, 501, 1590, 503, 504, 505, 506, 507, 508, - 509, 0, 0, 510, 0, 0, 511, 512, 513, 514, - 515, 516, 539, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 528, 529, 530, 531, 0, 0, 0, - 0, 0, 122, 123, 124, 125, 126, 127, 128, 129, - 0, 130, 131, 132, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 134, 135, 0, 0, 137, 138, 0, - 140, 141, 142, 143, 144, 0, 146, 147, 0, 0, - 148, 149, 150, 151, 152, 0, 0, 153, 154, 155, - 156, 157, 158, 159, 0, 160, 161, 162, 163, 164, - 0, 0, 0, 166, 167, 168, 169, 170, 171, 0, - 173, 174, 175, 0, 176, 177, 178, 179, 180, 181, - 0, 0, 183, 184, 185, 186, 187, 188, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 0, 198, 0, - 199, 200, 201, 202, 203, 204, 0, 0, 205, 206, - 207, 208, 0, 0, 209, 210, 211, 212, 213, 0, - 214, 215, 216, 0, 217, 218, 219, 220, 0, 221, - 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, - 232, 0, 233, 0, 234, 235, 236, 237, 0, 238, - 0, 239, 0, 0, 0, 242, 243, 540, 0, 246, - 247, 248, 0, 249, 250, 0, 252, 0, 253, 254, - 255, 256, 257, 258, 259, 0, 261, 262, 263, 264, - 0, 265, 266, 267, 268, 269, 270, 271, 0, 272, - 0, 274, 275, 276, 277, 278, 279, 280, 281, 0, - 282, 0, 283, 0, 0, 286, 0, 288, 289, 290, - 0, 291, 292, 293, 0, 0, 294, 0, 296, 0, - 0, 298, 299, 300, 301, 302, 303, 304, 305, 541, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 0, 331, 332, 333, 334, 335, 0, - 336, 337, 0, 339, 0, 340, 341, 342, 343, 344, - 345, 0, 346, 347, 0, 0, 348, 349, 350, 0, - 0, 351, 352, 353, 0, 355, 0, 357, 358, 359, - 360, 361, 362, 363, 0, 365, 366, 367, 368, 369, - 0, 0, 0, 0, 370, 371, 372, 0, 374, 375, - 376, 377, 378, 379, 0, 380, 381, 382, 383, 384, - 385, 0, 386, 387, 388, 0, 390, 391, 392, 393, - 394, 395, 0, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 0, 409, 410, 0, - 412, 413, 414, 415, 0, 417, 418, 419, 420, 421, - 422, 423, 424, 425, 426, 427, 428, 0, 0, 429, - 430, 431, 432, 433, 434, 435, 436, 437, 0, 0, - 439, 440, 441, 442, 0, 443, 444, 445, 446, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 542, - 458, 459, 0, 0, 460, 461, 0, 462, 0, 464, - 465, 466, 467, 468, 469, 0, 470, 471, 472, 0, - 0, 473, 474, 475, 476, 477, 0, 478, 479, 480, - 481, 482, 483, 484, 485, 0, 0, 486, 487, 488, - 0, 0, 489, 490, 491, 492, 0, 493, 494, 495, - 496, 497, 498, 499, 500, 0, 501, 0, 503, 504, - 505, 506, 507, 508, 509, 0, 0, 510, 0, 0, - 511, 512, 513, 514, 515, 516, 517, 518, 519, 520, - 521, 522, 523, 524, 525, 526, 527, 528, 529, 530, - 531, 1, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 764, 0, 3, 4, 0, 0, 0, 0, 1, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 764, - 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, - 7, 0, 0, 0, 0, 0, 0, 0, 0, 6, - 0, 0, 0, 0, 8, 0, 0, 0, 7, 0, - 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, - 0, 0, 8, 0, 0, 0, 0, 11, 0, 765, - 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, - 13, 0, 0, 0, 0, 11, 0, 765, 0, 0, - 0, 0, 0, 0, 0, 14, 15, 0, 13, 0, - 0, 0, 0, 0, 0, 0, 766, 0, 0, 0, - 0, 0, 18, 14, 15, 0, 0, 0, 0, 0, - 0, 19, 0, 0, 766, 0, 0, 0, 0, 0, - 18, 0, 0, 0, 0, 0, 0, 0, 22, 19, - 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, - 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 511, 512, 513, 514, 515, 516, 517, 518, + 519, 520, 521, 522, 523, 524, 525, 526, 527, 528, + 529, 530, 531, 3620, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 122, 123, 124, 125, 126, 127, 128, + 129, 0, 130, 131, 132, 0, 0, 0, 3473, 0, + 0, 0, 0, 3474, 134, 135, 0, 3475, 137, 138, + 3476, 140, 141, 142, 0, 1539, 3477, 1541, 1542, 0, + 3478, 148, 149, 150, 151, 152, 0, 0, 153, 154, + 155, 156, 1544, 1545, 159, 0, 160, 161, 162, 163, + 0, 0, 3479, 0, 3480, 167, 168, 169, 170, 171, + 3481, 173, 174, 175, 0, 176, 177, 178, 179, 180, + 181, 0, 3482, 183, 184, 185, 186, 187, 188, 189, + 190, 191, 192, 1550, 194, 195, 1551, 197, 0, 198, + 0, 199, 200, 201, 202, 203, 204, 0, 0, 205, + 206, 207, 208, 0, 0, 209, 210, 1093, 212, 213, + 0, 214, 215, 216, 0, 217, 218, 219, 220, 0, + 221, 222, 223, 224, 0, 226, 227, 228, 229, 230, + 231, 0, 0, 233, 0, 234, 235, 1552, 237, 0, + 238, 0, 239, 3483, 0, 3484, 242, 243, 2473, 3485, + 246, 247, 248, 0, 0, 0, 251, 252, 0, 253, + 254, 255, 256, 257, 258, 259, 3486, 261, 262, 263, + 264, 0, 265, 266, 267, 268, 269, 270, 271, 0, + 272, 3487, 0, 275, 276, 277, 278, 279, 1558, 1559, + 0, 1560, 0, 283, 3488, 3489, 286, 3490, 288, 289, + 290, 0, 291, 292, 293, 0, 0, 294, 3491, 296, + 3492, 0, 298, 299, 300, 301, 302, 303, 304, 305, + 2482, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, + 326, 327, 328, 1567, 3494, 1569, 332, 333, 334, 0, + 0, 336, 337, 3496, 339, 0, 0, 341, 1571, 343, + 344, 345, 0, 346, 347, 0, 0, 348, 349, 350, + 0, 0, 351, 352, 0, 3498, 355, 3499, 0, 358, + 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, + 369, 0, 0, 0, 0, 370, 371, 0, 3500, 374, + 375, 0, 377, 378, 379, 0, 380, 381, 382, 383, + 384, 385, 0, 386, 387, 388, 389, 390, 1575, 392, + 393, 394, 395, 0, 396, 397, 398, 399, 400, 401, + 402, 403, 404, 405, 406, 407, 408, 0, 409, 410, + 3501, 412, 413, 414, 0, 416, 417, 418, 419, 420, + 421, 422, 423, 424, 425, 426, 427, 428, 0, 3502, + 429, 430, 431, 432, 433, 434, 0, 436, 437, 0, + 3504, 439, 440, 1581, 442, 0, 443, 444, 445, 446, + 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, + 2490, 458, 0, 0, 0, 460, 461, 0, 462, 3506, + 464, 465, 466, 467, 468, 469, 0, 470, 1584, 1585, + 0, 0, 473, 474, 0, 476, 0, 0, 478, 479, + 3507, 481, 482, 483, 484, 485, 0, 0, 486, 487, + 488, 3509, 0, 489, 490, 491, 492, 0, 493, 494, + 495, 496, 497, 0, 1589, 500, 0, 501, 3510, 503, + 504, 505, 506, 507, 508, 509, 0, 0, 510, 0, + 0, 511, 512, 513, 514, 515, 516, 1844, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 528, 529, + 530, 531, 0, 0, 0, 0, 0, 122, 123, 124, + 125, 126, 127, 128, 129, 0, 130, 131, 132, 0, + 0, 0, 1535, 0, 0, 0, 0, 1536, 134, 135, + 0, 1537, 137, 138, 1538, 140, 141, 142, 0, 1539, + 1540, 1541, 1542, 0, 1543, 148, 149, 150, 151, 152, + 0, 0, 153, 154, 155, 156, 1544, 1545, 159, 0, + 160, 161, 162, 163, 0, 0, 1546, 0, 1547, 167, + 168, 169, 170, 171, 1548, 173, 174, 175, 0, 176, + 177, 178, 179, 180, 181, 0, 1549, 183, 184, 185, + 186, 187, 188, 189, 190, 191, 192, 1550, 194, 195, + 1551, 197, 0, 198, 0, 199, 200, 201, 202, 203, + 204, 0, 0, 205, 206, 207, 208, 0, 0, 209, + 210, 1093, 212, 213, 0, 214, 215, 216, 0, 217, + 218, 219, 220, 0, 221, 222, 223, 224, 0, 226, + 227, 228, 229, 230, 231, 0, 0, 233, 0, 234, + 235, 1552, 237, 0, 238, 0, 239, 1553, 0, 1554, + 242, 243, 0, 1555, 246, 247, 248, 0, 0, 0, + 251, 252, 0, 253, 254, 255, 256, 257, 258, 259, + 1556, 261, 262, 263, 264, 0, 265, 266, 267, 268, + 269, 270, 271, 0, 272, 1557, 0, 275, 276, 277, + 278, 279, 1558, 1559, 0, 1560, 0, 283, 1561, 1562, + 286, 1563, 288, 289, 290, 0, 291, 292, 293, 0, + 0, 294, 1564, 296, 1565, 0, 298, 299, 300, 301, + 302, 303, 304, 305, 0, 307, 308, 309, 310, 311, + 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, + 322, 323, 324, 325, 326, 327, 328, 1567, 1568, 1569, + 332, 333, 334, 0, 0, 336, 337, 1570, 339, 0, + 0, 341, 1571, 343, 344, 345, 0, 346, 347, 0, + 0, 348, 349, 350, 0, 0, 351, 352, 0, 1572, + 355, 1573, 0, 358, 359, 360, 361, 362, 363, 364, + 365, 366, 367, 368, 369, 0, 0, 0, 0, 370, + 371, 0, 1574, 374, 375, 0, 377, 378, 379, 0, + 380, 381, 382, 383, 384, 385, 0, 386, 387, 388, + 389, 390, 1575, 392, 393, 394, 395, 0, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, + 408, 0, 409, 410, 1576, 412, 413, 414, 0, 416, + 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 0, 1578, 429, 430, 431, 432, 433, 434, + 0, 436, 437, 0, 1580, 439, 440, 1581, 442, 0, + 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, + 453, 454, 455, 456, 0, 458, 0, 0, 0, 460, + 461, 0, 462, 1583, 464, 465, 466, 467, 468, 469, + 0, 470, 1584, 1585, 0, 0, 473, 474, 0, 476, + 0, 0, 478, 479, 1586, 481, 482, 483, 484, 485, + 0, 0, 486, 487, 488, 1588, 0, 489, 490, 491, + 492, 0, 493, 494, 495, 496, 497, 0, 1589, 500, + 0, 501, 1590, 503, 504, 505, 506, 507, 508, 509, + 0, 0, 510, 0, 0, 511, 512, 513, 514, 515, + 516, 539, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 528, 529, 530, 531, 0, 0, 0, 0, + 0, 122, 123, 124, 125, 126, 127, 128, 129, 0, + 130, 131, 132, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 134, 135, 0, 0, 137, 138, 0, 140, + 141, 142, 143, 144, 0, 146, 147, 0, 0, 148, + 149, 150, 151, 152, 0, 0, 153, 154, 155, 156, + 157, 158, 159, 0, 160, 161, 162, 163, 164, 0, + 0, 0, 166, 167, 168, 169, 170, 171, 0, 173, + 174, 175, 0, 176, 177, 178, 179, 180, 181, 0, + 0, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 0, 198, 0, 199, + 200, 201, 202, 203, 204, 0, 0, 205, 206, 207, + 208, 0, 0, 209, 210, 211, 212, 213, 0, 214, + 215, 216, 0, 217, 218, 219, 220, 0, 221, 222, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, + 0, 233, 0, 234, 235, 236, 237, 0, 238, 0, + 239, 0, 0, 0, 242, 243, 540, 0, 246, 247, + 248, 0, 249, 250, 0, 252, 0, 253, 254, 255, + 256, 257, 258, 259, 0, 261, 262, 263, 264, 0, + 265, 266, 267, 268, 269, 270, 271, 0, 272, 0, + 274, 275, 276, 277, 278, 279, 280, 281, 0, 282, + 0, 283, 0, 0, 286, 0, 288, 289, 290, 0, + 291, 292, 293, 0, 0, 294, 0, 296, 0, 0, + 298, 299, 300, 301, 302, 303, 304, 305, 541, 307, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 0, 331, 332, 333, 334, 335, 0, 336, + 337, 0, 339, 0, 340, 341, 342, 343, 344, 345, + 0, 346, 347, 0, 0, 348, 349, 350, 0, 0, + 351, 352, 353, 0, 355, 0, 357, 358, 359, 360, + 361, 362, 363, 0, 365, 366, 367, 368, 369, 0, + 0, 0, 0, 370, 371, 372, 0, 374, 375, 376, + 377, 378, 379, 0, 380, 381, 382, 383, 384, 385, + 0, 386, 387, 388, 0, 390, 391, 392, 393, 394, + 395, 0, 396, 397, 398, 399, 400, 401, 402, 403, + 404, 405, 406, 407, 408, 0, 409, 410, 0, 412, + 413, 414, 415, 0, 417, 418, 419, 420, 421, 422, + 423, 424, 425, 426, 427, 428, 0, 0, 429, 430, + 431, 432, 433, 434, 435, 436, 437, 0, 0, 439, + 440, 441, 442, 0, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, 456, 542, 458, + 459, 0, 0, 460, 461, 0, 462, 0, 464, 465, + 466, 467, 468, 469, 0, 470, 471, 472, 0, 0, + 473, 474, 475, 476, 477, 0, 478, 479, 480, 481, + 482, 483, 484, 485, 0, 0, 486, 487, 488, 0, + 0, 489, 490, 491, 492, 0, 493, 494, 495, 496, + 497, 498, 499, 500, 0, 501, 0, 503, 504, 505, + 506, 507, 508, 509, 0, 0, 510, 0, 0, 511, + 512, 513, 514, 515, 516, 517, 518, 519, 520, 521, + 522, 523, 524, 525, 526, 527, 528, 529, 530, 531, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 764, 0, 3, 4, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 764, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 7, + 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 0, 8, 0, 0, 0, 7, 0, 0, + 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, + 0, 8, 0, 0, 0, 0, 11, 0, 765, 0, + 0, 0, 10, 0, 0, 0, 0, 0, 0, 13, + 0, 0, 0, 0, 11, 0, 765, 0, 0, 0, + 0, 0, 0, 0, 14, 15, 0, 13, 0, 0, + 0, 0, 0, 0, 0, 766, 0, 0, 0, 0, + 0, 18, 14, 15, 0, 0, 0, 0, 0, 0, + 19, 0, 0, 766, 0, 0, 0, 0, 0, 18, + 0, 0, 0, 0, 0, 0, 0, 22, 19, 0, + 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 22, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, -1524, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, -1524, 0, 0, 0, 0, 0, 0, 0, - 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 25, + 0, 0, 0, -1530, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, -1530, 0, 0, 0, 0, 0, 0, 0, 0, + 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, - 27, 28, 0, 0, 0, 0, 0, 29, 0, 0, - 30, 0, 0, 0, 0, 0, 0, 26, 27, 28, - 0, 0, 0, 0, 0, 29, 0, 0, 30, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, + 28, 0, 0, 0, 0, 0, 29, 0, 0, 30, + 0, 0, 0, 0, 0, 0, 26, 27, 28, 0, + 0, 0, 0, 0, 29, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 31, 0, 0, 0, 0, 0, 0, 0, 0, - 32, 0, 0, 0, 0, 0, 0, 0, 0, 31, - 0, 0, 0, 0, 0, 0, 33, 0, 32, 0, - 0, 0, 0, 34, 0, 0, 0, 35, 0, 0, - 0, 0, 0, 0, 33, 0, 0, 0, 0, 36, - 0, 34, 0, 0, 0, 35, 0, 0, 0, 0, - 0, 37, 0, 0, 0, 38, 0, 36, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, - 0, 0, 0, 38, 0, 0, 39, 0, 0, 0, + 31, 0, 0, 0, 0, 0, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 31, 0, + 0, 0, 0, 0, 0, 33, 0, 32, 0, 0, + 0, 0, 34, 0, 0, 0, 35, 0, 0, 0, + 0, 0, 0, 33, 0, 0, 0, 0, 36, 0, + 34, 0, 0, 0, 35, 0, 0, 0, 0, 0, + 37, 0, 0, 0, 38, 0, 36, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, + 0, 0, 38, 0, 0, 39, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, + 0, 0, 0, 39, 0, 42, 0, 0, 0, 0, + 43, 0, 0, 0, 0, 767, 0, 40, 0, 0, + 0, 0, 0, 42, 0, 0, 0, 44, 43, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 40, 0, 0, 0, 39, 0, 42, 0, 0, 0, - 0, 43, 0, 0, 0, 0, 767, 0, 40, 0, - 0, 0, 0, 0, 42, 0, 0, 0, 44, 43, + 0, 0, 0, 0, 0, 44, 0, 0, 0, 0, + 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 768, 0, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 44, 0, 0, 0, - 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 768, 0, 0, 0, - 45, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 46 + 0, 0, 0, 46 }; static const yytype_int16 yycheck[] = { - 7, 532, 0, 0, 0, 46, 880, 0, 856, 16, - 0, 0, 922, 904, 1019, 0, 23, 0, 934, 0, - 1268, 830, 20, 0, 0, 1759, 759, 1270, 1000, 38, - 1065, 985, 955, 7, 16, 20, 950, 1010, 989, 1197, - 1720, 37, 75, 1490, 1474, 1256, 1962, 79, 1636, 23, - 20, 79, 1010, 1609, 1877, 1010, 1114, 7, 1017, 13, - 2343, 1527, 1248, 1649, 1885, 19, 760, 1594, 1692, 1010, - 77, 78, 1328, 23, 1245, 1677, 30, 2267, 2277, 2833, - 1813, 17, 2082, 1233, 0, 23, 2246, 0, 2248, 0, - 44, 45, 1673, 1674, 2830, 2789, 45, 2212, 2789, 1828, - 0, 2266, 1273, 77, 78, 114, 0, 103, 2850, 0, - 34, 1377, 1028, 2334, 0, 767, 1162, 0, 1123, 2857, - 2417, 1167, 2653, 825, 2497, 1724, 0, 77, 78, 831, - 0, 1899, 0, 768, 1008, 0, 0, 1866, 0, 77, - 78, 1898, 0, 1902, 2055, 2056, 0, 2740, 1872, 0, - 23, 2744, 2045, 2046, 2047, 2066, 1087, 1088, 112, 2070, - 0, 9, 9, 2969, 922, 0, 924, 2430, 926, 41, - 0, 0, 5, 1692, 1105, 0, 0, 0, 2017, 5, - 56, 3, 0, 5, 5, 0, 5, 64, 10, 60, - 4, 81, 13, 14, 5, 9, 10, 2425, 9, 5, - 5, 1173, 1011, 5, 77, 78, 5, 13, 14, 5, - 5, 13, 14, 2430, 0, 19, 2437, 1819, 13, 14, - 3197, 5, 13, 14, 2392, 1777, 5, 19, 83, 1779, - 5, 5, 5, 5, 13, 14, 9, 5, 793, 5, - 2423, 31, 5, 5, 83, 2832, 125, 118, 1122, 39, - 19, 27, 13, 14, 109, 94, 4, 1292, 3, 4, - 5, 9, 140, 1179, 9, 11, 928, 175, 1303, 46, - 16, 11, 193, 83, 201, 46, 16, 120, 174, 899, - 77, 78, 19, 149, 94, 1257, 101, 3076, 1260, 1261, - 91, 822, 174, 1207, 4, 3, 31, 3148, 174, 9, - 899, 47, 2523, 2524, 39, 2526, 60, 295, 1091, 64, - 1012, 180, 229, 1034, 108, 101, 183, 2597, 1039, 3178, - 1041, 176, 1024, 1925, 31, 1108, 3029, 35, 36, 130, - 296, 1489, 39, 301, 875, 81, 3181, 296, 869, 1060, - 293, 5, 820, 374, 11, 195, 319, 3384, 15, 16, - 205, 1003, 388, 301, 220, 186, 3201, 41, 1232, 5, - 3560, 278, 138, 281, 123, 1000, 65, 108, 1579, 1527, - 316, 107, 2699, 118, 2701, 244, 75, 1979, 108, 168, - 1228, 1229, 133, 41, 31, 3309, 118, 3311, 351, 1991, - 121, 2757, 120, 42, 249, 195, 84, 118, 3529, 123, - 164, 31, 375, 284, 75, 490, 121, 3639, 1102, 11, - 134, 492, 2235, 15, 16, 2575, 166, 439, 3481, 2021, - 3483, 426, 146, 11, 467, 417, 2028, 390, 3593, 514, - 347, 150, 11, 514, 809, 301, 15, 16, 3192, 13, - 14, 3132, 1333, 295, 253, 47, 123, 3741, 4, 1363, - 123, 11, 827, 9, 3208, 15, 16, 479, 3194, 47, - 406, 466, 150, 11, 427, 173, 197, 175, 47, 1392, - 2072, 280, 193, 2756, 2076, 166, 221, 241, 127, 81, - 295, 398, 197, 202, 234, 528, 133, 133, 64, 366, - 482, 215, 3692, 81, 178, 3626, 532, 528, 3629, 244, - 171, 3564, 81, 133, 2106, 3737, 3800, 1466, 1467, 295, - 379, 2877, 313, 1472, 364, 346, 162, 480, 3442, 255, - 178, 402, 27, 299, 379, 2640, 3691, 1585, 33, 2728, - 266, 3382, 2753, 81, 2755, 390, 495, 278, 215, 290, - 528, 330, 215, 76, 375, 244, 464, 464, 174, 3408, - 523, 3528, 367, 285, 550, 3344, 2083, 285, 440, 280, - 1038, 361, 528, 432, 532, 434, 4, 3004, 3413, 3006, - 109, 9, 427, 2159, 3363, 528, 2397, 2398, 2399, 256, - 2907, 367, 528, 479, 532, 379, 277, 363, 467, 365, - 456, 460, 414, 415, 2218, 169, 451, 64, 605, 1130, - 467, 440, 473, 2866, 3735, 532, 1480, 528, 486, 2075, - 1230, 366, 566, 1544, 1545, 405, 2844, 3204, 1280, 395, - 528, 285, 3325, 605, 2212, 480, 469, 3330, 1884, 3666, - 440, 1230, 433, 138, 280, 1190, 526, 2805, 1569, 285, - 530, 395, 25, 1376, 290, 2925, 1494, 424, 1381, 2866, - 3627, 477, 528, 424, 1387, 532, 2839, 528, 530, 3465, - 3402, 109, 1203, 2884, 335, 1206, 2434, 2391, 1516, 2250, - 405, 2270, 519, 520, 2431, 490, 1919, 531, 2678, 527, - 2439, 1947, 2593, 2576, 2577, 2578, 2579, 1722, 2276, 1383, - 3384, 531, 532, 3384, 2533, 528, 492, 427, 405, 2218, - 1631, 1632, 528, 536, 490, 464, 528, 528, 492, 528, - 528, 533, 534, 531, 529, 536, 531, 528, 514, 533, - 534, 526, 528, 528, 3097, 530, 528, 768, 532, 528, - 514, 2283, 528, 528, 2284, 527, 119, 528, 1612, 1613, - 464, 1393, 3335, 529, 528, 531, 3277, 3340, 1622, 528, - 1666, 1667, 1668, 528, 528, 528, 528, 3054, 527, 1394, - 528, 768, 528, 1637, 3047, 528, 528, 528, 1551, 767, - 478, 519, 520, 3527, 519, 520, 175, 532, 524, 820, - 490, 1502, 767, 3628, 524, 1487, 457, 464, 1571, 526, - 366, 464, 3534, 530, 299, 1669, 3233, 3535, 768, 1987, - 27, 447, 809, 1524, 514, 2716, 33, 761, 467, 519, - 520, 278, 458, 820, 440, 151, 280, 109, 827, 8, - 827, 285, 11, 1606, 2080, 528, 15, 16, 271, 442, - 2018, 20, 21, 22, 517, 809, 397, 254, 365, 2441, - 872, 407, 492, 432, 872, 434, 820, 530, 34, 856, - 857, 3586, 3587, 827, 521, 522, 523, 524, 363, 809, - 123, 229, 3027, 280, 514, 431, 875, 203, 395, 528, - 820, 904, 2030, 880, 60, 138, 1848, 827, 528, 2700, - 493, 345, 820, 3637, 327, 894, 1858, 3623, 0, 1861, - 395, 517, 890, 890, 890, 2497, 109, 890, 2898, 366, - 890, 890, 194, 936, 530, 890, 3641, 890, 878, 890, - 278, 138, 517, 890, 890, 314, 205, 2075, 3033, 521, - 522, 523, 524, 528, 523, 932, 933, 881, 395, 936, - 937, 530, 881, 1843, 858, 859, 809, 861, 83, 863, - 519, 520, 521, 522, 523, 524, 133, 820, 3684, 94, - 164, 432, 427, 434, 827, 169, 1689, 38, 3179, 519, - 520, 521, 522, 523, 524, 470, 4, 528, 2415, 83, - 2236, 9, 3666, 2597, 890, 3666, 531, 890, 1929, 890, - 94, 532, 989, 2983, 1907, 2808, 2809, 1878, 1879, 1880, - 890, 1945, 205, 1000, 2040, 1949, 890, 1038, 1952, 890, - 1007, 1008, 401, 1954, 890, 1003, 1013, 890, 300, 1016, - 1017, 2613, 1019, 1020, 1021, 1022, 890, 3771, 1003, 955, - 890, 2754, 890, 820, 478, 890, 890, 241, 890, 1036, - 398, 1038, 890, 1992, 1993, 1994, 1995, 1996, 1997, 890, - 1047, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, - 2009, 2780, 2640, 1811, 216, 890, 105, 1064, 1065, 1066, - 890, 890, 1036, 3346, 1038, 890, 890, 890, 361, 41, - 2799, 334, 299, 1047, 2340, 3752, 75, 164, 292, 1086, - 72, 73, 1123, 3760, 2665, 1843, 1036, 164, 1038, 61, - 379, 526, 169, 280, 175, 530, 464, 1047, 1036, 1106, - 1038, 390, 2252, 290, 2254, 1863, 3081, 280, 297, 1047, - 1868, 1118, 1119, 1120, 3089, 1122, 1123, 27, 1125, 118, - 5, 1854, 351, 33, 1655, 2555, 1859, 2574, 2371, 174, - 211, 3321, 359, 54, 183, 107, 363, 492, 427, 176, - 1613, 13, 14, 1125, 120, 248, 227, 2403, 2306, 1622, - 27, 1158, 2026, 523, 241, 529, 33, 238, 532, 514, - 530, 390, 528, 1036, 241, 1038, 379, 180, 395, 1176, - 1177, 1970, 2995, 528, 1047, 1974, 38, 390, 1977, 1211, - 1212, 526, 1214, 1211, 1212, 530, 1214, 2789, 347, 133, - 1043, 480, 205, 528, 1203, 526, 1049, 1206, 427, 530, - 109, 2789, 264, 265, 529, 292, 1213, 532, 2379, 31, - 1217, 1218, 249, 316, 427, 292, 13, 14, 162, 3502, - 1227, 1228, 1229, 529, 180, 1232, 532, 3227, 138, 278, - 2832, 244, 204, 209, 2193, 2194, 526, 2242, 528, 1036, - 530, 1038, 1196, 470, 2118, 1479, 361, 1481, 1482, 1256, - 1047, 480, 858, 859, 205, 861, 529, 863, 179, 532, - 3176, 138, 2448, 1272, 86, 1048, 386, 480, 529, 1052, - 257, 532, 2458, 95, 445, 196, 321, 322, 323, 529, - 201, 280, 532, 255, 386, 1292, 285, 300, 244, 370, - 843, 844, 845, 427, 266, 848, 1303, 119, 526, 480, - 528, 2925, 278, 406, 280, 383, 278, 529, 389, 529, - 532, 386, 532, 175, 351, 3048, 490, 529, 492, 240, - 532, 1328, 384, 385, 2198, 6, 515, 516, 517, 10, - 519, 520, 521, 522, 523, 524, 335, 18, 310, 529, - 528, 285, 532, 388, 529, 529, 290, 532, 532, 211, - 3171, 32, 528, 390, 353, 36, 2247, 460, 169, 529, - 529, 1368, 532, 532, 528, 227, 379, 1350, 528, 1350, - 1377, 193, 528, 1350, 1350, 2961, 238, 529, 176, 2826, - 532, 432, 427, 434, 206, 528, 1368, 1394, 437, 299, - 427, 528, 2346, 365, 2348, 1393, 529, 529, 529, 532, - 532, 532, 529, 529, 1411, 532, 532, 2934, 1393, 1416, - 2937, 5, 2939, 529, 451, 174, 532, 462, 390, 432, - 803, 434, 299, 529, 1394, 528, 532, 528, 473, 1411, - 1384, 529, 1386, 529, 532, 2901, 532, 2595, 432, 411, - 434, 2599, 528, 480, 457, 3033, 149, 460, 2349, 359, - 2351, 249, 835, 363, 2753, 528, 2755, 3013, 457, 1466, - 1467, 164, 896, 2311, 898, 1472, 169, 1474, 467, 528, - 2164, 521, 1479, 1480, 1481, 1482, 432, 860, 434, 400, - 3763, 529, 359, 528, 532, 395, 363, 1494, 1495, 529, - 529, 19, 532, 532, 514, 3097, 528, 1504, 529, 1506, - 1474, 532, 1509, 447, 460, 13, 14, 1514, 370, 1516, - 1517, 511, 1519, 226, 458, 2429, 1523, 220, 395, 529, - 13, 14, 532, 2771, 1474, 529, 909, 389, 532, 2772, - 1504, 295, 1506, 127, 128, 1509, 3696, 530, 241, 3738, - 1514, 3740, 511, 1517, 529, 1519, 532, 532, 173, 1523, - 248, 3711, 529, 351, 1504, 532, 1506, 529, 529, 1509, - 470, 532, 529, 528, 1514, 532, 1504, 1517, 1506, 1519, - 529, 1509, 1579, 1523, 529, 2823, 1514, 532, 174, 1517, - 174, 1519, 13, 14, 2770, 1523, 2772, 2645, 2646, 292, - 529, 413, 390, 470, 416, 529, 3198, 60, 301, 300, - 3799, 1474, 3204, 222, 529, 1612, 1613, 532, 3524, 13, - 14, 1609, 1609, 1609, 1621, 1622, 1609, 1000, 316, 1609, - 1609, 13, 14, 1630, 1609, 3785, 528, 1010, 428, 427, - 1637, 1504, 529, 1506, 174, 532, 1509, 1644, 3798, 529, - 511, 1514, 532, 226, 1517, 154, 1519, 2620, 2653, 0, - 1523, 3474, 3475, 451, 13, 14, 154, 1664, 1665, 13, - 14, 109, 1669, 2621, 2622, 1672, 2621, 2622, 2623, 3271, + 7, 922, 532, 856, 904, 46, 0, 0, 0, 16, + 0, 1019, 950, 0, 0, 830, 23, 880, 0, 0, + 0, 16, 759, 0, 0, 1270, 38, 1474, 1256, 1197, + 1065, 985, 934, 1268, 7, 955, 25, 1720, 1010, 20, + 20, 1490, 1010, 989, 2246, 37, 2248, 2277, 20, 1636, + 23, 1010, 1114, 1527, 1010, 79, 1962, 1759, 1609, 1017, + 79, 1649, 760, 1594, 1692, 1885, 1245, 7, 2082, 1877, + 77, 78, 1328, 75, 1813, 1000, 1233, 2267, 1248, 1673, + 1674, 17, 0, 23, 922, 1162, 924, 0, 926, 1000, + 1167, 0, 2832, 2266, 1273, 1677, 0, 2418, 1377, 2343, + 0, 2212, 114, 45, 77, 78, 0, 2859, 23, 0, + 825, 103, 2334, 768, 1828, 1123, 831, 0, 2835, 767, + 2498, 2055, 2056, 2654, 1724, 2741, 1028, 0, 0, 2745, + 119, 1902, 2066, 1898, 0, 34, 2070, 77, 78, 1087, + 1088, 1872, 2017, 0, 1899, 1008, 1777, 9, 0, 1692, + 0, 0, 1866, 41, 56, 3151, 64, 1105, 2045, 2046, + 2047, 1779, 77, 78, 60, 0, 64, 0, 9, 81, + 0, 5, 0, 5, 0, 19, 5, 9, 0, 0, + 0, 0, 0, 0, 175, 0, 2431, 2971, 13, 14, + 2431, 5, 3, 2426, 5, 5, 1011, 5, 2424, 10, + 75, 5, 5, 13, 14, 13, 14, 5, 2393, 13, + 14, 5, 4, 77, 78, 5, 2438, 9, 10, 13, + 14, 3135, 118, 13, 14, 5, 123, 174, 5, 9, + 5, 1142, 5, 5, 5, 5, 19, 1819, 19, 5, + 5, 3155, 31, 793, 201, 5, 127, 128, 1173, 125, + 39, 46, 13, 14, 928, 2598, 23, 1292, 11, 1122, + 46, 19, 1173, 16, 3, 4, 5, 123, 1303, 1207, + 9, 875, 174, 4, 3335, 5, 193, 1179, 9, 205, + 31, 120, 101, 101, 4, 11, 64, 3031, 39, 9, + 16, 301, 822, 174, 47, 3370, 171, 1012, 295, 3335, + 140, 3132, 2524, 2525, 109, 2527, 3078, 2834, 293, 1024, + 77, 78, 296, 1091, 123, 3, 123, 316, 215, 120, + 820, 1489, 11, 183, 3353, 134, 15, 16, 81, 11, + 1108, 138, 1257, 15, 16, 1260, 1261, 146, 301, 869, + 133, 168, 3530, 1925, 118, 1000, 1257, 35, 36, 1260, + 1261, 1579, 195, 195, 31, 1003, 3646, 319, 47, 1527, + 388, 374, 39, 175, 91, 296, 11, 123, 5, 1232, + 15, 16, 42, 3564, 2576, 1228, 1229, 105, 65, 118, + 11, 166, 11, 83, 15, 16, 108, 186, 75, 194, + 295, 281, 81, 1034, 94, 108, 2758, 1979, 1039, 11, + 1041, 60, 47, 130, 1102, 121, 215, 406, 3148, 1991, + 31, 118, 166, 375, 164, 3757, 1987, 84, 47, 1060, + 83, 899, 41, 284, 3006, 1363, 3008, 2235, 174, 3146, + 3435, 94, 3437, 1333, 72, 73, 81, 490, 439, 2021, + 321, 322, 323, 3631, 899, 3162, 2028, 2018, 3636, 365, + 3364, 3597, 81, 379, 3263, 183, 3265, 127, 366, 215, + 335, 514, 517, 3753, 390, 86, 4, 3503, 366, 81, + 109, 9, 1392, 528, 95, 3817, 295, 295, 479, 395, + 234, 197, 221, 150, 285, 173, 193, 175, 1399, 1400, + 2072, 241, 277, 440, 2076, 300, 133, 290, 119, 2729, + 256, 427, 314, 330, 532, 244, 3535, 388, 1466, 1467, + 174, 285, 3703, 2757, 1472, 528, 0, 2879, 399, 361, + 108, 364, 532, 1585, 2106, 162, 3298, 334, 3359, 528, + 2641, 528, 2754, 3529, 2756, 3279, 20, 528, 1038, 23, + 3284, 402, 423, 528, 528, 3317, 427, 346, 367, 367, + 278, 3626, 2083, 37, 480, 285, 3702, 244, 550, 178, + 3748, 523, 46, 3568, 495, 278, 76, 464, 64, 532, + 517, 2159, 193, 280, 464, 532, 375, 473, 2398, 2399, + 2400, 462, 457, 530, 2927, 206, 313, 3396, 366, 401, + 2218, 467, 473, 77, 78, 79, 1544, 1545, 605, 1203, + 1130, 2075, 1206, 414, 415, 3187, 1280, 467, 464, 490, + 605, 528, 3673, 2846, 526, 2841, 405, 1480, 530, 103, + 3695, 1569, 2807, 2868, 532, 2212, 528, 2868, 1884, 424, + 469, 3158, 528, 514, 532, 3419, 3632, 3673, 424, 1376, + 1190, 1494, 530, 280, 1381, 13, 486, 528, 285, 109, + 1387, 19, 2283, 290, 405, 464, 2250, 519, 520, 2534, + 2594, 2392, 30, 1516, 2886, 2679, 2284, 2432, 1947, 2440, + 2270, 490, 490, 3289, 1919, 2218, 44, 45, 3294, 531, + 2435, 531, 532, 1631, 1632, 1383, 527, 1722, 532, 2276, + 2577, 2578, 2579, 2580, 528, 528, 528, 526, 531, 528, + 3231, 530, 536, 528, 477, 427, 433, 41, 464, 437, + 529, 529, 531, 531, 528, 492, 1627, 528, 528, 3633, + 528, 3099, 533, 534, 528, 528, 536, 768, 405, 1640, + 528, 1642, 492, 479, 528, 3056, 395, 514, 528, 1394, + 440, 533, 534, 526, 112, 1393, 527, 530, 528, 1612, + 1613, 528, 1230, 528, 514, 528, 528, 528, 528, 1622, + 1671, 768, 528, 528, 1666, 1667, 1668, 528, 528, 527, + 490, 524, 1487, 1551, 1637, 1230, 440, 440, 427, 820, + 519, 520, 278, 2717, 3536, 407, 767, 767, 519, 520, + 478, 379, 413, 1571, 514, 416, 768, 149, 524, 519, + 520, 133, 809, 150, 397, 3049, 1669, 417, 121, 431, + 447, 3528, 164, 820, 803, 827, 31, 169, 164, 5, + 827, 458, 528, 169, 2080, 351, 107, 426, 1606, 60, + 519, 520, 521, 522, 523, 524, 809, 519, 520, 521, + 522, 523, 524, 2700, 178, 2702, 835, 820, 872, 856, + 857, 531, 280, 872, 827, 202, 3029, 285, 467, 109, + 2442, 1502, 2030, 875, 390, 1776, 1777, 466, 220, 809, + 366, 860, 482, 880, 149, 271, 521, 522, 523, 524, + 820, 2701, 894, 1524, 197, 0, 2900, 827, 3628, 241, + 521, 522, 523, 524, 809, 241, 890, 890, 890, 395, + 890, 427, 904, 890, 890, 820, 878, 2075, 890, 890, + 890, 3133, 827, 890, 890, 467, 2498, 345, 133, 528, + 909, 532, 1843, 1848, 3035, 932, 933, 3644, 180, 936, + 937, 327, 151, 1858, 936, 528, 1861, 1848, 253, 881, + 292, 127, 128, 174, 492, 220, 292, 1858, 280, 301, + 1861, 478, 1689, 3693, 480, 205, 820, 2236, 290, 858, + 859, 216, 861, 2040, 863, 280, 514, 2416, 13, 14, + 2598, 2985, 890, 1811, 255, 31, 528, 890, 1878, 1879, + 1880, 890, 989, 1929, 203, 266, 890, 1907, 174, 120, + 890, 1945, 244, 1000, 27, 1949, 890, 1038, 1952, 890, + 1007, 1008, 2810, 2811, 280, 1843, 1013, 890, 1954, 1016, + 1017, 1000, 1019, 1020, 1021, 1022, 2755, 890, 890, 955, + 3768, 1010, 1003, 1003, 890, 1863, 301, 38, 3776, 1036, + 1868, 1038, 2614, 890, 1992, 1993, 1994, 1995, 1996, 1997, + 1047, 890, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, + 2008, 2009, 2909, 820, 2641, 890, 3300, 1064, 1065, 1066, + 890, 2340, 890, 1036, 890, 1038, 550, 2781, 890, 890, + 890, 3788, 2666, 890, 1047, 890, 254, 133, 209, 1086, + 351, 361, 1123, 3519, 229, 3275, 38, 2801, 75, 164, + 321, 322, 323, 442, 169, 2252, 1036, 2254, 1038, 1106, + 529, 38, 280, 532, 456, 138, 43, 1047, 27, 2556, + 133, 1118, 1119, 1120, 33, 1122, 1123, 1854, 1125, 390, + 34, 1036, 1859, 1038, 169, 1655, 2575, 2372, 164, 379, + 1125, 118, 1047, 278, 809, 321, 322, 323, 2306, 162, + 390, 3590, 3591, 1132, 493, 517, 60, 278, 2404, 280, + 83, 1158, 827, 1142, 27, 229, 427, 388, 530, 1613, + 33, 5, 83, 2026, 175, 102, 241, 3181, 1622, 1176, + 1177, 347, 1036, 94, 1038, 1164, 109, 427, 316, 2090, + 432, 456, 434, 1047, 1173, 3621, 528, 1211, 1212, 2997, + 1214, 1203, 1211, 1212, 1206, 1214, 427, 54, 566, 3648, + 211, 2380, 388, 6, 278, 241, 1213, 10, 460, 480, + 1217, 1218, 3456, 399, 528, 18, 227, 292, 492, 138, + 1227, 1228, 1229, 175, 3130, 1232, 109, 238, 492, 32, + 480, 462, 361, 36, 2242, 2193, 2194, 423, 175, 27, + 514, 427, 473, 176, 523, 33, 183, 264, 265, 1256, + 514, 530, 2834, 398, 528, 2118, 292, 280, 4, 211, + 1272, 386, 285, 9, 528, 138, 299, 290, 406, 1036, + 3083, 1038, 205, 347, 211, 227, 462, 4, 3091, 2449, + 1047, 248, 9, 767, 768, 1292, 238, 473, 27, 2459, + 227, 83, 1281, 280, 33, 386, 1303, 528, 285, 2927, + 205, 238, 94, 1970, 490, 3125, 523, 1974, 1043, 529, + 1977, 3050, 532, 530, 1049, 1479, 249, 1481, 1482, 464, + 529, 1328, 179, 532, 398, 809, 858, 859, 514, 861, + 363, 863, 365, 13, 14, 2198, 820, 274, 2249, 196, + 257, 526, 528, 827, 201, 530, 248, 2247, 335, 316, + 138, 526, 490, 528, 492, 530, 1350, 445, 295, 370, + 1350, 1368, 395, 1350, 1350, 526, 353, 384, 385, 530, + 1377, 2282, 2283, 1368, 432, 2963, 434, 526, 389, 2828, + 299, 530, 1048, 240, 321, 427, 1052, 1394, 872, 383, + 464, 328, 2346, 761, 2348, 529, 133, 529, 532, 138, + 532, 432, 480, 434, 1411, 2936, 890, 386, 2939, 1416, + 2941, 528, 1393, 1393, 316, 528, 1411, 529, 370, 528, + 532, 1410, 1394, 528, 447, 162, 299, 529, 2596, 2903, + 532, 529, 2600, 370, 532, 458, 526, 389, 528, 406, + 359, 191, 192, 169, 363, 27, 379, 529, 3035, 528, + 532, 33, 389, 529, 13, 14, 532, 390, 2311, 1466, + 1467, 490, 528, 492, 3015, 1472, 2164, 1474, 529, 528, + 457, 532, 1479, 1480, 1481, 1482, 395, 379, 529, 529, + 467, 532, 532, 432, 174, 434, 359, 1494, 1495, 432, + 363, 434, 2430, 460, 427, 529, 528, 1504, 532, 1506, + 27, 1474, 1509, 528, 406, 3707, 33, 1514, 528, 1516, + 1517, 299, 1519, 881, 264, 265, 1523, 3099, 451, 1003, + 3722, 2349, 395, 2351, 3754, 462, 3756, 528, 2773, 529, + 467, 1504, 532, 1506, 1474, 3779, 1509, 2772, 2754, 529, + 2756, 1514, 532, 400, 1517, 180, 1519, 480, 285, 521, + 1523, 470, 1036, 290, 1038, 896, 138, 898, 460, 1474, + 299, 528, 19, 1047, 1504, 529, 1506, 514, 532, 1509, + 3152, 359, 1579, 528, 1514, 363, 3158, 1517, 529, 1519, + 511, 532, 226, 1523, 2646, 2647, 3816, 13, 14, 1504, + 2825, 1506, 530, 248, 1509, 13, 14, 470, 1082, 1514, + 3802, 2771, 1517, 2773, 1519, 1612, 1613, 395, 1523, 244, + 1094, 138, 295, 3815, 1621, 1622, 1609, 1609, 511, 3525, + 3428, 3429, 529, 1630, 363, 532, 528, 1609, 1609, 1609, + 1637, 173, 1609, 1609, 384, 385, 532, 1644, 27, 1123, + 1504, 528, 1506, 3225, 33, 1509, 2654, 529, 529, 2621, + 1514, 532, 529, 1517, 2622, 1519, 395, 1664, 1665, 1523, + 529, 316, 1669, 2622, 2623, 1672, 2622, 2623, 2624, 174, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, - 2621, 379, 480, 1690, 1691, 1692, 13, 14, 1695, 1722, - 359, 180, 1699, 13, 14, 1702, 1703, 1704, 1705, 1706, - 1707, 1708, 1709, 1710, 1686, 359, 1713, 1504, 406, 1506, - 13, 14, 1509, 1720, 154, 1722, 205, 1514, 1692, 154, - 1517, 154, 1519, 2682, 2683, 248, 1523, 321, 322, 323, - 1762, 13, 14, 1740, 1762, 191, 192, 13, 14, 13, - 14, 13, 14, 13, 14, 13, 14, 374, 375, 1132, - 101, 248, 154, 456, 41, 244, 13, 14, 1765, 1142, - 427, 27, 460, 13, 14, 528, 8, 33, 1738, 1776, - 1777, 374, 375, 15, 16, 529, 2509, 280, 20, 21, - 22, 1164, 3384, 13, 14, 13, 14, 13, 14, 480, - 1173, 27, 90, 316, 388, 494, 3384, 33, 149, 13, - 14, 13, 14, 2719, 154, 399, 3486, 154, 264, 265, - 133, 300, 1819, 164, 13, 14, 374, 375, 169, 316, - 374, 375, 1829, 174, 268, 269, 1833, 384, 385, 423, - 528, 295, 183, 427, 13, 14, 530, 188, 154, 162, - 154, 8, 472, 473, 11, 3717, 3718, 1829, 15, 16, - 361, 1833, 3095, 20, 21, 22, 379, 2499, 2500, 440, - 1814, 3706, 3707, 3747, 3748, 1176, 1177, 1874, 462, 220, - 1877, 1825, 138, 1827, 2318, 2319, 1830, 1884, 528, 473, - 1887, 1888, 379, 406, 528, 528, 1840, 529, 1842, 180, - 241, 528, 1874, 429, 2742, 47, 490, 222, 1281, 227, - 305, 1855, 138, 60, 528, 227, 1860, 528, 227, 406, - 1864, 1865, 302, 1867, 2837, 1869, 1870, 2868, 1925, 2793, - 514, 3132, 1929, 2814, 41, 5, 2880, 1923, 384, 385, - 239, 528, 5, 27, 528, 528, 2895, 460, 331, 33, - 1947, 292, 528, 432, 295, 434, 528, 1954, 1955, 2863, - 301, 528, 5, 244, 5, 528, 1963, 280, 5, 528, - 3694, 2996, 285, 460, 3698, 5, 528, 290, 457, 528, - 9, 460, 1979, 248, 491, 528, 1983, 1984, 307, 1986, - 532, 105, 532, 529, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 342, 467, 2000, 2001, 2002, 2003, 2004, 2005, 2006, - 2007, 2008, 2009, 222, 3434, 528, 395, 169, 2015, 2016, - 169, 292, 2019, 290, 2021, 60, 367, 174, 239, 2026, - 440, 2028, 528, 440, 94, 532, 440, 1410, 60, 320, - 60, 528, 440, 299, 201, 19, 271, 440, 3772, 224, - 248, 316, 528, 2050, 138, 440, 8, 490, 386, 11, - 2057, 154, 2059, 15, 16, 297, 2063, 224, 20, 21, - 22, 440, 280, 299, 3666, 2072, 149, 101, 201, 2076, - 280, 2078, 41, 2080, 99, 2082, 427, 280, 3666, 528, - 280, 164, 41, 2057, 280, 280, 169, 528, 379, 2063, - 154, 530, 174, 359, 13, 386, 174, 363, 532, 2106, - 529, 529, 127, 128, 379, 456, 529, 2057, 316, 528, - 3069, 2118, 2119, 2063, 3086, 487, 467, 529, 2125, 2057, - 529, 1000, 529, 359, 447, 2063, 227, 363, 529, 395, - 297, 406, 529, 287, 528, 458, 487, 220, 489, 490, - 227, 432, 1066, 434, 3098, 3099, 287, 528, 528, 174, - 3398, 2158, 528, 530, 532, 2162, 477, 2198, 241, 395, - 2167, 2168, 528, 3593, 321, 322, 323, 528, 528, 460, - 528, 379, 40, 530, 486, 526, 528, 9, 529, 530, - 531, 11, 438, 248, 2057, 460, 2193, 2194, 528, 438, - 2063, 2198, 361, 527, 19, 532, 532, 2930, 406, 438, - 3647, 285, 537, 440, 470, 299, 183, 2214, 3638, 292, - 2217, 2218, 2219, 528, 165, 532, 174, 229, 301, 529, - 41, 467, 467, 220, 532, 271, 398, 229, 2235, 2236, - 296, 388, 532, 319, 470, 2242, 0, 3242, 2245, 201, - 319, 183, 38, 532, 2218, 529, 222, 43, 359, 1173, - 528, 316, 460, 528, 2261, 229, 280, 229, 2265, 530, - 2057, 3691, 224, 1142, 301, 359, 2063, 3226, 2275, 363, - 427, 2245, 60, 515, 516, 517, 60, 519, 520, 521, - 522, 523, 524, 287, 60, 2292, 2293, 2261, 60, 287, - 340, 2265, 293, 480, 1173, 2245, 321, 322, 323, 3457, - 529, 395, 2309, 2257, 2311, 462, 102, 2245, 154, 3, - 154, 2261, 528, 528, 379, 2265, 473, 154, 154, 2326, - 528, 154, 490, 2261, 41, 154, 532, 2265, 532, 295, - 280, 3, 1256, 2340, 3067, 297, 41, 101, 295, 60, - 174, 406, 2349, 2350, 2351, 11, 41, 1730, 515, 516, - 517, 169, 519, 520, 521, 522, 523, 524, 529, 529, - 183, 169, 528, 388, 529, 529, 3, 2349, 2350, 2351, - 528, 528, 2245, 456, 399, 528, 470, 40, 1257, 175, - 3, 1260, 1261, 526, 118, 149, 526, 2394, 2261, 527, - 529, 149, 2265, 529, 529, 460, 2403, 174, 423, 440, - 164, 532, 427, 537, 440, 169, 164, 440, 530, 440, - 174, 169, 511, 529, 529, 211, 511, 529, 359, 183, - 529, 1804, 1805, 448, 188, 8, 3669, 150, 11, 2436, - 530, 227, 15, 16, 2441, 511, 529, 462, 529, 2422, - 174, 2422, 238, 526, 174, 2422, 2422, 530, 473, 440, - 3364, 528, 487, 528, 2436, 157, 220, 528, 60, 528, - 528, 41, 220, 528, 47, 490, 247, 60, 2265, 532, - 513, 54, 296, 517, 296, 464, 532, 241, 274, 60, - 271, 75, 280, 241, 479, 440, 440, 81, 1871, 514, - 2497, 205, 154, 154, 2501, 154, 440, 2451, 81, 295, - 94, 528, 528, 528, 440, 528, 1889, 1890, 440, 3040, - 2517, 440, 529, 528, 528, 41, 41, 295, 361, 529, - 1399, 1400, 293, 532, 118, 321, 120, 490, 292, 528, - 41, 295, 328, 38, 292, 2517, 528, 301, 43, 154, - 285, 529, 174, 301, 321, 322, 323, 528, 2555, 528, - 60, 529, 188, 515, 516, 517, 529, 519, 520, 521, - 522, 523, 524, 14, 1066, 529, 169, 81, 529, 3443, - 526, 3445, 3488, 144, 370, 309, 529, 529, 342, 174, - 528, 2555, 529, 532, 529, 19, 1969, 321, 322, 323, - 2597, 529, 532, 389, 528, 306, 179, 102, 529, 254, - 528, 367, 528, 367, 296, 2555, 2613, 3455, 529, 183, - 154, 388, 2653, 196, 532, 209, 2625, 529, 201, 528, - 178, 529, 529, 2630, 451, 529, 528, 530, 528, 528, - 2637, 2638, 41, 87, 41, 41, 41, 532, 174, 467, - 528, 489, 529, 529, 201, 529, 2653, 2688, 3653, 3458, - 427, 3460, 527, 527, 388, 1579, 532, 240, 529, 2666, - 2693, 473, 2669, 427, 2671, 529, 462, 529, 529, 532, - 175, 2678, 2679, 295, 60, 2682, 2683, 486, 517, 529, - 2687, 2688, 2555, 490, 3598, 462, 280, 2694, 529, 529, - 207, 285, 456, 427, 3585, 118, 473, 3607, 456, 41, - 229, 2742, 528, 467, 2711, 89, 211, 194, 285, 529, - 285, 530, 517, 490, 297, 2722, 530, 530, 529, 2715, - 530, 440, 227, 487, 530, 489, 490, 530, 462, 530, - 3578, 530, 440, 238, 527, 2742, 530, 514, 530, 473, - 530, 335, 41, 530, 530, 530, 280, 530, 1627, 528, - 530, 528, 108, 1677, 1256, 530, 490, 530, 527, 353, - 530, 1640, 526, 1642, 529, 529, 530, 531, 526, 274, - 530, 529, 530, 530, 530, 530, 530, 530, 530, 2786, - 514, 530, 2789, 2790, 530, 2792, 2793, 2794, 530, 530, - 530, 2745, 1671, 530, 528, 2749, 532, 530, 530, 490, - 529, 2808, 2809, 529, 2786, 529, 528, 427, 2790, 295, - 2792, 41, 528, 9, 2821, 360, 321, 400, 528, 528, - 2861, 342, 529, 328, 2778, 2832, 532, 60, 532, 529, - 201, 61, 529, 2840, 2875, 2831, 532, 527, 472, 194, - 529, 2795, 2796, 2797, 2798, 532, 2800, 2801, 2802, 2803, - 2804, 92, 529, 2836, 353, 2836, 7, 8, 528, 2836, - 2836, 2868, 13, 457, 41, 370, 154, 125, 19, 2865, - 530, 529, 23, 467, 25, 154, 41, 107, 29, 30, - 31, 2922, 529, 34, 389, 375, 37, 38, 2895, 41, - 41, 2898, 375, 44, 45, 1819, 529, 1776, 1777, 528, - 528, 41, 3635, 467, 528, 532, 37, 315, 2915, 2916, - 253, 2918, 528, 285, 252, 2922, 193, 467, 2925, 451, - 528, 75, 298, 81, 9, 75, 77, 78, 529, 512, - 529, 528, 377, 3807, 60, 527, 519, 520, 521, 522, - 523, 524, 529, 527, 134, 2952, 94, 436, 178, 60, - 517, 278, 103, 451, 295, 41, 528, 462, 298, 110, - 111, 112, 113, 114, 115, 2972, 298, 528, 472, 1848, - 2977, 2978, 207, 2356, 204, 2982, 2983, 529, 529, 1858, - 2987, 3022, 1861, 2990, 2991, 295, 529, 295, 2995, 2996, - 529, 395, 2999, 436, 281, 123, 3003, 464, 473, 8, - 374, 1925, 11, 150, 473, 0, 15, 16, 3015, 521, - 26, 20, 21, 22, 37, 3013, 3013, 3013, 303, 528, - 3013, 374, 41, 3013, 3013, 255, 3557, 529, 3013, 3003, - 890, 2773, 2415, 2341, 1841, 2344, 266, 2786, 47, 3490, - 2720, 41, 61, 3638, 3589, 54, 3757, 3191, 278, 1954, - 867, 3091, 2504, 3003, 3061, 1979, 3613, 3730, 3357, 3670, - 3679, 61, 3069, 3723, 3415, 3003, 1243, 1991, 2332, 2350, - 1819, 1819, 81, 2851, 3668, 3677, 2763, 1579, 2792, 3665, - 310, 3088, 2329, 1376, 3664, 3762, 8, 3329, 107, 11, - 3097, 2499, 2421, 15, 16, 2500, 1348, 2021, 20, 21, - 22, 2868, 2309, 2826, 2028, 1035, 101, 107, 108, 2794, - 1035, 1196, 2275, 1801, 3068, 37, 1221, 2574, 118, 3647, - 2292, 1056, 1220, 3566, 1765, 3132, 3447, 1800, 23, 2069, - 3003, 1223, 2261, 3266, 1012, 365, 2519, 2925, 2521, 2555, - 2554, 3378, 2525, 2605, 2527, 1010, 3570, 2085, 2072, 3569, - 2169, 1010, 2076, 1010, 149, 1010, 1010, 1010, 2082, 1010, - 390, 1010, 2638, 1010, 2218, 2276, 2120, 3314, 2215, 164, - 179, 3178, 2662, 3015, 169, 1677, 2172, 1495, 178, 174, - 1890, 411, 2106, 3555, 3191, 204, 3013, 196, 183, 2974, - 804, 3198, 201, 188, 2078, 1738, 3178, 3204, 1000, 3195, - 1394, 3242, 2721, 180, 204, 1739, 3003, 3214, 3215, 3191, - 3217, 2090, 2517, 1874, -1, 224, 225, -1, -1, 3226, - 3227, 909, -1, -1, -1, 220, -1, -1, 205, -1, - -1, 240, -1, -1, -1, 3242, 255, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 241, 266, -1, -1, - -1, -1, -1, -1, -1, 255, -1, -1, -1, 278, - -1, -1, -1, -1, 3271, -1, 266, 244, -1, 8, - 3277, 280, 11, -1, 283, 0, 15, 16, 278, -1, - 280, 20, 21, 22, -1, -1, 3293, 3294, 297, -1, - 3297, 310, 3299, -1, -1, 20, -1, 292, 23, -1, - 295, -1, 224, -1, -1, -1, 301, -1, -1, -1, - 310, -1, 37, -1, -1, -1, -1, 1819, -1, -1, - -1, 46, -1, 300, 3331, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 8, -1, -1, 11, -1, -1, - -1, 15, 16, 320, -1, -1, 365, 342, 3355, -1, - -1, -1, 77, 78, 79, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 365, -1, -1, -1, -1, - 2249, 390, 367, 47, -1, 297, -1, 3384, 103, 8, - 54, -1, 11, 56, -1, -1, 15, 16, -1, -1, - 390, 400, 411, -1, -1, -1, -1, -1, -1, -1, - 551, 3408, 379, 2282, 2283, 556, 2789, 81, 3404, 386, - -1, 411, 3366, 413, -1, 566, 416, -1, 47, -1, - -1, -1, -1, 1925, -1, 54, 3408, 3434, -1, -1, - 103, -1, 427, 3387, 3388, -1, 3443, -1, 3445, -1, - 3447, -1, -1, 2826, 3451, -1, 3453, -1, 3455, -1, - -1, 124, 81, -1, -1, 432, -1, 434, 3412, -1, - 3434, 456, 3469, -1, -1, -1, 153, 3474, 3475, 142, - -1, -1, 467, 147, 147, -1, -1, 1979, 2861, 3486, - 457, -1, -1, 460, 3434, 224, -1, 174, -1, 1991, - -1, 3487, 487, 3489, 489, 490, 3503, 170, -1, -1, - 173, 3508, -1, 512, -1, 179, 515, 516, 517, -1, - 519, 520, 521, 522, 523, 524, 189, 2441, 147, 2021, - -1, 3503, 196, -1, -1, -1, 2028, 201, 528, -1, - -1, 526, -1, -1, 529, 530, 531, 3533, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3556, - 179, -1, -1, -1, 3550, -1, -1, -1, 297, 3566, - -1, 3434, -1, -1, -1, -1, 240, 196, -1, -1, - 2072, 3578, 201, 2497, 2076, -1, -1, -1, -1, -1, - 2082, -1, -1, -1, -1, -1, 3593, -1, 3595, -1, - -1, -1, -1, 515, 516, 517, -1, 519, 520, 521, - 522, 523, 524, -1, 2106, -1, -1, 3614, 759, 760, - 761, 240, 285, -1, -1, -1, -1, -1, -1, 3593, - 293, -1, -1, 297, 3007, -1, -1, -1, -1, -1, - -1, 3638, -1, -1, 321, 322, 323, -1, -1, -1, - -1, -1, 315, 3593, -1, -1, 3653, -1, -1, -1, - -1, -1, 803, 804, -1, -1, -1, -1, 809, 3666, - 811, 3668, -1, -1, 3638, -1, -1, -1, 297, 820, - -1, -1, 345, 824, 825, -1, 827, -1, -1, 830, - 831, -1, -1, -1, 3691, -1, 3668, 3683, 3638, 2613, - -1, -1, 843, 844, 845, -1, -1, 848, 3705, 3706, - 3707, 388, -1, -1, 3658, 856, 857, 858, 859, 3716, - 861, -1, 863, 3709, -1, -1, -1, 3691, -1, -1, - 3593, -1, -1, -1, 875, -1, 400, -1, -1, -1, - 881, -1, -1, -1, 3741, -1, -1, -1, 2617, 2618, - 427, 3691, -1, 894, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2678, -1, -1, 908, 909, -1, - -1, -1, -1, -1, -1, 3638, -1, -1, -1, -1, - -1, 400, -1, -1, -1, 462, 515, 516, 517, -1, - 519, 520, 521, 522, 523, 524, 473, -1, -1, 153, - -1, -1, -1, 3800, -1, -1, 947, 948, -1, -1, - 3807, -1, -1, 490, -1, -1, -1, 958, -1, -1, - 174, 962, 963, 964, 965, 966, -1, -1, 3691, -1, - 174, -1, -1, -1, -1, 550, -1, 514, 979, 25, - -1, -1, -1, -1, -1, -1, -1, -1, 512, -1, - -1, 528, -1, -1, -1, 519, 520, 521, 522, 523, - 524, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1011, 1012, -1, 1014, -1, 2789, 1017, -1, -1, -1, - -1, -1, 1023, 1024, -1, -1, -1, -1, -1, 1030, - -1, -1, -1, 512, -1, 1036, 82, 1038, -1, -1, - 519, 520, 521, 522, 523, 524, 1047, 8, -1, -1, - 11, -1, 98, -1, 15, 16, 1057, -1, 2832, -1, - 2789, -1, -1, -1, -1, -1, -1, 8, -1, -1, - 11, -1, -1, 1074, 15, 16, -1, 3310, -1, 20, - 21, 22, -1, -1, -1, -1, 47, -1, -1, 2441, - -1, -1, -1, 54, -1, -1, 37, -1, 1066, -1, - -1, 1102, 148, 1066, -1, 309, 47, 321, 322, 323, - -1, -1, 158, 54, -1, -1, -1, 321, 322, 323, - 81, -1, -1, -1, 2898, 171, 1127, -1, -1, -1, - 176, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 81, -1, -1, -1, -1, 2497, -1, -1, -1, -1, - -1, 3384, -1, -1, -1, -1, -1, -1, 8, 205, - -1, 11, -1, -1, -1, 15, 16, -1, -1, -1, - 20, 21, 22, -1, 388, -1, -1, -1, -1, 1180, - -1, -1, -1, -1, 388, -1, 147, -1, -1, -1, - -1, 3424, 767, 768, -1, 1196, 1197, 47, -1, -1, - -1, -1, 1203, 249, 54, 1206, 2935, -1, 254, 2983, - -1, -1, -1, 427, -1, -1, -1, -1, 179, -1, - -1, -1, -1, 427, -1, -1, 1227, 1228, 1229, -1, - -1, 81, -1, -1, 809, 196, 1237, -1, 179, 1240, - 201, 1242, 1243, -1, -1, 820, -1, -1, 462, -1, - -1, -1, 827, -1, 1255, 196, -1, -1, 462, 473, - 201, 2613, -1, -1, -1, -1, -1, -1, -1, 473, - -1, 1272, -1, -1, 320, 1276, 490, -1, -1, 240, - 326, 1282, -1, 224, 225, 1066, 490, -1, 1256, -1, - -1, -1, 3525, 1256, -1, 341, -1, 872, -1, 240, - 514, -1, -1, -1, -1, 127, 128, -1, -1, -1, - 514, -1, -1, -1, 528, 890, -1, -1, -1, -1, - -1, -1, -1, 3097, 528, -1, 2678, -1, -1, 179, - 376, -1, -1, 379, -1, -1, 297, -1, -1, 280, - -1, -1, 283, 1344, 390, 1346, 196, 393, -1, -1, - -1, 201, 174, 1354, -1, -1, 297, 3086, 3132, 300, - -1, -1, 3091, -1, -1, -1, 1367, 413, -1, -1, - -1, -1, -1, -1, -1, 1376, -1, -1, -1, -1, - 1381, 427, 1383, 1384, -1, 1386, 1387, -1, 434, 435, - 240, -1, -1, -1, -1, -1, -1, -1, -1, 445, - -1, -1, -1, -1, -1, 451, -1, -1, -1, -1, - -1, 3140, 3141, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3198, -1, -1, -1, 1003, -1, - 3204, -1, -1, 3666, 480, -1, -1, 2789, -1, 400, - -1, -1, -1, -1, -1, -1, -1, 297, -1, -1, - -1, -1, -1, 3227, -1, -1, -1, -1, -1, 400, - -1, 1036, -1, 1038, -1, 1466, 1467, -1, -1, -1, - -1, 1472, 1047, 1474, -1, 1256, -1, -1, -1, -1, - 2832, -1, -1, -1, -1, -1, 1487, -1, 1489, 1490, - -1, -1, -1, 1494, 1495, -1, 1497, 3271, -1, 321, - 322, 323, -1, 1504, 38, 1506, -1, 1082, 1509, 43, - -1, -1, -1, 1514, -1, 1516, 1517, -1, 1519, 1094, - -1, -1, 1523, -1, 1525, -1, 1527, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2898, -1, 1123, -1, - 400, 512, -1, -1, -1, -1, -1, -1, 519, 520, - 521, 522, 523, 524, -1, -1, 388, -1, 102, -1, - -1, 512, -1, -1, 515, 516, 517, 399, 519, 520, - 521, 522, 523, 524, 8, -1, -1, 11, -1, -1, - -1, 15, 16, -1, -1, -1, -1, -1, -1, -1, - -1, 423, -1, -1, -1, 427, -1, -1, -1, -1, - 3384, 1579, -1, -1, -1, -1, 1579, 8, -1, -1, - 11, -1, -1, 47, 15, 16, -1, -1, -1, -1, - 54, 2983, -1, -1, -1, 1636, 1211, 1212, -1, 1214, - 462, 175, -1, -1, -1, 3374, 3375, -1, 1649, 183, - -1, 473, -1, -1, -1, 3384, 47, 81, -1, -1, - -1, -1, 512, 54, -1, 515, 516, 517, 490, 519, - 520, 521, 522, 523, 524, -1, -1, 211, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1066, 1689, -1, - 81, 1692, 514, 227, 38, -1, -1, -1, -1, 43, - -1, -1, -1, -1, 238, -1, 528, -1, -1, 1677, - -1, -1, -1, -1, 1677, -1, -1, -1, -1, 1720, - -1, -1, -1, 147, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1735, -1, 1737, -1, 1739, -1, - 274, -1, -1, -1, -1, 3097, -1, -1, -1, 1750, - -1, -1, 1753, -1, -1, 179, 147, -1, 102, -1, - -1, 295, 8, -1, 1765, 11, -1, -1, -1, 15, - 16, -1, 196, -1, 20, 21, 22, 201, -1, -1, - 3132, -1, -1, -1, -1, -1, -1, 321, 179, 1790, - -1, 1792, -1, -1, 328, -1, -1, -1, 1579, -1, - -1, -1, -1, 1804, 1805, 196, -1, -1, 1066, 1810, - 201, -1, 1813, 1814, -1, -1, 240, -1, 1393, -1, - -1, -1, -1, -1, 1825, 1826, 1827, 1828, -1, 1830, - -1, 175, -1, -1, -1, -1, 370, -1, -1, 1840, - -1, 1842, -1, -1, -1, -1, 3198, -1, -1, 240, - -1, 1819, 3204, 1854, 1855, 389, 1819, -1, 1859, 1860, - -1, -1, -1, 1864, 1865, 1866, 1867, 211, 1869, 1870, - -1, -1, -1, 297, -1, 3227, -1, 1256, -1, -1, - 37, -1, -1, 227, 41, -1, -1, -1, -1, -1, - 1891, -1, 3666, -1, 238, -1, 1677, -1, 1899, -1, - 1901, 1902, 1903, 1904, 1905, 1906, 297, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3271, - 1921, -1, -1, -1, -1, -1, -1, -1, 462, 1504, - 274, 1506, -1, 467, 1509, -1, -1, 3666, -1, 1514, - -1, 1942, 1517, -1, 1519, -1, 103, -1, 1523, -1, - -1, 295, -1, -1, 111, -1, 113, 1925, 115, -1, - -1, -1, 1925, -1, -1, 1017, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 400, 321, 224, -1, - -1, -1, -1, -1, 328, -1, -1, -1, -1, -1, - -1, 1992, 1993, 1994, 1995, 1996, 1997, -1, 1256, 2000, - 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 400, - -1, 1979, -1, -1, -1, -1, 1979, -1, -1, -1, - -1, -1, -1, 1991, -1, -1, 370, -1, 1991, 2030, - -1, -1, 3384, -1, 1609, -1, -1, -1, 1819, -1, - -1, -1, -1, 2044, -1, 389, -1, -1, -1, -1, - -1, 297, -1, 2021, -1, -1, 2057, -1, 2021, -1, - 2028, -1, 2063, -1, -1, 2028, -1, -1, 2069, -1, - -1, -1, -1, -1, 2075, -1, -1, -1, -1, -1, - -1, -1, -1, 2084, 2085, -1, -1, -1, 512, -1, - -1, -1, -1, -1, -1, 519, 520, 521, 522, 523, - 524, -1, -1, -1, 2072, 13, -1, -1, 2076, 2072, - -1, 19, -1, 2076, 2082, 23, -1, 1692, 462, 2082, - -1, 512, 30, 467, -1, -1, -1, -1, 519, 520, - 521, 522, 523, 524, -1, -1, 44, 45, 2106, -1, - -1, -1, -1, 2106, 1925, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2159, -1, - -1, -1, -1, 2164, -1, -1, 1218, -1, 2169, 77, - 78, -1, -1, -1, -1, 1227, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1762, -1, -1, - -1, -1, 2193, 2194, -1, -1, -1, -1, 1979, -1, - 1579, -1, -1, -1, 112, -1, -1, -1, -1, -1, - 1991, 2212, -1, -1, -1, -1, -1, 2218, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2021, -1, -1, -1, 2245, -1, -1, 2028, -1, -1, - -1, -1, -1, -1, -1, -1, 2257, -1, -1, -1, - 2261, -1, -1, -1, 2265, 2266, -1, -1, -1, 515, - 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2072, -1, -1, -1, 2076, -1, -1, 1677, -1, - -1, 2082, -1, -1, -1, 2306, -1, -1, 2309, -1, - 2311, 2312, -1, -1, 3666, -1, -1, -1, -1, -1, - -1, 1579, -1, -1, -1, 2106, -1, 8, -1, -1, - 11, -1, -1, 2334, 15, 16, -1, -1, -1, 20, - 21, 22, -1, -1, -1, -1, -1, 8, 1923, -1, - 11, -1, -1, -1, 15, 16, 37, -1, -1, 20, - 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 37, 8, -1, -1, - 11, -1, -1, -1, 15, 16, -1, -1, -1, 20, - 21, 22, -1, -1, 551, -1, -1, -1, -1, 556, - -1, -1, -1, -1, -1, -1, 37, -1, -1, -1, - -1, -1, -1, -1, 1466, 1467, 2417, -1, -1, 1677, - 1472, -1, -1, 2424, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2434, -1, -1, 2437, 2438, 2439, 2440, - 1819, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2451, -1, 2453, -1, -1, -1, 2457, -1, -1, 2460, + 13, 14, 470, 1690, 1691, 1692, 529, 529, 1695, 532, + 532, 1686, 1699, 13, 14, 1702, 1703, 1704, 1705, 1706, + 1707, 1708, 1709, 1710, 13, 14, 1713, 2618, 2619, 300, + 447, 248, 41, 1720, 222, 1722, 60, 299, 528, 1692, + 1722, 458, 13, 14, 379, 2683, 2684, 1211, 1212, 428, + 1214, 470, 61, 1740, 13, 14, 174, 1504, 1762, 1506, + 511, 1730, 1509, 1762, 379, 13, 14, 1514, 3335, 138, + 1517, 406, 1519, 3335, 176, 226, 1523, 3440, 1765, 843, + 844, 845, 529, 359, 848, 532, 1738, 154, 529, 1776, + 1777, 532, 299, 2510, 13, 14, 154, 359, 107, 316, + 529, 363, 529, 532, 529, 532, 529, 532, 529, 532, + 359, 532, 154, 529, 154, 529, 532, 432, 532, 434, + 529, 529, 109, 532, 532, 460, 529, 529, 529, 532, + 532, 532, 1819, 395, 529, 1804, 1805, 532, 2720, 154, + 529, 41, 1829, 532, 427, 460, 1833, 249, 1196, 13, + 14, 154, 359, 529, 1829, 528, 363, 280, 1833, 13, + 14, 480, 379, 90, 1833, 13, 14, 13, 14, 154, + 8, 494, 3097, 11, 13, 14, 154, 15, 16, 13, + 14, 530, 20, 21, 22, 176, 154, 1874, 395, 406, + 1877, 154, 180, 528, 295, 204, 361, 1884, 99, 1874, + 1887, 1888, 1871, 440, 248, 13, 14, 528, 470, 529, + 2743, 8, 13, 14, 11, 528, 248, 205, 15, 16, + 1889, 1890, 528, 20, 21, 22, 127, 128, 528, 1393, + 299, 13, 14, 13, 14, 1066, 2816, 47, 1925, 2839, + 37, 222, 1929, 460, 2870, 429, 255, 2865, 2882, 351, + 227, 1923, 2795, 13, 14, 305, 244, 266, 249, 2897, + 1947, 3388, 528, 470, 13, 14, 149, 1954, 1955, 278, + 13, 14, 316, 174, 13, 14, 1963, 13, 14, 374, + 375, 164, 227, 2998, 316, 227, 169, 528, 390, 41, + 359, 302, 1979, 239, 363, 528, 1983, 1984, 5, 1986, + 1969, 310, 374, 375, 1991, 1992, 1993, 1994, 1995, 1996, + 1997, 528, 300, 2000, 2001, 2002, 2003, 2004, 2005, 2006, + 2007, 2008, 2009, 3705, 75, 427, 395, 3709, 2015, 2016, + 81, 5, 2019, 528, 2021, 379, 1384, 220, 1386, 2026, + 1504, 2028, 1506, 94, 5, 1509, 2937, 379, 331, 451, + 1514, 374, 375, 1517, 528, 1519, 365, 528, 241, 1523, + 351, 528, 406, 2050, 374, 375, 5, 118, 528, 120, + 2057, 5, 2059, 528, 406, 5, 2063, 9, 480, 268, + 269, 390, 384, 385, 528, 2072, 224, 13, 14, 2076, + 528, 2078, 528, 2080, 491, 2082, 472, 473, 307, 390, + 532, 470, 411, 105, 2057, 532, 3673, 3789, 529, 292, + 2063, 3673, 3728, 3729, 2500, 2501, 460, 222, 301, 2106, + 321, 322, 323, 248, 467, 1256, 395, 224, 460, 3717, + 3718, 2118, 2119, 3071, 3349, 169, 427, 2057, 2125, 3763, + 3764, 1176, 1177, 2063, 432, 1609, 434, 2318, 2319, 292, + 169, 60, 239, 290, 440, 528, 440, 94, 209, 297, + 451, 440, 2057, 60, 532, 60, 3100, 3101, 2063, 457, + 3597, 2158, 460, 440, 440, 2162, 271, 2198, 19, 528, + 2167, 2168, 174, 3088, 528, 440, 224, 388, 440, 480, + 386, 316, 490, 101, 154, 280, 528, 3088, 399, 280, + 297, 201, 3093, 27, 280, 41, 2193, 2194, 3196, 33, + 528, 2198, 280, 2057, 41, 2932, 280, 41, 3645, 2063, + 529, 280, 423, 528, 174, 3654, 427, 2214, 1692, 280, + 2217, 2218, 2219, 154, 285, 530, 13, 61, 174, 529, + 532, 227, 3180, 487, 227, 287, 528, 448, 2235, 2236, + 287, 477, 532, 529, 379, 2242, 529, 529, 2245, 529, + 40, 462, 486, 3411, 153, 2218, 530, 529, 529, 529, + 528, 528, 473, 456, 2261, 3702, 530, 528, 2265, 528, + 9, 406, 438, 107, 335, 174, 438, 528, 2275, 490, + 180, 528, 2245, 528, 528, 3503, 528, 11, 1762, 528, + 361, 532, 353, 19, 527, 2292, 2293, 532, 2261, 180, + 2057, 438, 2265, 514, 138, 205, 2063, 149, 285, 537, + 528, 440, 2309, 183, 2311, 2245, 165, 528, 174, 321, + 322, 323, 164, 532, 205, 460, 529, 169, 229, 2326, + 41, 2261, 220, 526, 467, 2265, 529, 530, 532, 467, + 2245, 271, 3069, 2340, 244, 229, 296, 398, 532, 532, + 319, 319, 2349, 2350, 2351, 183, 2261, 222, 529, 359, + 2265, 528, 229, 244, 2349, 2350, 2351, 515, 516, 517, + 204, 519, 520, 521, 522, 523, 524, 2356, 220, 229, + 530, 60, 280, 60, 60, 60, 388, 301, 529, 340, + 3318, 287, 287, 528, 154, 480, 457, 3, 2395, 241, + 300, 293, 528, 528, 154, 154, 467, 2404, 515, 516, + 517, 2265, 519, 520, 521, 522, 523, 524, 154, 300, + 320, 255, 321, 322, 323, 427, 154, 3328, 3329, 154, + 490, 532, 266, 532, 3335, 280, 41, 2416, 1579, 2423, + 2437, 3676, 295, 2423, 278, 2442, 2423, 2423, 3, 1923, + 292, 295, 2437, 41, 174, 11, 1814, 60, 41, 301, + 462, 118, 169, 529, 529, 299, 529, 1825, 183, 1827, + 528, 473, 1830, 529, 528, 169, 310, 3, 528, 379, + 40, 3, 1840, 526, 1842, 526, 386, 440, 2245, 388, + 529, 527, 440, 530, 529, 440, 529, 1855, 379, 440, + 532, 2498, 1860, 537, 2261, 2502, 1864, 1865, 2265, 1867, + 529, 1869, 1870, 529, 511, 529, 511, 174, 529, 359, + 150, 2518, 3042, 530, 529, 359, 528, 174, 427, 363, + 529, 365, 432, 2518, 434, 511, 1677, 528, 440, 528, + 528, 2520, 41, 2522, 3397, 528, 3399, 2526, 157, 2528, + 3442, 432, 487, 434, 528, 41, 390, 457, 60, 2556, + 460, 395, 61, 462, 1066, 532, 3409, 180, 532, 296, + 513, 464, 60, 296, 473, 247, 457, 411, 517, 460, + 60, 271, 479, 2057, 280, 440, 440, 154, 205, 2063, + 528, 490, 154, 2556, 517, 154, 528, 440, 41, 528, + 0, 2598, 440, 529, 440, 440, 528, 3412, 107, 3414, + 3511, 3512, 528, 41, 456, 514, 361, 2614, 529, 532, + 293, 295, 490, 2654, 2626, 8, 2556, 41, 11, 528, + 154, 244, 15, 16, 2631, 285, 470, 20, 21, 22, + 529, 2638, 2639, 528, 174, 528, 528, 60, 528, 188, + 529, 2556, 309, 529, 529, 14, 529, 2654, 2689, 169, + 81, 144, 3660, 526, 321, 322, 323, 529, 529, 174, + 2667, 1173, 532, 2670, 3602, 2672, 19, 529, 1819, 178, + 306, 529, 2679, 2680, 526, 1066, 2683, 2684, 530, 528, + 254, 2688, 2689, 183, 296, 528, 8, 529, 2695, 3589, + 3611, 101, 2694, 15, 16, 204, 532, 320, 20, 21, + 22, 529, 2743, 528, 367, 2712, 528, 154, 529, 532, + 529, 528, 178, 529, 2198, 529, 2723, 529, 41, 451, + 530, 388, 528, 528, 2716, 528, 87, 41, 41, 3582, + 41, 532, 174, 528, 2218, 529, 2743, 489, 529, 149, + 467, 201, 529, 527, 1256, 527, 255, 532, 529, 529, + 2234, 529, 529, 532, 164, 473, 379, 266, 295, 169, + 427, 2245, 3673, 386, 174, 60, 486, 517, 529, 278, + 207, 3634, 3635, 183, 1925, 529, 529, 2261, 188, 490, + 2787, 2265, 529, 2790, 2791, 2792, 118, 2794, 2795, 2796, + 41, 89, 2787, 229, 194, 462, 285, 2792, 285, 2794, + 528, 310, 517, 2810, 2811, 2794, 473, 529, 440, 432, + 220, 434, 440, 527, 527, 41, 2823, 529, 280, 529, + 529, 528, 2863, 490, 108, 528, 490, 2834, 1979, 9, + 529, 241, 427, 528, 532, 2842, 2877, 460, 295, 2828, + 1991, 2833, 360, 342, 2838, 60, 201, 514, 2838, 528, + 528, 2838, 2838, 529, 527, 532, 365, 532, 529, 8, + 532, 528, 11, 2870, 529, 1256, 15, 16, 194, 472, + 2021, 20, 21, 22, 2863, 2867, 529, 2028, 532, 92, + 529, 390, 292, 2924, 353, 295, 528, 41, 154, 2257, + 2897, 301, 529, 2900, 125, 154, 41, 375, 529, 60, + 60, 375, 411, 41, 297, 3642, 41, 529, 528, 467, + 2917, 2918, 315, 2920, 528, 532, 37, 2924, 528, 253, + 2927, 2072, 7, 8, 528, 2076, 285, 252, 13, 193, + 530, 2082, 342, 530, 19, 75, 467, 81, 23, 530, + 25, 530, 530, 530, 29, 30, 31, 2954, 530, 34, + 530, 530, 37, 38, 530, 2106, 41, 367, 298, 44, + 45, 3824, 530, 1066, 528, 528, 174, 2974, 530, 530, + 530, 2455, 2979, 2980, 530, 297, 530, 2984, 2985, 530, + 530, 528, 2989, 3024, 530, 2992, 2993, 530, 530, 530, + 2997, 2998, 77, 78, 3001, 530, 75, 530, 3005, 9, + 530, 530, 530, 530, 530, 530, 530, 530, 530, 530, + 3017, 174, 529, 529, 528, 377, 529, 427, 103, 527, + 3009, 527, 3015, 3015, 60, 110, 111, 112, 113, 114, + 115, 3561, 3005, 3015, 3015, 3015, 94, 134, 3015, 3015, + 436, 60, 517, 278, 530, 295, 456, 41, 38, 528, + 298, 298, 201, 43, 472, 207, 3063, 467, 528, 295, + 451, 529, 529, 295, 3071, 3005, 529, 1579, 529, 281, + 529, 529, 436, 123, 395, 224, 464, 487, 451, 489, + 490, 374, 150, 3090, 2452, 26, 473, 521, 473, 37, + 3005, 374, 3099, 528, 303, 2774, 529, 890, 2341, 1841, + 2344, 309, 2787, 3444, 2721, 3645, 3593, 3773, 3145, 1954, + 3093, 2505, 102, 321, 322, 323, 526, 3673, 3617, 529, + 530, 531, 515, 516, 517, 3132, 519, 520, 521, 522, + 523, 524, 3741, 3311, 3677, 3686, 867, 3132, 3145, 3734, + 3366, 3005, 2332, 2350, 1243, 3152, 1819, 1819, 297, 2853, + 3145, 3158, 3675, 1256, 2794, 3196, 2764, 3149, 321, 322, + 323, 3168, 3169, 3684, 3171, 1677, 2329, 3672, 1376, 3671, + 2654, 3778, 3283, 3180, 3181, 2500, 2870, 2501, 1348, 2309, + 388, 2422, 2828, 1196, 1035, 175, 2275, 1801, 1579, 3196, + 2796, 1221, 1220, 515, 516, 517, 1035, 519, 520, 521, + 522, 523, 524, 3654, 2575, 2689, 2292, 1765, 3570, 3401, + 1800, 23, 1223, 2261, 2069, 1056, 2927, 3220, 3225, 427, + 1012, 211, 2606, 2556, 3231, 388, 2555, 3332, 3574, 2085, + 3573, 2639, 2716, 2169, 1010, 1010, 1010, 227, 3005, 1010, + 3247, 3248, 1010, 1010, 3251, 1010, 3253, 1010, 238, 2276, + 2218, 3268, 1010, 2120, 462, 2215, 2172, 2663, 1495, 2743, + 3017, 2976, 3559, 3015, 427, 473, 804, 1890, 1394, 2078, + 909, 1738, 2722, 1739, 1000, 3264, 2518, 1874, 3285, -1, + -1, -1, 490, -1, 274, -1, 1677, 8, 1017, -1, + 11, 2442, -1, -1, 15, 16, -1, -1, -1, 462, + -1, -1, 3309, -1, -1, 295, 514, 1819, -1, -1, + 473, -1, -1, -1, -1, 8, -1, -1, 11, -1, + 528, -1, 15, 16, -1, -1, 47, 490, 3335, -1, + -1, 321, -1, 54, -1, -1, -1, -1, 328, -1, + -1, -1, -1, -1, -1, -1, 3335, 2498, -1, 2833, + -1, 514, 3359, -1, 47, -1, -1, -1, -1, -1, + 81, 54, -1, 3355, 3359, 528, 515, 516, 517, -1, + 519, 520, 521, 522, 523, 524, -1, -1, 2746, 2863, + 370, 3388, 2750, 2867, -1, -1, -1, -1, 81, 3378, + 3397, -1, 3399, 2877, 3401, -1, -1, 56, 3405, 389, + 3407, -1, 3409, -1, -1, -1, -1, -1, -1, -1, + -1, 2779, -1, 1925, -1, 3388, 3423, -1, -1, -1, + -1, 3428, 3429, -1, -1, -1, 147, -1, 1819, 2797, + 2798, 2799, 2800, 3440, 2802, 2803, 2804, 2805, 2806, -1, + 2924, -1, -1, -1, 103, -1, -1, -1, 3388, 3441, + 3457, 3443, -1, -1, 147, 3462, -1, -1, 179, -1, + -1, -1, 3457, 2614, -1, 124, 551, 1979, -1, -1, + -1, 556, 462, 3388, -1, 196, 1579, 467, -1, 1991, + 201, 566, -1, 142, -1, -1, 179, -1, 147, 1218, + -1, -1, -1, -1, -1, -1, 3503, -1, 1227, -1, + -1, -1, -1, 196, -1, -1, -1, -1, 201, 2021, + -1, 170, -1, -1, 173, -1, 2028, -1, -1, 240, + -1, 3005, -1, -1, -1, -1, -1, -1, 2679, -1, + 189, 3015, -1, -1, 1925, -1, -1, 3526, -1, -1, + 3024, -1, 3534, -1, -1, -1, -1, 240, -1, -1, + -1, -1, 38, 3560, -1, -1, -1, 43, -1, -1, + 2072, -1, 3554, 3570, 2076, -1, -1, -1, -1, -1, + 2082, -1, -1, -1, 1677, 3582, 297, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 153, -1, 1979, -1, + 3597, -1, 3599, 1066, 2106, -1, -1, -1, -1, -1, + 1991, -1, -1, -1, 297, -1, -1, 174, -1, -1, + -1, 3618, -1, -1, -1, -1, 102, -1, -1, -1, + -1, -1, -1, -1, 3597, -1, 285, 3634, 3635, -1, + 2021, -1, 41, -1, 293, -1, -1, 2028, 3645, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2441, -1, -1, -1, -1, 2441, -1, - -1, -1, 2057, -1, -1, -1, -1, -1, 2063, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2503, -1, -1, -1, -1, -1, 2509, -1, + -1, -1, 61, 3660, -1, -1, 315, 3597, -1, -1, + -1, -1, -1, -1, -1, 3149, 3673, -1, 3675, -1, + -1, -1, 3645, -1, 759, 760, 761, -1, -1, 400, + 3675, 2072, 3597, 2834, 3673, 2076, 345, -1, -1, 175, + -1, 2082, -1, -1, -1, 3702, -1, -1, 107, 3691, + -1, -1, 3070, -1, -1, 3645, -1, 400, -1, 3716, + 3717, 3718, 3196, -1, -1, 2106, 1819, -1, 803, 804, + 3727, -1, -1, -1, 809, 211, 811, -1, 3720, 3702, + 3645, -1, -1, -1, -1, 820, -1, 1466, 1467, 824, + 825, 227, 827, 1472, -1, 830, 831, -1, -1, 2900, + 3757, -1, 238, -1, 321, 322, 323, -1, 843, 844, + 845, -1, 3702, 848, -1, -1, -1, -1, -1, -1, + -1, 856, 857, 858, 859, -1, 861, -1, 863, -1, + -1, -1, -1, 1256, -1, -1, -1, 3702, 274, -1, + 875, 512, -1, -1, -1, 204, 881, -1, 519, 520, + 521, 522, 523, 524, -1, -1, -1, -1, -1, 894, + 3817, -1, -1, -1, -1, -1, -1, 3824, -1, 512, + -1, 388, 1925, 908, 909, -1, 519, 520, 521, 522, + 523, 524, -1, -1, 2985, 321, -1, -1, -1, -1, + -1, -1, 328, 1066, -1, -1, 255, -1, -1, -1, + -1, 8, -1, -1, 11, -1, -1, 266, 15, 16, + 427, -1, 947, 948, -1, -1, -1, -1, -1, 278, + -1, 3355, -1, 958, -1, -1, 1979, 962, 963, 964, + 965, 966, -1, -1, 370, -1, -1, -1, 1991, -1, + 47, -1, -1, -1, 979, 462, -1, 54, -1, -1, + 3384, 310, -1, 389, -1, -1, 473, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2021, -1, + -1, -1, -1, 490, 81, 2028, 1011, 1012, -1, 1014, + 2442, -1, 1017, -1, -1, -1, -1, -1, 1023, 1024, + -1, -1, 1066, -1, -1, 1030, -1, 514, 3099, -1, + -1, 1036, 3320, 1038, -1, -1, 365, 3441, -1, 3443, + -1, 528, 1047, -1, -1, -1, -1, -1, -1, 2072, + 3338, 3339, 1057, 2076, -1, -1, 462, -1, -1, 2082, + -1, 390, -1, -1, -1, -1, 2498, -1, -1, 1074, + 147, -1, -1, -1, -1, 3363, -1, -1, -1, -1, + -1, 3152, 411, 2106, -1, -1, -1, 3158, -1, -1, + -1, -1, 0, -1, -1, -1, -1, 1102, -1, -1, + -1, -1, 179, -1, -1, -1, 38, -1, -1, -1, + 3181, 43, -1, 1256, -1, -1, 1765, -1, -1, 196, + -1, -1, 1127, -1, 201, -1, -1, -1, -1, -1, + 3534, 2442, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, -1, -1, -1, 20, 21, 22, -1, + 3554, -1, -1, -1, 3225, -1, -1, -1, -1, -1, + -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, + 102, -1, -1, 47, -1, 1180, -1, -1, -1, -1, + 54, -1, 2614, -1, -1, -1, 1579, 2498, -1, -1, + -1, 1196, 1197, 101, -1, -1, -1, -1, 1203, -1, + -1, 1206, -1, -1, -1, -1, -1, 81, -1, -1, + -1, -1, 1256, -1, -1, -1, -1, -1, -1, -1, + 297, -1, 1227, 1228, 1229, -1, -1, -1, -1, -1, + -1, -1, 1237, -1, -1, 1240, -1, 1242, 1243, -1, + -1, 149, -1, 175, -1, -1, -1, 2679, -1, -1, + 1255, -1, -1, -1, -1, -1, 164, -1, -1, -1, + -1, 169, -1, -1, 3335, -1, 174, 1272, -1, -1, + -1, 1276, -1, -1, -1, 183, -1, 1282, -1, 211, + 188, -1, -1, -1, 1677, -1, -1, 3691, -1, -1, + -1, -1, -1, -1, -1, 227, -1, -1, -1, -1, + -1, -1, -1, 2614, -1, 179, 238, -1, -1, -1, + -1, -1, 220, -1, -1, -1, 3720, -1, -1, -1, + -1, -1, 196, 400, -1, -1, -1, 201, -1, -1, + -1, -1, -1, 241, -1, -1, -1, -1, -1, 1344, + -1, 1346, 274, 1992, 1993, 1994, 1995, 1996, 1997, 1354, + -1, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, + 2009, -1, 1367, 295, -1, -1, 240, -1, 2679, -1, + -1, 1376, -1, -1, -1, -1, 1381, 3665, 1383, 1384, + -1, 1386, 1387, -1, 292, -1, -1, 295, -1, 321, + -1, -1, -1, 301, -1, -1, 328, -1, -1, -1, + -1, -1, 2834, -1, -1, 37, -1, -1, -1, 41, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2442, + -1, -1, -1, 297, -1, -1, 1819, -1, -1, -1, + -1, -1, 3503, -1, 342, 512, 1579, -1, 370, -1, + -1, -1, 519, 520, 521, 522, 523, 524, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 389, -1, 367, + -1, 1466, 1467, -1, -1, -1, -1, 1472, 2900, 1474, + -1, 103, -1, -1, -1, 2498, -1, -1, -1, 111, + -1, 113, 1487, 115, 1489, 1490, -1, -1, -1, 1494, + 1495, -1, 1497, -1, -1, -1, -1, -1, -1, 1504, + -1, 1506, -1, -1, 1509, -1, -1, -1, -1, 1514, + -1, 1516, 1517, -1, 1519, -1, -1, -1, 1523, 427, + 1525, -1, 1527, 2834, -1, -1, 400, -1, -1, -1, + 462, -1, 1925, -1, 1677, 1579, -1, -1, -1, -1, + 13, -1, -1, -1, 2193, 2194, 19, -1, 456, -1, + 23, -1, -1, 2985, -1, -1, -1, 30, -1, 467, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2523, 2524, -1, 2526, -1, -1, -1, 2497, - 8, -1, -1, 11, 2497, -1, -1, 15, 16, -1, - -1, -1, -1, 224, -1, -1, 1925, -1, -1, -1, - -1, -1, -1, -1, 2555, -1, -1, -1, -1, -1, - -1, 1819, 1017, 224, -1, -1, -1, -1, -1, 47, - -1, -1, 2573, -1, -1, -1, 54, -1, -1, -1, - 2581, 2582, 2583, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 224, 2595, -1, 2597, -1, 2599, -1, - 1979, -1, -1, 81, 2605, -1, -1, -1, -1, -1, - -1, -1, 1991, -1, -1, -1, 297, -1, -1, -1, - -1, -1, -1, 2198, 2625, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 297, -1, -1, 2640, - -1, -1, 2021, 2218, -1, 2613, -1, -1, -1, 2028, - 2613, 2652, -1, -1, 811, 2656, -1, -1, 566, 2234, - 2441, -1, -1, -1, -1, -1, 297, 1925, -1, 147, - 2245, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2682, 2683, -1, -1, -1, 2261, -1, -1, -1, - 2265, -1, -1, 2072, -1, -1, -1, 2076, -1, -1, - -1, 179, -1, 2082, -1, 2706, -1, -1, -1, -1, - 2678, -1, 2713, 1765, -1, 2678, 2497, -1, 196, 2720, - -1, 1979, -1, 201, -1, -1, -1, 2106, -1, -1, - -1, -1, -1, 1991, -1, 2736, -1, -1, -1, 2740, - -1, 2742, -1, 2744, 2745, -1, -1, 2748, 2749, -1, - -1, 908, 2753, 2754, 2755, -1, 2757, -1, -1, -1, - -1, -1, 240, 2021, -1, -1, -1, -1, -1, -1, - 2028, -1, 1227, -1, -1, -1, -1, 2778, -1, 2780, + -1, 44, 45, -1, -1, -1, -1, -1, -1, 487, + -1, 489, 490, -1, -1, -1, 1979, -1, -1, 2900, + -1, 2614, -1, -1, -1, -1, -1, -1, 1991, -1, + -1, -1, 3673, -1, 77, 78, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 526, -1, + -1, 529, 530, 531, -1, -1, -1, -1, 2021, -1, + -1, 1636, -1, 1677, -1, 2028, -1, -1, 512, 112, + -1, 515, 516, 517, 1649, 519, 520, 521, 522, 523, + 524, -1, -1, -1, -1, -1, 2679, -1, -1, -1, + 2309, -1, -1, -1, -1, -1, -1, 3099, -1, -1, + -1, -1, -1, -1, 2985, -1, 1819, -1, -1, 2072, + -1, -1, -1, 2076, 1689, -1, -1, 1692, -1, 2082, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 947, -1, -1, -1, 2795, 2796, 2797, 2798, 2799, 2800, - 2801, 2802, 2803, 2804, -1, 962, 963, 964, 965, 966, - -1, -1, -1, -1, 2072, -1, -1, -1, 2076, 297, - -1, 2789, -1, -1, 2082, -1, 2789, -1, -1, 2830, - -1, -1, 2613, -1, 515, 516, 517, 2838, 519, 520, - 521, 522, 523, 524, -1, -1, -1, -1, 2106, -1, - 2851, -1, 760, 761, 515, 516, 517, 1014, 519, 520, - 521, 522, 523, 524, 2832, -1, -1, -1, -1, 2832, - -1, -1, -1, -1, -1, -1, 2877, -1, -1, 2454, - -1, -1, -1, 2884, 515, 516, 517, -1, 519, 520, - 521, 522, 523, 524, 2895, -1, -1, 2678, -1, -1, - 2901, -1, -1, -1, -1, -1, -1, 2908, 2909, 2910, - 2911, -1, 820, -1, -1, -1, -1, -1, -1, -1, - -1, 2922, 400, -1, 2925, -1, -1, -1, 2929, 2930, - 2898, -1, -1, -1, -1, 2898, -1, 2938, -1, -1, - 1992, 1993, 1994, 1995, 1996, 1997, -1, -1, 2000, 2001, - 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, -1, -1, - 2961, -1, -1, -1, -1, -1, -1, 2968, 2969, -1, - -1, -1, -1, 881, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, - 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3001, -1, 3003, -1, -1, -1, -1, -1, 2789, -1, - -1, 1466, 1467, -1, 3015, 2983, -1, 1472, -1, -1, - 2983, 3022, -1, -1, -1, -1, 3027, -1, -1, -1, - -1, -1, 3033, -1, 512, -1, -1, -1, -1, -1, - -1, 519, 520, 521, 522, 523, 524, 3048, -1, -1, - -1, 2832, -1, 3054, 69, 70, -1, -1, -1, -1, - -1, -1, 2441, -1, -1, -1, 3067, 3068, 3069, -1, - -1, -1, -1, -1, 3075, -1, -1, -1, 2653, -1, - 1237, -1, -1, -1, -1, 1242, -1, -1, -1, -1, - -1, 3092, -1, -1, -1, 110, 111, -1, 1255, 114, - 115, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2688, -1, -1, -1, 2898, 2497, 1276, - -1, -1, 1030, -1, -1, -1, -1, -1, 1036, 3097, - 1038, -1, -1, -1, 3097, -1, -1, -1, -1, 1047, - 2715, 2193, 2194, -1, -1, -1, -1, -1, -1, 1057, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3132, -1, -1, 2742, -1, 3132, - -1, -1, -1, 3174, -1, -1, 191, 192, 3179, -1, - -1, -1, -1, 2441, -1, -1, -1, -1, -1, 1346, - -1, -1, -1, 3194, 1102, -1, -1, 1354, -1, -1, - -1, -1, 2983, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 1127, - 3221, -1, -1, -1, -1, 3226, -1, -1, -1, -1, - 3198, -1, -1, -1, 2613, 3198, 3204, -1, -1, 2497, - -1, 3204, -1, 258, 259, 260, 261, 262, 263, 264, - 265, 3252, -1, 268, 269, -1, 2831, 2309, 3259, 3227, - -1, -1, -1, 1718, 3227, 3266, -1, -1, -1, -1, + -1, -1, -1, 2106, -1, 1720, -1, -1, -1, -1, + 3152, -1, -1, -1, -1, -1, 3158, -1, -1, -1, + 1735, -1, 1737, -1, 1739, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1750, -1, -1, 1753, 3181, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 3283, -1, -1, -1, 2861, -1, 1196, 1197, - 2865, -1, -1, -1, -1, -1, -1, -1, -1, 2678, - 2875, -1, -1, 3271, -1, 3306, -1, -1, 3271, -1, - 1765, -1, -1, 3314, -1, -1, 3097, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 343, 344, - -1, -1, -1, -1, 3335, -1, -1, -1, -1, 3340, - 1497, -1, -1, -1, -1, -1, -1, 2922, -1, -1, - -1, 3132, -1, -1, -1, 2613, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3366, -1, -1, -1, 384, - 385, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3387, 3388, -1, -1, - -1, -1, -1, -1, -1, 69, 70, -1, -1, -1, - -1, -1, -1, -1, 3405, -1, 3407, -1, -1, -1, - 2789, 3412, -1, -1, -1, -1, 3384, 3198, -1, -1, - 2678, 3384, -1, 3204, -1, -1, -1, -1, 3003, -1, - 3431, -1, -1, 3434, -1, -1, 110, 111, 3013, -1, - 114, 115, -1, -1, -1, -1, 3227, 3022, -1, -1, - -1, -1, 3453, 2832, 3455, -1, 3457, 3458, -1, 3460, - -1, -1, -1, -1, 3465, -1, -1, -1, -1, 484, - 485, -1, -1, -1, -1, 1383, 1384, -1, 1386, -1, - -1, -1, -1, -1, -1, 3486, -1, -1, -1, 3490, - 3271, -1, -1, 508, 509, -1, -1, -1, -1, -1, - 3501, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 191, 192, 2898, + 1765, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1819, -1, -1, -1, -1, + -1, -1, 1925, -1, -1, 1790, -1, 1792, 3099, -1, + -1, -1, -1, 3225, -1, -1, -1, -1, -1, 1804, + 1805, -1, -1, -1, -1, 1810, -1, -1, 1813, 1814, + -1, 2834, -1, -1, -1, -1, -1, -1, -1, -1, + 1825, 1826, 1827, 1828, -1, 1830, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 1840, 1979, 1842, -1, -1, + -1, 3152, -1, -1, -1, -1, -1, 3158, 1991, 1854, + 1855, -1, -1, -1, 1859, 1860, -1, -1, -1, 1864, + 1865, 1866, 1867, -1, 1869, 1870, -1, -1, -1, -1, + 3181, -1, 8, -1, -1, 11, -1, 2900, 2021, 15, + 16, 1925, -1, -1, -1, 2028, 1891, -1, -1, -1, + -1, -1, -1, -1, 1899, -1, 1901, 1902, 1903, 1904, + 1905, 1906, -1, 3335, -1, -1, -1, -1, -1, -1, + -1, 47, -1, -1, 3225, -1, 1921, -1, 54, 551, + -1, -1, -1, -1, 556, -1, -1, -1, -1, 2072, + -1, -1, -1, 2076, -1, 1979, -1, 1942, -1, 2082, + -1, -1, -1, -1, -1, 81, -1, 1991, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3531, 2789, -1, -1, -1, -1, -1, 1992, 1993, 1994, + -1, -1, 2985, 2106, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 2021, -1, -1, + -1, -1, -1, -1, 2028, -1, -1, 1992, 1993, 1994, 1995, 1996, 1997, -1, -1, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3570, - -1, -1, -1, -1, 2832, -1, -1, 3578, -1, -1, - 1737, 1489, 1739, -1, 258, 259, 260, 261, 262, 263, - 264, 265, 3593, 1750, 268, 269, 1504, -1, 1506, -1, - -1, 1509, -1, 3384, 2983, -1, 1514, -1, -1, 1517, - -1, 1519, -1, -1, -1, 1523, -1, 1525, -1, 1527, - 3195, -1, 3623, -1, -1, -1, -1, 25, -1, -1, - 2682, 2683, -1, 1790, 3635, 3636, -1, 3638, 3639, -1, - 2898, -1, -1, -1, -1, -1, 3647, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3658, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3242, -1, 343, - 344, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 27, 3684, 82, -1, -1, -1, 33, -1, - 3691, -1, -1, -1, -1, -1, 41, -1, 3666, -1, - 98, -1, -1, 3666, -1, -1, -1, -1, -1, -1, - 384, 385, -1, -1, -1, -1, 61, -1, 3097, -1, - -1, -1, -1, -1, -1, 2983, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3737, -1, 2193, 2194, - -1, 1649, -1, -1, 1901, 1902, 1903, 1904, 1905, 1906, - 148, 3752, -1, 3132, -1, -1, 3757, -1, -1, 3760, - 158, -1, 107, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 171, -1, -1, -1, -1, 176, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 138, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 205, -1, -1, - 484, 485, -1, -1, -1, -1, -1, -1, -1, 3198, - -1, -1, 856, 857, -1, 3204, -1, -1, -1, 3404, - -1, -1, -1, -1, 508, 509, -1, -1, -1, 3097, - -1, -1, -1, 2895, -1, -1, -1, -1, 3227, -1, - -1, 249, -1, -1, 2309, 3430, 254, -1, -1, 204, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2922, -1, -1, -1, 3132, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1792, 3666, -1, 2044, -1, -1, - -1, -1, 3271, -1, -1, -1, -1, -1, 932, -1, - -1, -1, 936, 937, -1, -1, 1814, -1, -1, -1, - 255, -1, 3487, -1, 3489, -1, -1, 1825, -1, 1827, - 2972, 266, 1830, -1, -1, -1, -1, -1, 326, -1, - -1, -1, 1840, 278, 1842, -1, -1, -1, -1, -1, - 3198, -1, -1, 341, -1, -1, 3204, 1855, -1, -1, - -1, -1, 1860, -1, 299, 989, 1864, 1865, 3533, 1867, - -1, 1869, 1870, -1, -1, 310, -1, -1, -1, 3227, - -1, -1, -1, 1007, -1, 3550, -1, -1, 376, 1013, - -1, 379, 1016, -1, -1, 1019, 1020, 1021, 1022, -1, - -1, -1, 390, -1, -1, 393, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3384, -1, -1, -1, -1, - -1, -1, -1, 3271, 359, 413, -1, 3069, 363, -1, - 365, -1, -1, -1, -1, -1, -1, -1, -1, 427, - 1064, 1065, -1, -1, -1, -1, -1, 435, -1, -1, - -1, -1, -1, -1, -1, 390, -1, 445, -1, -1, - 395, -1, 1086, 451, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 411, -1, -1, -1, - -1, -1, 1106, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 480, -1, 1118, 1119, 1120, -1, 1122, 1123, - -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - 17, 18, -1, 20, 21, 22, -1, -1, 3683, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 37, -1, 2030, -1, 1158, 470, 3384, -1, -1, -1, - 47, -1, -1, -1, 3709, -1, -1, 54, -1, 27, - -1, -1, 1176, 1177, -1, 33, -1, -1, -1, 2057, - -1, -1, -1, 41, -1, 2063, -1, -1, -1, -1, - -1, 2069, -1, -1, 81, -1, -1, 2075, -1, -1, - -1, -1, -1, 61, 3226, -1, -1, -1, -1, 1213, - -1, -1, -1, 1217, 1218, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 1228, 1229, 3, -1, -1, -1, - -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - 17, 18, -1, 20, 21, 22, -1, -1, -1, 107, - -1, -1, -1, -1, -1, -1, -1, 2682, 2683, -1, - 37, -1, -1, -1, 41, -1, -1, -1, -1, -1, - 47, -1, -1, -1, -1, -1, -1, 54, -1, -1, - 138, 2159, -1, -1, -1, -1, 2164, -1, 1292, -1, - -1, 2169, 179, -1, -1, -1, -1, 2424, -1, 1303, - -1, -1, -1, -1, 81, -1, -1, -1, -1, 196, - -1, 2438, 2439, 2440, 201, -1, -1, 3666, -1, -1, - -1, -1, -1, -1, 1328, -1, 2453, -1, -1, -1, - 2457, -1, -1, 2460, -1, -1, -1, 224, 225, -1, - -1, -1, -1, -1, -1, -1, 204, -1, -1, -1, - -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2245, -1, -1, - -1, -1, -1, -1, -1, -1, 2503, -1, -1, 2257, - -1, -1, -1, 2261, -1, -1, -1, 2265, -1, -1, - -1, -1, -1, 280, -1, -1, 283, 255, -1, -1, - -1, -1, 179, -1, -1, -1, -1, -1, 266, -1, - 297, -1, 1416, 300, -1, -1, -1, -1, -1, 196, - 278, -1, -1, -1, 201, -1, -1, -1, 2306, -1, - -1, 3453, -1, -1, 2312, -1, -1, -1, 3666, -1, - -1, 299, -1, -1, -1, -1, -1, 224, 225, -1, - -1, -1, 310, -1, 2581, 2582, 2583, -1, -1, -1, - -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, - 2895, -1, -1, -1, -1, 1479, -1, 1481, 1482, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1494, 1495, -1, -1, -1, -1, -1, 2922, -1, -1, - -1, 359, -1, 280, -1, 363, 283, 365, -1, -1, - -1, -1, 1516, 400, -1, -1, -1, -1, -1, -1, - 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, - -1, -1, 390, -1, -1, -1, -1, 395, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 411, -1, -1, -1, -1, -1, -1, + -1, 147, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 3335, 2030, -1, -1, 2072, -1, + -1, -1, 2076, -1, 2683, 2684, -1, -1, 2082, 2044, + -1, -1, -1, 179, -1, -1, -1, -1, -1, 2442, + -1, -1, 2057, -1, -1, -1, -1, -1, 2063, 0, + 196, -1, 2106, -1, 2069, 201, -1, -1, -1, -1, + 2075, 3503, -1, -1, -1, -1, 3099, -1, -1, 2084, + 2085, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 566, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 8, 240, 2498, 11, -1, -1, -1, + 15, 16, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3152, + -1, -1, -1, -1, -1, 3158, -1, -1, -1, -1, + -1, -1, 47, -1, -1, -1, -1, -1, -1, 54, + -1, -1, -1, -1, 2159, -1, -1, -1, 3181, 2164, + 101, 297, -1, -1, 2169, -1, -1, -1, -1, -1, + 8, -1, -1, 11, -1, -1, 81, 15, 16, 811, + -1, -1, -1, -1, -1, -1, -1, -1, 2193, 2194, + -1, -1, 3503, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 3225, -1, -1, -1, -1, 2212, 149, 47, + -1, -1, -1, 2218, -1, -1, 54, -1, -1, -1, + -1, 2614, -1, 164, -1, -1, -1, -1, 169, -1, + -1, -1, -1, 174, -1, -1, -1, -1, -1, -1, + 2245, 3673, 183, 81, -1, -1, -1, 188, 2897, -1, + -1, -1, 2257, -1, -1, -1, 2261, -1, -1, -1, + 2265, 2266, -1, -1, 400, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 179, 2924, 908, -1, -1, 220, + -1, -1, -1, -1, -1, -1, 2679, 760, 761, -1, + -1, 196, -1, -1, -1, -1, 201, -1, -1, 2442, + 241, 2306, -1, -1, 2309, -1, 2311, 2312, -1, 147, + -1, -1, 3335, -1, -1, 947, -1, -1, -1, -1, + -1, -1, 1017, -1, -1, 2974, -1, -1, -1, 2334, + 962, 963, 964, 965, 966, 240, -1, -1, -1, -1, + -1, 179, -1, -1, -1, -1, -1, 820, -1, -1, + -1, 292, -1, -1, 295, 2498, -1, -1, 196, -1, + 301, -1, 3673, 201, -1, -1, -1, -1, -1, -1, + -1, 8, -1, -1, 11, -1, 512, -1, 15, 16, + -1, -1, 1014, 519, 520, 521, 522, 523, 524, -1, + -1, -1, 297, -1, -1, -1, -1, -1, 2442, -1, + -1, 342, 240, -1, -1, -1, -1, -1, 881, -1, + 47, -1, -1, 2418, -1, -1, -1, 54, -1, -1, + 2425, -1, 3071, -1, -1, -1, 367, -1, -1, -1, + 2435, -1, -1, 2438, 2439, 2440, 2441, -1, -1, -1, + -1, 2834, -1, -1, 81, -1, -1, 2452, -1, 2454, + -1, -1, -1, 2458, 2498, -1, 2461, -1, -1, 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 2451, -1, -1, -1, -1, -1, -1, + -1, 2614, -1, -1, -1, -1, -1, -1, -1, -1, + 3503, -1, -1, -1, -1, -1, 427, -1, -1, -1, + -1, -1, -1, -1, -1, 400, -1, -1, -1, 2504, + -1, -1, -1, -1, -1, 2510, -1, 2900, -1, -1, + 147, -1, -1, -1, -1, 456, -1, -1, -1, 2524, + 2525, -1, 2527, -1, -1, -1, 467, -1, -1, -1, + -1, 3180, 1227, -1, -1, -1, 2679, -1, -1, -1, + -1, -1, 179, -1, -1, -1, 487, -1, 489, 490, + -1, 2556, -1, -1, -1, -1, -1, 1030, -1, 196, + -1, -1, 400, 1036, 201, 1038, -1, -1, -1, 2574, + 2614, -1, -1, -1, 1047, -1, -1, 2582, 2583, 2584, + -1, -1, -1, -1, 1057, 526, -1, -1, 529, 530, + 531, 2596, 2985, 2598, -1, 2600, -1, -1, -1, -1, + -1, 2606, -1, 240, -1, 1237, -1, 512, -1, -1, + 1242, -1, -1, -1, 519, 520, 521, 522, 523, 524, + -1, 2626, -1, 1255, -1, -1, -1, -1, -1, 1102, + -1, -1, -1, -1, -1, 2679, 2641, -1, -1, -1, + -1, -1, -1, -1, 1276, -1, -1, -1, 2653, -1, + 3673, -1, 2657, -1, 1127, -1, -1, -1, -1, -1, + 297, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 512, -1, -1, -1, 2683, 2684, + -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, + -1, 2834, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 2707, -1, -1, 8, 3099, -1, 11, 2714, + -1, -1, 15, 16, 1346, -1, 2721, 20, 21, 22, + -1, -1, 1354, 1196, 1197, -1, -1, -1, -1, -1, + -1, -1, 2737, -1, 37, -1, 2741, -1, 2743, -1, + 2745, 2746, -1, -1, 2749, 2750, -1, -1, -1, 2754, + 2755, 2756, -1, 2758, -1, -1, -1, 2900, 3407, 3152, + -1, -1, -1, 400, -1, 3158, -1, -1, -1, -1, + -1, 1466, 1467, -1, 2779, -1, 2781, 1472, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3181, -1, + 2834, -1, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, + 2805, 2806, -1, -1, -1, -1, -1, -1, -1, 8, + -1, -1, 11, -1, -1, -1, 15, 16, -1, -1, + -1, 20, 21, 22, -1, -1, -1, 2832, -1, -1, + -1, -1, 3225, -1, -1, 2840, -1, -1, -1, -1, + -1, -1, 2985, -1, -1, -1, -1, -1, 2853, -1, + -1, -1, -1, -1, -1, -1, 2900, -1, -1, -1, + -1, -1, -1, -1, -1, 1497, -1, -1, -1, -1, + -1, -1, -1, -1, 2879, 512, -1, -1, -1, -1, + -1, 2886, 519, 520, 521, 522, 523, 524, -1, -1, + -1, -1, 2897, -1, -1, -1, -1, -1, 2903, -1, + -1, -1, -1, -1, -1, 2910, 2911, 2912, 2913, -1, + 1383, 1384, -1, 1386, -1, -1, -1, -1, -1, 2924, + -1, 224, 2927, -1, -1, -1, 2931, 2932, -1, -1, + -1, -1, -1, -1, -1, 2940, -1, -1, -1, -1, + 8, 2985, 3335, 11, -1, -1, -1, 15, 16, -1, + -1, -1, 20, 21, 22, -1, 3099, -1, 2963, -1, + -1, -1, -1, -1, -1, 2970, 2971, -1, -1, 37, + 8, -1, -1, 11, -1, -1, -1, 15, 16, -1, + -1, -1, 20, 21, 22, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 297, -1, -1, -1, 3003, 37, + 3005, -1, 201, -1, -1, -1, -1, -1, -1, 3152, + -1, -1, 3017, -1, 41, 3158, 1489, -1, -1, 3024, + -1, -1, -1, 1718, 3029, 224, -1, -1, -1, -1, + 3035, 1504, -1, 1506, 61, -1, 1509, -1, 3181, -1, + -1, 1514, -1, -1, 1517, 3050, 1519, -1, -1, -1, + 1523, 3056, 1525, -1, 1527, 3099, -1, -1, -1, -1, + -1, -1, -1, -1, 3069, 3070, 3071, -1, -1, -1, + 1765, -1, 3077, -1, -1, -1, -1, -1, -1, -1, + 107, 108, 3225, -1, -1, -1, -1, -1, -1, 3094, + -1, 118, -1, -1, -1, -1, -1, -1, 297, -1, + -1, -1, -1, -1, -1, 1737, -1, 1739, 3152, -1, + 3503, -1, -1, -1, 3158, -1, -1, -1, 1750, 8, + -1, -1, 11, 3128, -1, -1, 15, 16, 3133, -1, + -1, 20, 21, 22, -1, -1, -1, 3181, -1, -1, + -1, -1, -1, 3148, -1, -1, -1, -1, -1, -1, + -1, 178, -1, -1, -1, -1, 224, -1, 1790, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 3175, -1, -1, -1, -1, 3180, 1649, 204, -1, -1, + -1, 3225, -1, -1, -1, -1, 224, -1, -1, -1, + -1, -1, 3335, -1, -1, -1, -1, -1, -1, -1, + -1, 3206, -1, -1, -1, -1, -1, -1, 3213, -1, + -1, -1, 515, 516, 517, 3220, 519, 520, 521, 522, + 523, 524, -1, -1, -1, -1, -1, -1, 255, 297, + -1, -1, 3237, -1, -1, -1, -1, -1, -1, 266, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 2736, - -1, -1, 470, -1, -1, -1, -1, 1621, -1, -1, - -1, -1, -1, 400, -1, 512, 1630, -1, 515, 516, - 517, -1, 519, 520, 521, 522, 523, 524, -1, -1, - 1644, -1, -1, -1, 3069, 532, -1, -1, -1, -1, + -1, 278, -1, 280, -1, 3260, -1, -1, -1, 297, + -1, -1, -1, 3268, -1, -1, -1, -1, -1, 1901, + 1902, 1903, 1904, 1905, 1906, -1, -1, -1, -1, -1, + 3673, -1, -1, 310, 3289, -1, -1, -1, -1, 3294, + -1, 3335, -1, -1, -1, -1, -1, 1992, 1993, 1994, + 1995, 1996, 1997, -1, -1, 2000, 2001, 2002, 2003, 2004, + 2005, 2006, 2007, 2008, 2009, 3320, 515, 516, 517, 1792, + 519, 520, 521, 522, 523, 524, -1, -1, -1, -1, + -1, -1, -1, 3338, 3339, 224, -1, -1, 365, -1, + -1, 1814, -1, 856, 857, -1, -1, -1, -1, -1, + -1, 3356, 1825, 3358, 1827, -1, -1, 1830, 3363, -1, + 3503, -1, -1, 390, -1, -1, -1, 1840, -1, 1842, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 1664, -1, -1, -1, -1, -1, -1, -1, 1672, -1, - -1, -1, -1, -1, 1678, 1679, 1680, 1681, 1682, 1683, - 1684, 1685, -1, -1, -1, -1, 1690, 1691, -1, -1, - -1, 1695, -1, -1, -1, 1699, -1, -1, 1702, 1703, - 1704, 1705, 1706, 1707, 1708, 1709, 1710, -1, -1, 1713, - -1, 2838, -1, -1, -1, -1, 1720, 2595, 1722, -1, - -1, 2599, -1, -1, -1, -1, -1, 2605, -1, -1, - -1, -1, -1, -1, -1, 512, 1740, -1, 515, 516, - 517, -1, 519, 520, 521, 522, 523, 524, -1, -1, + 3385, -1, 1855, 3388, 411, -1, 413, 1860, -1, 416, + -1, 1864, 1865, -1, 1867, -1, 1869, 1870, -1, -1, + -1, -1, 3407, -1, 3409, -1, 3411, 3412, 297, 3414, + -1, -1, 2044, -1, 3419, -1, -1, -1, -1, 932, + -1, -1, -1, 936, 937, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3440, -1, -1, -1, 3444, + -1, -1, -1, -1, -1, -1, -1, 515, 516, 517, + 3455, 519, 520, 521, 522, 523, 524, -1, -1, 3503, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 989, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, + -1, -1, -1, -1, 1007, -1, -1, -1, 2193, 2194, + 1013, 528, -1, 1016, -1, -1, 1019, 1020, 1021, 1022, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, -1, 20, 21, 22, -1, -1, 3532, -1, -1, + 3673, -1, -1, -1, -1, -1, -1, -1, -1, 37, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, + -1, 1064, 1065, -1, -1, -1, 54, 2030, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3574, + -1, -1, -1, 1086, -1, -1, -1, 3582, -1, -1, + -1, -1, -1, 81, 2057, -1, -1, -1, -1, 25, + 2063, -1, 3597, 1106, -1, -1, 2069, -1, -1, -1, + -1, -1, 2075, -1, -1, 1118, 1119, 1120, -1, 1122, + 1123, -1, -1, -1, 2309, -1, -1, -1, -1, -1, + -1, -1, -1, 3628, -1, -1, 515, 516, 517, 3673, + 519, 520, 521, 522, 523, 524, -1, 3642, 3643, -1, + 3645, 3646, -1, -1, -1, 1158, 82, -1, -1, 3654, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 1776, 1777, 2652, -1, -1, -1, 2656, -1, - -1, 2908, 2909, 2910, 2911, -1, -1, -1, -1, -1, + 3665, -1, 98, 1176, 1177, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3226, -1, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, + -1, 179, -1, -1, -1, -1, 2159, -1, 3693, -1, + -1, 2164, -1, -1, -1, -1, 2169, 3702, 196, -1, + 1213, -1, -1, 201, 1217, 1218, -1, -1, -1, -1, + -1, -1, 148, -1, -1, 1228, 1229, -1, -1, -1, + -1, -1, 158, -1, -1, -1, 224, 225, -1, -1, + -1, -1, -1, -1, -1, 171, -1, -1, -1, -1, + 176, -1, 240, -1, -1, -1, -1, -1, 3753, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 37, -1, -1, -1, 41, -1, - -1, -1, -1, -1, 47, -1, -1, -1, -1, -1, + -1, -1, -1, 3768, -1, -1, -1, -1, 3773, 205, + -1, 3776, 2245, -1, -1, -1, -1, -1, -1, 1292, + -1, -1, 280, -1, 2257, 283, -1, -1, 2261, -1, + 1303, -1, 2265, 2425, -1, -1, -1, -1, -1, 297, + -1, -1, 300, -1, -1, -1, -1, 2439, 2440, 2441, + -1, -1, -1, 249, -1, 1328, -1, -1, 254, -1, + -1, -1, 2454, -1, -1, -1, 2458, -1, -1, 2461, + -1, -1, -1, 2306, -1, 3, -1, -1, -1, 2312, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 37, + -1, -1, 2504, 41, -1, 8, -1, -1, 11, 47, + -1, -1, 15, 16, 320, -1, 54, 20, 21, 22, + 326, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 400, 1416, 37, 341, -1, -1, -1, -1, + -1, -1, -1, 81, 47, -1, -1, -1, -1, -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2740, -1, -1, -1, 2744, 2745, -1, -1, - -1, 2749, -1, 1877, -1, -1, -1, -1, 81, -1, - 1884, -1, -1, 1887, 1888, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2778, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 2795, 2796, 2797, - 2798, -1, 2800, 2801, 2802, 2803, 2804, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3075, -1, - 1954, 1955, -1, -1, -1, -1, -1, -1, -1, 1963, - 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, - 18, -1, 20, 21, 22, -1, 179, -1, -1, 1983, - 1984, -1, 1986, -1, -1, -1, -1, -1, -1, 37, - -1, -1, -1, 196, -1, -1, -1, -1, 201, 47, - -1, -1, -1, -1, -1, -1, 54, -1, -1, -1, - -1, 2015, 2016, -1, -1, 2019, -1, 0, -1, -1, - -1, 224, 225, 2901, -1, -1, -1, -1, 3453, -1, - -1, -1, -1, 81, -1, -1, -1, 240, -1, -1, - 23, -1, -1, -1, -1, -1, 2050, -1, -1, -1, - 33, 2929, 35, 36, -1, 2059, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 48, -1, -1, -1, -1, - 53, -1, -1, -1, 2078, -1, 2080, 280, -1, 62, - 283, -1, -1, 2961, -1, -1, -1, -1, -1, -1, - -1, 2969, -1, 76, 297, -1, -1, 300, -1, -1, - -1, -1, 85, -1, 87, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 2119, 99, -1, 101, -1, - -1, 2125, -1, -1, -1, 3003, -1, -1, -1, 112, - -1, 179, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 127, 128, 129, -1, 196, -1, - -1, -1, -1, 201, 2158, 138, -1, -1, 2162, -1, - -1, 144, -1, 2167, 2168, -1, -1, -1, -1, -1, - 153, -1, 155, 156, -1, -1, 224, 225, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 170, -1, -1, - 3068, 174, 240, -1, -1, -1, -1, 400, -1, -1, + 376, -1, -1, 379, -1, -1, -1, -1, 81, -1, + 2582, 2583, 2584, -1, 390, -1, -1, 393, -1, -1, + -1, -1, -1, -1, -1, -1, 1479, -1, 1481, 1482, + -1, -1, -1, -1, -1, -1, -1, 413, -1, 2452, + -1, 1494, 1495, -1, -1, -1, -1, -1, 2683, 2684, + -1, 427, -1, -1, -1, -1, -1, -1, 434, 435, + -1, -1, -1, 1516, -1, -1, -1, -1, -1, 445, + -1, 179, -1, -1, 512, 451, -1, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, 196, 3, + -1, 5, -1, 201, 532, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 480, -1, 179, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 224, 225, -1, -1, + -1, -1, -1, 196, -1, -1, -1, -1, 201, -1, + -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 2214, -1, -1, 2217, -1, 2219, -1, 200, -1, -1, + -1, 224, 225, -1, -1, 69, 70, -1, -1, -1, + -1, -1, -1, -1, -1, 2737, -1, 240, 1621, -1, + -1, -1, 280, -1, -1, 283, -1, 1630, -1, -1, + -1, -1, -1, 2596, -1, -1, -1, 2600, -1, 297, + -1, 1644, 300, 2606, -1, -1, 110, 111, -1, -1, + 114, 115, -1, -1, -1, -1, -1, 280, -1, -1, + 283, 1664, -1, -1, -1, -1, -1, -1, -1, 1672, + -1, -1, -1, -1, 297, 1678, 1679, 1680, 1681, 1682, + 1683, 1684, 1685, -1, -1, -1, -1, 1690, 1691, -1, + 2653, -1, 1695, -1, 2657, -1, 1699, -1, -1, 1702, + 1703, 1704, 1705, 1706, 1707, 1708, 1709, 1710, -1, -1, + 1713, -1, 2897, -1, -1, -1, -1, 1720, 2840, 1722, + -1, -1, -1, 69, 70, -1, -1, 191, 192, -1, + -1, -1, -1, -1, -1, -1, -1, 1740, -1, 2924, + -1, -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2235, 280, 216, -1, 283, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 297, - -1, -1, 300, -1, -1, -1, -1, -1, -1, -1, - 243, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 2275, -1, -1, -1, -1, -1, -1, 3405, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2292, 2293, + -1, -1, -1, -1, 110, 111, -1, -1, 114, 115, + -1, -1, -1, 1776, 1777, -1, -1, 400, 2741, -1, + -1, -1, 2745, 2746, -1, -1, -1, 2750, 2910, 2911, + 2912, 2913, -1, -1, 258, 259, 260, 261, 262, 263, + 264, 265, -1, -1, 268, 269, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 2779, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3431, -1, -1, 2311, -1, 512, + -1, -1, -1, -1, 2797, 2798, 2799, 2800, -1, 2802, + 2803, 2804, 2805, 2806, -1, 191, 192, -1, -1, -1, + -1, -1, -1, -1, 512, -1, -1, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, + -1, -1, -1, -1, 1877, -1, -1, -1, -1, 343, + 344, 1884, -1, -1, 1887, 1888, 3071, -1, -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, - 523, 524, 2326, -1, -1, -1, 529, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 321, 322, - 323, -1, -1, -1, -1, -1, 329, -1, -1, 332, - -1, -1, 400, -1, -1, -1, -1, -1, -1, -1, + 523, 524, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 258, 259, 260, 261, 262, 263, 264, 265, + 384, 385, 268, 269, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3501, -1, -1, -1, -1, 8, - 363, 3259, 11, -1, -1, -1, 15, 16, 3266, 372, - 2394, 20, 21, 22, -1, -1, -1, -1, -1, 2403, - -1, -1, -1, -1, 3531, 388, -1, -1, 37, -1, - -1, -1, 395, 1017, 69, 70, 399, -1, 47, -1, - -1, -1, -1, -1, -1, 54, -1, -1, 411, -1, + 2903, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 1954, 1955, -1, -1, 3077, 0, -1, -1, -1, + 1963, -1, -1, -1, -1, -1, -1, -1, 2931, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, + 1983, 1984, -1, 1986, -1, -1, -1, -1, -1, 33, + -1, 35, 36, -1, -1, 3180, 25, 343, 344, -1, + 2963, -1, -1, -1, 48, -1, -1, -1, 2971, 53, + -1, -1, 2015, 2016, -1, -1, 2019, -1, 62, -1, + 484, 485, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 76, -1, -1, -1, -1, -1, 384, 385, + -1, 85, 3005, 87, 508, 509, -1, 2050, -1, -1, + -1, -1, -1, 82, -1, 99, 2059, 101, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 112, 98, + -1, -1, -1, -1, -1, 2078, -1, 2080, -1, -1, + -1, -1, -1, 127, 128, 129, -1, -1, -1, -1, + -1, -1, -1, -1, 138, -1, -1, -1, -1, -1, + 144, -1, -1, -1, -1, -1, -1, 3070, -1, 153, + -1, 155, 156, -1, -1, -1, 2119, -1, -1, 148, + -1, -1, 2125, -1, -1, 1017, 170, -1, -1, 158, + 174, -1, -1, -1, -1, -1, -1, -1, 484, 485, + -1, -1, 171, -1, -1, -1, -1, 176, -1, -1, + -1, -1, -1, -1, -1, 2158, 200, -1, -1, 2162, + -1, -1, 508, 509, 2167, 2168, -1, -1, -1, 27, + -1, -1, 216, -1, -1, 33, 205, -1, -1, -1, + -1, -1, 528, 41, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 243, + -1, -1, -1, 61, -1, -1, -1, -1, -1, -1, + -1, 2214, -1, -1, 2217, -1, 2219, -1, -1, -1, + 249, -1, 3407, -1, -1, 254, -1, -1, -1, -1, + -1, -1, 2235, -1, 3356, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 107, + 3213, 1143, -1, -1, -1, -1, -1, 3220, -1, -1, + -1, -1, -1, 3385, -1, -1, -1, -1, -1, -1, + -1, -1, 2275, -1, -1, -1, -1, 321, 322, 323, + 138, -1, -1, -1, -1, 329, -1, -1, 332, 2292, + 2293, -1, -1, -1, -1, -1, -1, 326, -1, -1, + 1192, -1, -1, -1, -1, -1, -1, -1, 2311, -1, + -1, -1, 341, -1, -1, -1, -1, -1, -1, 363, + -1, -1, -1, 2326, -1, -1, 3289, -1, 372, -1, + -1, 3294, -1, 3455, -1, 1227, -1, -1, -1, -1, + -1, -1, -1, -1, 388, -1, 204, 376, -1, -1, + 379, 395, -1, -1, -1, 399, -1, 3320, -1, -1, + -1, 390, -1, -1, 393, -1, -1, 411, -1, -1, + -1, -1, -1, -1, -1, 3338, 3339, -1, -1, 423, + -1, -1, -1, 427, 413, -1, -1, -1, -1, -1, + -1, -1, 2395, -1, 1286, -1, -1, 255, 427, -1, + 3363, 2404, -1, -1, 448, -1, 435, -1, 266, -1, + 3532, -1, -1, -1, -1, -1, 445, -1, 462, -1, + 278, 465, 451, -1, 468, -1, -1, -1, -1, 473, + 8, -1, -1, 11, -1, -1, -1, 15, 16, -1, + 1332, 299, 20, 21, 22, -1, 490, 1339, 3411, -1, + -1, 480, 310, -1, -1, -1, 3419, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, + 514, -1, -1, -1, -1, -1, 54, -1, -1, -1, + -1, -1, -1, -1, 528, -1, -1, 531, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 1390, 2502, + -1, 359, -1, 81, -1, 363, -1, 365, -1, -1, + -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, + 17, 18, 1414, 20, 21, 22, -1, -1, -1, -1, + -1, -1, 390, -1, -1, -1, -1, 395, -1, -1, + 37, -1, -1, -1, 41, -1, -1, -1, -1, -1, + 47, -1, -1, 411, -1, -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 423, -1, -1, -1, 427, -1, -1, -1, -1, -1, - -1, -1, 81, -1, -1, 110, 111, 3335, -1, 114, - 115, -1, 3340, -1, 512, 448, -1, 515, 516, 517, - -1, 519, 520, 521, 522, 523, 524, -1, -1, 462, - -1, 529, 465, -1, -1, 468, -1, -1, 3366, -1, - 473, -1, -1, -1, -1, -1, -1, 2501, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 490, -1, 3387, - 3388, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 1462, -1, 1464, -1, 1466, 1467, -1, 1469, -1, -1, + 1472, -1, -1, 1475, 81, -1, 1478, -1, -1, -1, + -1, 1483, -1, -1, 1486, -1, -1, -1, -1, -1, + -1, 179, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 470, -1, -1, -1, -1, -1, 196, -1, + -1, -1, -1, 201, -1, -1, -1, -1, 2631, -1, + -1, -1, -1, -1, -1, 2638, 2639, -1, 1530, -1, + -1, -1, -1, -1, -1, -1, 224, 225, -1, -1, + -1, 2654, 69, 70, -1, -1, -1, -1, -1, -1, + -1, -1, 240, -1, 2667, -1, -1, 2670, -1, 2672, + -1, -1, -1, -1, -1, -1, -1, 2680, -1, -1, + -1, -1, 179, -1, -1, 2688, 2689, -1, -1, -1, + -1, -1, 2695, 110, 111, -1, -1, 114, 115, 196, + -1, -1, 3665, -1, 201, 283, -1, -1, -1, 2712, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 297, + 2723, -1, -1, -1, -1, 1617, -1, 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 514, -1, -1, 3412, -1, 191, 192, -1, 1143, - -1, -1, -1, -1, -1, 528, -1, -1, 531, -1, - 179, 8, -1, -1, 11, -1, -1, -1, 15, 16, - 17, 18, -1, 20, 21, 22, -1, 196, -1, -1, - -1, -1, 201, -1, -1, -1, -1, -1, -1, 3457, - 37, -1, -1, -1, -1, -1, -1, 3465, 1192, -1, - 47, -1, -1, -1, -1, 224, 225, 54, -1, -1, - -1, -1, -1, 258, 259, 260, 261, 262, 263, 264, - 265, 240, -1, 268, 269, -1, -1, -1, -1, -1, - -1, -1, -1, 1227, 81, -1, 2630, -1, -1, -1, - -1, -1, 8, 2637, 2638, 11, -1, -1, -1, 15, - 16, 17, 18, -1, 20, 21, 22, -1, -1, 2653, - -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, - -1, 37, 2666, -1, -1, 2669, -1, 2671, 297, -1, - -1, 47, -1, -1, -1, 2679, -1, -1, 54, -1, - -1, -1, 1286, 2687, 2688, -1, -1, -1, 343, 344, - 2694, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 81, -1, 2711, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2722, -1, - -1, -1, 179, -1, -1, -1, -1, -1, 1332, 384, - 385, -1, -1, -1, -1, 1339, -1, -1, 2742, 196, - -1, -1, -1, -1, 201, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, - -1, -1, -1, -1, -1, -1, -1, 224, 225, -1, - -1, 400, -1, -1, 37, -1, -1, -1, -1, -1, - 3658, -1, -1, 240, 47, -1, 1390, -1, -1, -1, - 2794, 54, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 179, 2808, 2809, -1, -1, -1, -1, - 1414, -1, -1, -1, -1, -1, -1, 2821, 81, -1, - 196, -1, -1, 280, -1, 201, 283, -1, -1, 484, - 485, -1, -1, -1, -1, -1, 2840, -1, -1, -1, - 297, -1, -1, 300, -1, -1, -1, -1, 224, 225, - -1, -1, -1, 508, 509, -1, -1, -1, 1462, -1, - 1464, -1, 1466, 1467, 240, 1469, -1, -1, 1472, -1, - -1, 1475, -1, 528, 1478, -1, -1, -1, -1, 1483, - -1, -1, 1486, 512, -1, -1, 515, 516, 517, -1, - 519, 520, 521, 522, 523, 524, -1, -1, -1, -1, - -1, -1, -1, -1, 280, -1, -1, 283, -1, -1, - -1, 2915, 2916, -1, 2918, -1, 179, -1, -1, -1, - -1, 297, -1, -1, 300, -1, 1530, -1, -1, -1, - -1, -1, -1, 196, -1, -1, -1, -1, 201, -1, - -1, -1, -1, 400, -1, -1, -1, -1, 2952, -1, + 2743, -1, 1634, 240, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 1645, 1646, 1647, -1, -1, -1, -1, + 1652, -1, -1, -1, 1656, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 191, 192, -1, -1, -1, -1, + -1, -1, -1, 280, -1, -1, 283, 2790, 2791, -1, + -1, -1, -1, 2796, -1, -1, -1, -1, -1, -1, + 297, -1, -1, 300, -1, -1, -1, 2810, 2811, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 224, 225, -1, -1, -1, -1, -1, 2972, -1, - -1, -1, -1, 2977, 2978, -1, -1, 240, 2982, -1, - -1, -1, -1, 2987, -1, -1, 2990, 2991, -1, -1, - -1, 2995, 2996, -1, -1, 2999, -1, -1, -1, -1, + 2823, -1, 400, -1, -1, -1, -1, 1719, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2842, + -1, 258, 259, 260, 261, 262, 263, 264, 265, -1, + -1, 268, 269, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 8, -1, -1, 11, -1, 1759, -1, 15, + 16, 17, 18, -1, 20, 21, 22, -1, -1, -1, + -1, -1, -1, 1775, -1, -1, -1, -1, 1780, -1, + -1, 37, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 47, -1, 400, -1, 1797, -1, -1, 54, -1, + -1, -1, -1, -1, 2917, 2918, -1, 2920, -1, -1, + -1, -1, -1, -1, -1, -1, 343, 344, -1, -1, + -1, -1, -1, -1, 512, 81, -1, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, + -1, 2954, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 384, 385, -1, + -1, 2974, -1, -1, -1, -1, 2979, 2980, -1, -1, + -1, 2984, -1, -1, -1, -1, 2989, -1, -1, 2992, + 2993, -1, -1, -1, 2997, 2998, -1, -1, 3001, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3015, -1, 1617, -1, -1, -1, 280, -1, -1, - 283, -1, -1, -1, 400, -1, -1, -1, -1, -1, - 1634, -1, -1, -1, 297, -1, -1, 300, -1, -1, - -1, 1645, 1646, 1647, -1, -1, -1, -1, 1652, -1, - -1, -1, 1656, -1, -1, 512, -1, 3061, 515, 516, + -1, -1, -1, -1, 3017, 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, -1, - -1, -1, 529, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3088, -1, -1, -1, -1, -1, + -1, -1, 529, 179, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 196, -1, -1, -1, -1, 201, -1, -1, -1, -1, + 3063, -1, -1, -1, -1, -1, -1, 484, 485, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 224, 225, + -1, -1, -1, -1, -1, -1, -1, 3090, -1, 1981, + -1, 508, 509, -1, 240, -1, -1, 1989, 1990, -1, + 1992, 1993, 1994, 1995, 1996, 1997, -1, -1, 2000, 2001, + 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 1719, -1, -1, -1, -1, + -1, -1, -1, -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 512, 400, -1, 515, - 516, 517, -1, 519, 520, 521, 522, 523, 524, 8, - -1, -1, 11, 529, -1, 1759, 15, 16, 17, 18, + -1, 297, -1, -1, 300, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3168, 3169, -1, 3171, 8, + -1, -1, 11, -1, -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, -1, - -1, 1775, -1, -1, -1, -1, 1780, -1, 37, -1, + -1, -1, -1, 3196, -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, -1, - -1, -1, -1, 1797, -1, 54, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 54, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3231, -1, + 2122, -1, -1, -1, 2126, -1, -1, -1, -1, -1, + -1, -1, 81, -1, 3247, 3248, -1, -1, 3251, -1, + 3253, -1, -1, -1, 400, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2157, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2171, + -1, -1, 3285, -1, 2176, -1, -1, -1, 2180, 2181, + 2182, 2183, 2184, 2185, 2186, 2187, -1, -1, -1, -1, + -1, 2193, 2194, -1, 2196, 2197, 3309, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 2210, -1, + -1, 2213, -1, -1, -1, -1, -1, -1, -1, 2221, + 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, -1, + 179, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 196, -1, -1, + -1, -1, 201, -1, 2256, -1, 512, -1, -1, 515, + 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, + -1, -1, -1, 529, -1, 224, 225, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3401, -1, + -1, 240, 3405, -1, -1, -1, 3409, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 2309, -1, -1, + 3423, -1, -1, -1, -1, 3428, 3429, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3440, -1, -1, + -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 297, 3462, + -1, 300, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3214, 3215, -1, 3217, -1, -1, -1, -1, -1, -1, - -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 3242, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 512, - -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, - 523, 524, 8, -1, -1, 11, 529, -1, -1, 15, - 16, 17, 18, 3277, 20, 21, 22, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 3293, - 3294, 37, -1, 3297, -1, 3299, -1, -1, -1, -1, - -1, 47, -1, -1, -1, -1, -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 179, -1, -1, -1, -1, -1, -1, 3331, -1, -1, - -1, -1, -1, -1, -1, 81, -1, 196, -1, -1, - -1, -1, 201, -1, -1, -1, -1, -1, -1, -1, - -1, 3355, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 224, 225, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 1981, -1, -1, - -1, 240, -1, -1, -1, 1989, 1990, -1, 1992, 1993, - 1994, 1995, 1996, 1997, -1, -1, 2000, 2001, 2002, 2003, - 2004, 2005, 2006, 2007, 2008, 2009, 2010, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, - -1, -1, -1, 179, -1, -1, -1, -1, 297, -1, - -1, 300, -1, 3447, -1, -1, -1, 3451, -1, -1, - 196, 3455, -1, -1, -1, 201, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3469, -1, -1, -1, -1, - 3474, 3475, -1, -1, -1, -1, -1, -1, 224, 225, - -1, -1, 3486, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 3508, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2122, -1, - -1, -1, 2126, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 280, -1, -1, 283, -1, -1, - -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 297, 3556, 2157, 300, -1, -1, -1, -1, -1, - -1, -1, 3566, -1, -1, -1, -1, 2171, -1, -1, - -1, -1, 2176, -1, 3578, -1, 2180, 2181, 2182, 2183, - 2184, 2185, 2186, 2187, -1, -1, -1, -1, -1, 2193, - 2194, 3595, 2196, 2197, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2210, -1, -1, 2213, - 3614, -1, -1, -1, -1, -1, -1, 2221, 2222, 2223, - 2224, 2225, 2226, 2227, 2228, 2229, 2230, -1, -1, -1, + -1, -1, -1, -1, 2396, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 2407, 2408, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 3560, -1, 37, + -1, 400, -1, -1, -1, -1, -1, 3570, -1, 47, + -1, -1, -1, -1, -1, -1, 54, -1, -1, 3582, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 2256, 512, 400, -1, 515, 516, 517, -1, + -1, -1, -1, -1, -1, -1, 3599, -1, -1, -1, + -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 3618, -1, -1, -1, -1, + -1, 2513, -1, 2515, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2531, + 2532, 2533, -1, -1, 2536, 2537, 2538, 2539, 2540, 2541, + -1, -1, -1, 2545, 2546, 2547, 2548, 2549, 2550, 2551, + 2552, 2553, 2554, -1, -1, -1, -1, 2559, 2560, -1, + -1, -1, -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, -1, - 529, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - 17, 18, -1, 20, 21, 22, -1, -1, -1, -1, - -1, 3705, 3706, 3707, -1, 2309, -1, -1, -1, -1, - 37, -1, 3716, -1, -1, -1, -1, -1, -1, -1, - 47, -1, -1, -1, -1, -1, -1, 54, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3741, -1, -1, + 529, -1, -1, 2585, -1, -1, -1, -1, -1, -1, + -1, 179, -1, 2595, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3716, 3717, 3718, -1, -1, 196, -1, + -1, -1, -1, 201, 3727, -1, -1, 8, -1, -1, + 11, -1, -1, -1, 15, 16, 17, 18, 2630, 20, + 21, 22, -1, -1, -1, 2637, 224, 225, -1, -1, + -1, -1, -1, -1, 3757, -1, 37, 2649, -1, -1, + -1, -1, 240, 2655, -1, -1, 47, -1, 2660, 2661, + -1, -1, -1, 54, -1, -1, 2668, 2669, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 512, -1, -1, 515, - 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, - -1, -1, -1, 529, -1, -1, -1, -1, -1, -1, - -1, 2395, -1, -1, -1, -1, 3800, -1, -1, -1, - -1, -1, 2406, 2407, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 8, -1, -1, - 11, -1, -1, -1, 15, 16, 17, 18, -1, 20, - 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 37, -1, -1, -1, - -1, -1, 179, -1, -1, -1, 47, -1, -1, -1, - -1, -1, -1, 54, -1, -1, -1, -1, -1, 196, - -1, -1, -1, -1, 201, -1, -1, -1, -1, -1, + 2682, 2683, 2684, 2685, -1, 2687, -1, -1, -1, 2691, + 81, -1, 280, -1, -1, 283, -1, -1, -1, -1, + -1, -1, -1, -1, 3817, -1, -1, -1, -1, 297, + -1, -1, 300, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 81, -1, -1, -1, -1, -1, -1, 224, 225, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 2512, -1, - 2514, -1, -1, 240, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 2530, 2531, 2532, -1, - -1, 2535, 2536, 2537, 2538, 2539, 2540, -1, -1, -1, - 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553, - -1, -1, -1, 280, 2558, 2559, 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, - 2584, -1, -1, -1, 8, -1, -1, 11, 179, -1, - 2594, 15, 16, 17, 18, -1, 20, 21, 22, -1, - -1, -1, -1, -1, -1, 196, -1, -1, -1, -1, - 201, -1, -1, 37, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 47, -1, 2629, -1, -1, -1, -1, - 54, -1, 2636, 224, 225, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 2648, -1, -1, -1, -1, 240, - 2654, -1, -1, -1, -1, 2659, 2660, 81, -1, -1, - -1, -1, -1, 2667, 2668, -1, -1, -1, -1, -1, - -1, -1, -1, 400, -1, -1, -1, 2681, 2682, 2683, - 2684, -1, 2686, -1, -1, -1, 2690, -1, -1, 280, - 8, -1, 283, 11, -1, -1, -1, 15, 16, 17, - 18, -1, 20, 21, 22, -1, 297, -1, -1, 300, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 2751, + 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, + 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 37, - -1, -1, -1, -1, -1, 8, -1, -1, 11, 47, - -1, -1, 15, 16, 17, 18, 54, 20, 21, 22, - -1, -1, -1, -1, -1, -1, 2750, -1, -1, -1, - -1, -1, -1, -1, 37, 179, -1, -1, -1, -1, - -1, -1, -1, 81, 47, -1, -1, -1, -1, -1, - -1, 54, 196, -1, -1, -1, -1, 201, -1, -1, - -1, -1, -1, -1, -1, 512, -1, -1, 515, 516, - 517, -1, 519, 520, 521, 522, 523, 524, 81, -1, - 224, 225, 529, -1, -1, -1, -1, -1, -1, 400, - -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 8, -1, -1, 11, -1, -1, -1, 15, 16, - 17, 18, -1, 20, 21, 22, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 280, -1, -1, 283, - 37, 179, -1, -1, -1, -1, -1, -1, -1, -1, - 47, -1, 2876, 297, -1, -1, 300, 54, 196, -1, - -1, -1, -1, 201, -1, -1, -1, -1, -1, -1, - -1, 2895, -1, -1, -1, -1, 179, -1, -1, -1, - -1, -1, -1, -1, 81, -1, 224, 225, -1, -1, - -1, -1, -1, 196, -1, -1, -1, -1, 201, -1, - -1, 512, 240, -1, 515, 516, 517, -1, 519, 520, - 521, 522, 523, 524, -1, -1, -1, -1, 529, -1, - -1, 224, 225, -1, -1, -1, -1, -1, -1, 2953, - -1, 2955, -1, -1, -1, -1, -1, 240, -1, -1, - 2964, -1, 280, -1, -1, 283, -1, -1, -1, -1, - -1, -1, 2976, -1, -1, 2979, 400, 2981, -1, 297, - -1, 2985, 300, -1, 2988, 2989, -1, -1, 2992, 2993, - -1, -1, -1, -1, -1, -1, 3000, 280, -1, -1, - 283, -1, 179, -1, -1, -1, -1, -1, -1, -1, - 3014, -1, -1, -1, 297, -1, -1, 300, -1, 196, - -1, -1, -1, -1, 201, -1, 3030, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 8, -1, -1, - 11, -1, -1, -1, 15, 16, -1, 224, 225, 20, - 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 240, -1, 3069, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 47, -1, -1, -1, - -1, -1, 400, 54, -1, -1, -1, -1, 512, -1, - -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, - 524, -1, -1, 280, -1, 529, 283, -1, -1, -1, - 81, -1, -1, -1, -1, -1, -1, 400, -1, -1, - 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 8, -1, -1, 11, -1, -1, - -1, 15, 16, 17, 18, -1, 20, 21, 22, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, - -1, 3175, -1, 47, -1, -1, -1, -1, -1, -1, - 54, -1, -1, -1, -1, 3189, -1, -1, -1, -1, - -1, -1, -1, -1, 512, -1, -1, 515, 516, 517, - -1, 519, 520, 521, 522, 523, 524, 81, 179, -1, - -1, 529, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 3225, 3226, 400, -1, 196, -1, -1, -1, 512, - 201, -1, 515, 516, 517, -1, 519, 520, 521, 522, - 523, 524, -1, -1, 527, -1, 3250, 3251, -1, -1, - 3254, -1, -1, 224, 225, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, - -1, 3275, -1, -1, -1, -1, -1, -1, -1, -1, - 3284, -1, -1, 3287, 3288, 3289, -1, -1, 3292, -1, - -1, 3295, 3296, -1, -1, -1, -1, -1, -1, -1, - 3304, -1, -1, -1, -1, 179, -1, -1, -1, -1, - -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 196, -1, -1, -1, 297, 201, -1, -1, - -1, -1, -1, -1, -1, 512, -1, -1, 515, 516, - 517, -1, 519, 520, 521, 522, 523, 524, 3352, -1, - 224, 225, 529, -1, 3358, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 240, 3371, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 179, 47, + -1, -1, -1, -1, -1, -1, 54, -1, -1, -1, + -1, -1, -1, -1, -1, 196, -1, -1, -1, -1, + 201, -1, 400, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 81, -1, -1, -1, -1, 8, -1, + -1, 11, -1, 224, 225, 15, 16, 17, 18, -1, + 20, 21, 22, -1, -1, -1, -1, -1, -1, 240, + -1, -1, -1, -1, -1, -1, -1, 37, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 47, -1, -1, + -1, -1, -1, -1, 54, -1, 2878, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 280, + -1, -1, 283, -1, -1, 2897, -1, -1, -1, -1, + -1, 81, -1, -1, -1, -1, 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 179, -1, -1, 512, -1, -1, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, 196, -1, + -1, 529, -1, 201, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2955, -1, 2957, -1, -1, -1, -1, + -1, -1, -1, -1, 2966, -1, 224, 225, -1, -1, + -1, -1, -1, -1, -1, -1, 2978, -1, -1, 2981, + -1, 2983, 240, -1, -1, 2987, -1, -1, 2990, 2991, + -1, -1, 2994, 2995, -1, -1, -1, -1, -1, 179, + 3002, -1, -1, -1, -1, -1, -1, -1, -1, 400, + -1, -1, -1, -1, 3016, -1, 196, -1, -1, -1, + -1, 201, 280, -1, -1, 283, -1, -1, -1, -1, + 3032, -1, -1, -1, -1, -1, -1, -1, -1, 297, + -1, -1, 300, -1, 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 240, -1, -1, -1, -1, -1, -1, -1, -1, 3071, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 297, 3428, 3429, 300, -1, -1, 400, - -1, 3435, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 280, 3103, 3104, 283, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 297, -1, -1, + 300, 512, -1, -1, 515, 516, 517, 3129, 519, 520, + 521, 522, 523, 524, -1, -1, -1, 8, 529, -1, + 11, 3143, 400, -1, 15, 16, 17, 18, -1, 20, + 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 37, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 47, 3179, 3180, -1, + -1, -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3471, 3472, 3473, + -1, -1, 3204, 3205, -1, -1, 3208, -1, -1, -1, + 81, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 400, -1, -1, -1, -1, -1, -1, 3229, -1, -1, + -1, -1, -1, -1, -1, -1, 3238, -1, -1, 3241, + 3242, 3243, -1, -1, 3246, -1, -1, 3249, 3250, -1, + -1, -1, -1, -1, 512, -1, 3258, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, + -1, 529, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 3497, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3509, -1, -1, -1, -1, + -1, -1, -1, -1, 3306, -1, -1, -1, 179, -1, + 3312, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3325, -1, 196, -1, -1, -1, -1, + 201, -1, 512, -1, -1, 515, 516, 517, -1, 519, + 520, 521, 522, 523, 524, -1, -1, -1, -1, 529, + -1, -1, -1, 224, 225, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 400, -1, -1, -1, + 3382, 3383, -1, -1, -1, -1, -1, 3389, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, - 521, 522, 523, 524, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3571, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3581, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 280, + -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3425, 3426, 3427, 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3451, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 3609, -1, -1, -1, -1, + -1, 3463, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 3634, -1, -1, -1, -1, -1, -1, -1, 512, -1, - -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, - 524, -1, -1, -1, -1, 529, -1, 3661, -1, -1, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 3681, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, - 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, - 3744, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, 3755, 95, 96, 97, 98, 99, 100, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, - 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, - 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, -1, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, 428, 429, 430, 431, 432, - 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, -1, -1, 458, 459, 460, 461, 462, - 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, -1, -1, 488, -1, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - -1, 514, -1, -1, -1, -1, 519, 520, 521, -1, - -1, -1, -1, 526, -1, 528, 529, -1, -1, -1, - 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, - -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, - 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, - 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, - 119, -1, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, - 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, - -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, - -1, 170, -1, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, - 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, - 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, -1, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, - 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, - -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 401, 402, 403, 404, -1, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 423, -1, 425, 426, 427, 428, - 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, 461, 462, 463, 464, 465, 466, -1, 468, - 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, - 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, - -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 512, -1, 514, -1, -1, -1, -1, - 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, - -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, - 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, - 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, - 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, - 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, - 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, - 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, - 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, - 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, 173, 174, - 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, - 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, - 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, - 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, - -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, - 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, - -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, - 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, 321, 322, 323, -1, - 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, - 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, 388, -1, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, - -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, - 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, - 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, - 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, 461, 462, 463, 464, - 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, - 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, -1, -1, 488, -1, 490, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 512, -1, 514, - -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, - -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, - 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - 31, 32, 33, 34, -1, -1, -1, 38, -1, 40, - -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, -1, 60, - 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, - 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, - -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, - -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, - 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, - 131, 132, 133, -1, 135, 136, 137, 138, 139, -1, - 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, - -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, - 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, - 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, - -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, - 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, - 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, - -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, - 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, - 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, - 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, -1, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, - 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, - 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, - -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, - 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, - 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, - 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, - 521, -1, -1, -1, -1, 526, -1, 528, 529, -1, - -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, - 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, - -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, -1, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, - 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, - 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, - -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, - 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, - 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, - 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, - 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, -1, 236, - 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, - 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, - 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, - -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, - 437, 438, 439, -1, 441, 442, 443, 444, 445, 446, - 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, - -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, - -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, - -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, - -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, - 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, 38, -1, 40, -1, -1, - 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, -1, 60, 61, 62, - 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, - 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, - -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, - 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, - -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, - 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, - 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, - 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, - -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, - 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, - 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, - 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, - 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, - -1, -1, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, -1, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, - 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, - 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, - 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, - -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, - -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, - 533, 534, 535, 536, 3, 4, 5, 6, 7, -1, - 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, - -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, - 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, - 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, - 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, - 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, - 119, -1, 121, 122, 123, 124, 125, 126, 127, 128, - 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, - 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, - -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, - -1, 170, -1, 172, 173, 174, 175, 176, 177, 178, - 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, - 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, - -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, - 229, 230, -1, 232, 233, 234, -1, -1, 237, 238, - 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, -1, 281, 282, 283, 284, 285, 286, 287, 288, - 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, - 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, 321, 322, 323, -1, 325, 326, 327, 328, - 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, - 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, - 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, - -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, - 399, 400, 401, 402, 403, 404, -1, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, 423, -1, 425, 426, 427, 428, - 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, - 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, -1, 462, 463, 464, 465, 466, -1, 468, - 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, - 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, - -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, -1, -1, 514, -1, -1, 3, 4, - 5, 6, 7, 8, 9, 10, -1, 526, -1, 528, - -1, -1, -1, -1, 533, 534, 535, 536, 23, 24, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3575, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 3585, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 3613, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 3641, + -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, + 521, 522, 523, 524, -1, -1, -1, -1, 529, -1, + -1, -1, -1, -1, -1, -1, 3668, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, 3688, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, 38, -1, 40, -1, -1, 43, 44, + -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, + 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, - -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + -1, 76, 77, 78, 79, 80, -1, 82, 3760, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 3771, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, - 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, + 125, 126, 127, 128, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, + 165, 166, 167, 168, -1, 170, -1, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, @@ -13793,46 +13408,46 @@ static const yytype_int16 yycheck[] = 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, + 315, 316, 317, 318, 319, 320, 321, 322, 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 385, 386, 387, 388, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, - 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, + 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, + 455, -1, -1, 458, 459, 460, 461, 462, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, + 485, -1, -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, + 505, 506, 507, 508, 509, 510, 511, 512, -1, 514, -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, 529, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, 38, -1, 40, + -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, - 51, 52, 53, 54, 55, 56, 57, 58, -1, 60, + 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, - 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, - -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, + -1, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, @@ -13847,32 +13462,32 @@ static const yytype_int16 yycheck[] = 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, + 321, 322, 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, -1, 389, 390, - 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, + 381, 382, 383, 384, 385, 386, 387, 388, -1, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, + 421, 422, 423, -1, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, + 461, 462, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, + 481, 482, 483, 484, 485, -1, -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, + 511, 512, -1, 514, -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, -1, -1, - -1, -1, 39, 40, -1, -1, 43, 44, 45, -1, + 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, + -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, @@ -13885,7 +13500,7 @@ static const yytype_int16 yycheck[] = 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, + 167, 168, -1, 170, -1, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, @@ -13900,34 +13515,34 @@ static const yytype_int16 yycheck[] = 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, + 317, 318, 319, 320, 321, 322, 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, 400, 401, 402, 403, 404, 405, 406, + 387, 388, -1, 390, 391, 392, 393, 394, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, - -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, + 427, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, + -1, 458, 459, 460, 461, 462, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, - -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, + -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, + 507, 508, 509, 510, 511, 512, -1, 514, -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, - 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, + 33, 34, -1, -1, -1, 38, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, + 53, 54, 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, @@ -13935,7 +13550,7 @@ static const yytype_int16 yycheck[] = 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, - -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, + 133, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, @@ -13951,7 +13566,7 @@ static const yytype_int16 yycheck[] = 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, + 293, 294, -1, -1, 297, 298, 299, -1, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, 331, 332, @@ -13960,7 +13575,7 @@ static const yytype_int16 yycheck[] = -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, + 383, 384, 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, @@ -13969,19 +13584,19 @@ static const yytype_int16 yycheck[] = 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, + 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, - -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, + -1, -1, -1, 526, -1, 528, 529, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, 31, 32, 33, 34, -1, -1, -1, -1, + 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, + 59, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, @@ -13992,13 +13607,13 @@ static const yytype_int16 yycheck[] = 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, - -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, + -1, 170, -1, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, - 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, + 229, 230, 231, 232, 233, 234, -1, 236, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, @@ -14019,7 +13634,7 @@ static const yytype_int16 yycheck[] = 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, + 439, -1, 441, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, @@ -14032,9 +13647,9 @@ static const yytype_int16 yycheck[] = 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, + -1, -1, -1, 38, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, - 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, + 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, @@ -14045,7 +13660,7 @@ static const yytype_int16 yycheck[] = 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, 173, 174, + 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, @@ -14067,7 +13682,7 @@ static const yytype_int16 yycheck[] = 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, + 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, @@ -14076,13 +13691,13 @@ static const yytype_int16 yycheck[] = 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, - 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, + 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, - 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, + 535, 536, 3, 4, 5, 6, 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, @@ -14093,55 +13708,53 @@ static const yytype_int16 yycheck[] = -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, - 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, + 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, + 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, - -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, + -1, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, - 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, + -1, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, + 321, 322, 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, - 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, + 381, 382, 383, 384, 385, 386, 387, 388, -1, 390, + 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, + 421, 422, 423, -1, 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, + -1, 462, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, + 481, 482, 483, 484, 485, -1, -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, - 521, -1, -1, -1, -1, 526, -1, 528, 529, -1, - -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, - 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, - -1, -1, 19, -1, -1, -1, 23, 24, 25, 26, + 511, -1, -1, 514, -1, -1, 3, 4, 5, 6, + 7, 8, 9, 10, -1, 526, -1, 528, -1, -1, + -1, -1, 533, 534, 535, 536, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, - -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, + -1, 38, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, + 57, 58, -1, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, @@ -14174,7 +13787,7 @@ static const yytype_int16 yycheck[] = 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, + 387, -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, @@ -14188,13 +13801,13 @@ static const yytype_int16 yycheck[] = 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, - -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, + -1, 528, 529, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, + 33, 34, -1, -1, -1, 38, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, + 53, 54, 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, @@ -14227,11 +13840,11 @@ static const yytype_int16 yycheck[] = -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, + 383, 384, 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - -1, -1, 425, 426, 427, 428, 429, 430, 431, 432, + -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, @@ -14245,8 +13858,8 @@ static const yytype_int16 yycheck[] = 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, - -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, + 29, 30, 31, 32, 33, 34, -1, -1, -1, -1, + 39, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, @@ -14282,7 +13895,7 @@ static const yytype_int16 yycheck[] = 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, - -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, + -1, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, @@ -14290,7 +13903,7 @@ static const yytype_int16 yycheck[] = 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, - 479, 480, 481, 482, 483, 484, 485, -1, 487, 488, + 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, @@ -14350,9 +13963,9 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, - -1, -1, -1, -1, -1, -1, -1, -1, 19, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, + 31, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, @@ -14419,7 +14032,7 @@ static const yytype_int16 yycheck[] = 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, + 167, 168, -1, 170, -1, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, @@ -14508,10 +14121,10 @@ static const yytype_int16 yycheck[] = 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, - -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, + -1, -1, -1, 526, -1, 528, 529, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, + 19, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, @@ -14605,7 +14218,7 @@ static const yytype_int16 yycheck[] = 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, - 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, @@ -14664,7 +14277,7 @@ static const yytype_int16 yycheck[] = 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, - 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, + 481, 482, 483, 484, 485, -1, 487, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, @@ -14672,7 +14285,7 @@ static const yytype_int16 yycheck[] = -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, - 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, + 27, 28, 29, 30, 31, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, @@ -14724,7 +14337,7 @@ static const yytype_int16 yycheck[] = -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, @@ -14905,13 +14518,13 @@ static const yytype_int16 yycheck[] = 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, - 221, -1, 223, -1, -1, 226, 227, 228, 229, 230, + 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, - 281, 282, -1, 284, 285, 286, 287, 288, 289, 290, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, @@ -14948,7 +14561,7 @@ static const yytype_int16 yycheck[] = 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, + 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, @@ -14959,12 +14572,12 @@ static const yytype_int16 yycheck[] = 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, - 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 227, 228, 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, @@ -14982,15 +14595,15 @@ static const yytype_int16 yycheck[] = -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, + -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, -1, -1, -1, -1, -1, - -1, -1, 519, 520, -1, -1, -1, -1, -1, 526, + 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, + -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, - 3, 4, 5, 6, 7, -1, 9, 10, -1, -1, + 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, @@ -15001,7 +14614,7 @@ static const yytype_int16 yycheck[] = -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, + 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, @@ -15012,12 +14625,12 @@ static const yytype_int16 yycheck[] = 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, - 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, + 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, + 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, @@ -15035,13 +14648,13 @@ static const yytype_int16 yycheck[] = -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, - 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, + 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, -1, - -1, -1, -1, -1, -1, -1, 519, 520, -1, -1, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, @@ -15054,7 +14667,7 @@ static const yytype_int16 yycheck[] = 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, @@ -15065,13 +14678,13 @@ static const yytype_int16 yycheck[] = 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, - 219, -1, 221, -1, 223, -1, 225, 226, 227, 228, - 229, 230, -1, 232, 233, 234, -1, -1, 237, 238, + 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, + 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, -1, 281, 282, 283, 284, 285, 286, 287, 288, + 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, @@ -15089,15 +14702,15 @@ static const yytype_int16 yycheck[] = 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, + 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, -1, -1, -1, -1, -1, -1, -1, - 519, 520, -1, -1, -1, -1, -1, 526, -1, 528, + 509, 510, 511, 512, -1, -1, -1, -1, -1, -1, + 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, - 5, 6, 7, -1, 9, 10, -1, -1, -1, -1, + 5, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, @@ -15108,23 +14721,23 @@ static const yytype_int16 yycheck[] = 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, - 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, - 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, @@ -15142,15 +14755,17 @@ static const yytype_int16 yycheck[] = 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, + 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, -1, -1, -1, - -1, -1, 3, 4, 5, 6, 7, -1, 9, 10, + 505, 506, 507, 508, 509, 510, 511, 512, -1, -1, + -1, -1, -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, - 535, 536, 23, 24, 25, 26, 27, 28, 29, 30, + 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, @@ -15159,7 +14774,7 @@ static const yytype_int16 yycheck[] = -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, + 111, 112, 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, @@ -15171,11 +14786,11 @@ static const yytype_int16 yycheck[] = -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, - -1, 232, 233, 234, -1, -1, 237, 238, 239, 240, + 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, + 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, @@ -15194,14 +14809,16 @@ static const yytype_int16 yycheck[] = 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, + 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, -1, -1, -1, -1, -1, 3, 4, 5, 6, - 7, -1, 9, 10, -1, 526, -1, 528, -1, -1, - -1, -1, 533, 534, 535, 536, 23, 24, 25, 26, + 511, 512, -1, -1, -1, -1, -1, -1, 519, 520, + 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, + -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, + 7, 8, 9, 10, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, @@ -15211,7 +14828,7 @@ static const yytype_int16 yycheck[] = 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, + 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, @@ -15222,12 +14839,12 @@ static const yytype_int16 yycheck[] = 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, - 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 227, 228, 229, 230, 231, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, + 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, @@ -15245,18 +14862,20 @@ static const yytype_int16 yycheck[] = -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, + -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, -1, -1, -1, -1, -1, - 3, 4, 5, 6, 7, 8, 9, 10, -1, 526, + 507, 508, 509, 510, 511, 512, -1, -1, -1, -1, + -1, -1, 519, 520, 521, -1, -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, + 3, 4, 5, 6, 7, 8, 9, 10, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, -1, 55, 56, 57, 58, -1, -1, 61, 62, + 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, @@ -15265,16 +14884,16 @@ static const yytype_int16 yycheck[] = 113, 114, 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, - 143, -1, 145, 146, -1, 148, -1, 150, 151, 152, + 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, - 173, -1, 175, 176, 177, 178, -1, 180, 181, 182, + 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, -1, 197, 198, 199, 200, -1, 202, + 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, 227, 228, 229, 230, 231, 232, - 233, 234, -1, -1, 237, 238, 239, -1, -1, 242, + 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, @@ -15290,7 +14909,7 @@ static const yytype_int16 yycheck[] = 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, - 393, 394, 395, 396, 397, 398, -1, -1, 401, 402, + 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, @@ -15301,10 +14920,12 @@ static const yytype_int16 yycheck[] = 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, -1, - -1, -1, -1, -1, 3, -1, 519, 520, 521, -1, - -1, 10, -1, 526, -1, 528, -1, -1, -1, -1, - 533, 534, 535, 536, 23, 24, 25, 26, 27, 28, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 512, + -1, -1, -1, -1, -1, -1, 519, 520, 521, -1, + -1, -1, -1, 526, -1, 528, -1, -1, -1, -1, + 533, 534, 535, 536, 3, 4, 5, 6, 7, 8, + 9, 10, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, @@ -15318,7 +14939,7 @@ static const yytype_int16 yycheck[] = 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, + 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, @@ -15330,7 +14951,7 @@ static const yytype_int16 yycheck[] = 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - 279, -1, 281, 282, 283, 284, -1, 286, 287, 288, + 279, -1, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, @@ -15346,375 +14967,181 @@ static const yytype_int16 yycheck[] = 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, + 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, -1, -1, -1, -1, -1, 3, 4, - -1, -1, -1, -1, 9, 10, -1, 526, -1, 528, - -1, -1, -1, -1, 533, 534, 535, 536, 23, 24, + 509, 510, 511, -1, -1, -1, -1, -1, -1, -1, + 519, 520, -1, -1, -1, -1, -1, 526, -1, 528, + -1, -1, -1, -1, 533, 534, 535, 536, 3, 4, + 5, 6, 7, -1, 9, 10, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, - 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, - 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, - 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, - -1, 76, 77, 78, 79, 80, -1, -1, -1, 84, - 85, 86, 87, 88, 89, -1, 91, 92, 93, -1, - 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, + -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, + 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, -1, -1, - -1, 176, 177, 178, -1, 180, 181, 182, -1, 184, + 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, + 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, + 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, - 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, - 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, - 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, - -1, 226, -1, 228, 229, 230, -1, 232, 233, 234, - -1, -1, 237, -1, 239, -1, -1, 242, 243, 244, - 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, - 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, - -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, - -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, - -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, - 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, - 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, - -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, - 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, - 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, - 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, - 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, - 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, - 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, - 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, -1, -1, -1, - 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 533, 534, - 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, -1, -1, -1, 41, -1, - -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, - 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, - 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, - 73, 74, -1, 76, 77, 78, 79, 80, -1, -1, - -1, 84, 85, 86, 87, 88, 89, -1, 91, 92, - 93, -1, 95, 96, 97, 98, 99, 100, -1, -1, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, - 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, - -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, - 143, -1, 145, 146, 147, 148, 149, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, 164, 165, 166, 167, 168, 169, 170, -1, 172, - -1, -1, -1, 176, 177, 178, -1, 180, 181, 182, - -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, -1, 197, 198, 199, 200, -1, 202, - 203, 204, 205, 206, 207, 208, -1, 210, -1, 212, - 213, 214, 215, 216, 217, 218, 219, 220, 221, -1, - 223, -1, -1, 226, -1, 228, 229, 230, -1, 232, - 233, 234, -1, -1, 237, -1, 239, -1, 241, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, -1, 275, 276, 277, 278, 279, -1, 281, 282, - -1, 284, -1, 286, 287, 288, 289, 290, 291, 292, - 293, 294, -1, -1, 297, 298, 299, -1, 301, 302, - 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, - -1, -1, 325, 326, 327, -1, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, -1, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, - 393, 394, 395, 396, 397, 398, -1, -1, 401, 402, - 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - -1, -1, 425, 426, -1, 428, -1, 430, 431, 432, - 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, - 453, 454, 455, 456, -1, 458, 459, 460, -1, -1, - 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, -1, 477, -1, 479, 480, 481, 482, - 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, - -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 529, -1, -1, 23, - 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, - 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, - 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, - 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, - 74, -1, 76, 77, 78, 79, 80, -1, -1, -1, - 84, 85, 86, 87, 88, 89, -1, 91, 92, 93, - -1, 95, 96, 97, 98, 99, 100, -1, -1, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, - 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, - -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, - -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, - -1, 165, 166, 167, 168, -1, 170, -1, 172, -1, - -1, -1, 176, 177, 178, -1, 180, 181, 182, -1, - 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, - 194, 195, -1, 197, 198, 199, 200, -1, 202, 203, - 204, 205, 206, 207, 208, -1, 210, -1, 212, 213, - 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, - -1, -1, 226, -1, 228, 229, 230, -1, 232, 233, - 234, -1, -1, 237, -1, 239, -1, -1, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - -1, 275, 276, 277, 278, 279, -1, 281, 282, -1, - 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, - 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, - 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, - -1, 325, 326, 327, -1, 329, 330, 331, 332, 333, - 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, - 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, - 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - 364, 365, 366, -1, 368, 369, -1, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, - 394, 395, 396, 397, 398, -1, -1, 401, 402, 403, - 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, - -1, 425, 426, -1, 428, -1, 430, 431, 432, 433, - 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, - 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, - 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, - 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, - 474, 475, -1, 477, -1, 479, 480, 481, 482, 483, - 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 528, 529, -1, -1, 23, 24, - 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, 38, -1, -1, -1, -1, 43, 44, - 45, -1, 47, 48, 49, 50, 51, 52, 53, -1, - -1, 56, -1, -1, -1, 60, 61, 62, 63, 64, - 65, -1, -1, 68, 69, 70, 71, -1, -1, 74, - -1, 76, 77, 78, 79, -1, -1, 82, -1, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, - 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, -1, 114, - 115, -1, 117, -1, 119, -1, 121, 122, 123, 124, - 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, - 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, - 145, 146, 147, 148, -1, 150, 151, 152, 153, -1, - 155, 156, 157, 158, 159, 160, -1, -1, 163, -1, - 165, 166, -1, 168, -1, 170, -1, 172, 173, -1, - 175, 176, 177, 178, 179, 180, 181, 182, -1, -1, - -1, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, - 205, 206, 207, 208, -1, 210, 211, -1, 213, 214, - 215, 216, 217, -1, -1, -1, -1, -1, 223, 224, + 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, -1, 274, - -1, 276, 277, 278, -1, -1, 281, 282, 283, 284, - -1, -1, 287, -1, 289, 290, 291, -1, 293, 294, - -1, -1, 297, 298, 299, -1, -1, 302, 303, -1, - 305, 306, 307, -1, 309, 310, 311, 312, 313, 314, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, + -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, - 325, 326, -1, 328, 329, 330, -1, 332, 333, 334, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, - 345, 346, 347, -1, 349, 350, 351, 352, -1, 354, + 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, -1, 368, 369, 370, 371, 372, 373, -1, + 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, - 395, -1, 397, 398, -1, 400, 401, 402, -1, 404, + 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, -1, -1, -1, + 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, - 435, -1, 437, -1, -1, -1, -1, 442, 443, -1, - 445, -1, -1, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, - 465, 466, -1, 468, 469, 470, 471, 472, -1, -1, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, - 495, 496, 3, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 508, 509, 510, 511, -1, -1, -1, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, -1, -1, -1, + -1, -1, -1, -1, 519, 520, -1, -1, -1, -1, + -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, + 535, 536, 3, 4, 5, 6, 7, 8, 9, 10, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, 529, -1, -1, 38, -1, -1, + -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, - 51, 52, 53, -1, -1, 56, -1, -1, -1, 60, - 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, - 71, -1, -1, 74, -1, 76, 77, 78, 79, -1, + 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, -1, 114, 115, -1, 117, -1, 119, -1, + 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, - 151, 152, 153, -1, 155, 156, 157, 158, 159, 160, - -1, -1, 163, -1, 165, 166, -1, 168, -1, 170, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, - 181, 182, -1, -1, -1, 186, 187, -1, 189, 190, + 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, - 211, -1, 213, 214, 215, 216, 217, -1, -1, -1, - -1, -1, 223, 224, 225, 226, 227, 228, 229, 230, + 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, + 221, -1, 223, -1, 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, -1, 274, -1, 276, 277, 278, -1, -1, - 281, 282, 283, 284, -1, -1, 287, -1, 289, 290, + 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, + 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, - -1, 302, 303, -1, 305, 306, 307, -1, 309, 310, + -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, -1, 328, 329, 330, - -1, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, -1, 343, 344, 345, 346, 347, -1, 349, 350, + -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, - 371, 372, 373, -1, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, -1, 389, 390, - 391, 392, 393, 394, 395, -1, 397, 398, -1, 400, - 401, 402, -1, 404, -1, 406, 407, 408, 409, 410, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, + 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, -1, -1, -1, 425, 426, -1, 428, 429, 430, - 431, 432, 433, 434, 435, -1, 437, -1, -1, -1, - -1, 442, 443, -1, 445, -1, -1, 448, 449, 450, + 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, + 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, + -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, - 471, 472, -1, -1, 475, -1, 477, 478, 479, 480, + -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, + 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, - 491, 492, 493, 494, 495, 496, -1, -1, -1, -1, - 3, -1, -1, -1, -1, -1, -1, 508, 509, 510, - 511, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, 529, 32, - 33, 34, 35, 36, -1, 38, -1, -1, -1, -1, - 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, -1, 60, 61, 62, - 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, - 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, - -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, - 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, - 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, - 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, - 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, - 283, 284, -1, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, 428, 429, 430, 431, 432, - 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, - 453, 454, 455, -1, -1, 458, 459, 460, 461, 462, - 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, -1, -1, 488, -1, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, -1, - 3, 514, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 528, -1, -1, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, - 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, - 63, 64, 65, -1, 67, 68, 69, 70, 71, 72, - 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, - -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, - 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, - 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, - 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, - -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, - 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, - 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, - 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, - -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, - 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, - 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, - 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, - 233, 234, 235, -1, 237, 238, 239, 240, -1, 242, - 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, - 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, - 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, - 283, 284, -1, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, 296, 297, 298, 299, -1, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, - 323, -1, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, 388, -1, 390, 391, 392, - 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - 423, -1, 425, 426, 427, 428, 429, 430, 431, 432, - 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, - 453, 454, 455, -1, -1, 458, 459, 460, -1, 462, - 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, -1, -1, 488, -1, 490, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, -1, - 3, 514, 5, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 528, -1, -1, -1, -1, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, -1, -1, -1, -1, -1, -1, -1, 519, 520, + -1, -1, -1, -1, -1, 526, -1, 528, -1, -1, + -1, -1, 533, 534, 535, 536, 3, 4, 5, 6, + 7, -1, 9, 10, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, + 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, + -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, + 57, 58, -1, -1, 61, 62, 63, 64, 65, 66, + 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, + 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, + 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, + -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, + 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, + 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, + 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, + 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, + 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, + 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, + 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, + 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, -1, 281, 282, 283, 284, 285, 286, + 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, + 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, + 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, + -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, + 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, + -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, + 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, + 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, + -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, + -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, + -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, -1, -1, -1, -1, -1, + 3, 4, 5, 6, 7, -1, 9, 10, -1, 526, + -1, 528, -1, -1, -1, -1, 533, 534, 535, 536, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, + 33, 34, -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, - 63, 64, 65, -1, 67, 68, 69, 70, 71, 72, + 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, @@ -15723,7 +15150,7 @@ static const yytype_int16 yycheck[] = 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, - 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, + 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, @@ -15731,114 +15158,115 @@ static const yytype_int16 yycheck[] = 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, - 233, 234, 235, -1, 237, 238, 239, 240, -1, 242, + 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, - 283, 284, -1, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, 296, 297, 298, 299, -1, -1, 302, - 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, - 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, - -1, -1, 325, 326, 327, 328, 329, 330, 331, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, - 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, - -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, - 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, - 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, - 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, - -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, - 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, - 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, - 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, - 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, - 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, - 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, - -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 528, -1, -1, -1, 23, - 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, - 34, -1, -1, -1, -1, -1, -1, -1, -1, 43, - 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, - 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, - 64, 65, -1, 67, 68, 69, 70, 71, 72, 73, - 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, - 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, - -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, - 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, - 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, - 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, - -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, - -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, - 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, - -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, - -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, - 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, - 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, - 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, - 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, - 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, - 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, - 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, - 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, - 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, - 274, 275, 276, 277, 278, 279, -1, 281, 282, 283, - 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, - 294, -1, 296, 297, 298, 299, -1, -1, 302, 303, - 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, - 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, - -1, 325, 326, 327, 328, 329, 330, 331, 332, 333, - 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, - 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, - 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, - 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, - 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, - 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, - 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, - 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, - 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, - -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, - 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, - 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, - 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, - 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, - 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, - 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, - 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, - 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 528, -1, -1, -1, 23, 24, + 273, 274, 275, 276, 277, 278, 279, -1, 281, 282, + 283, 284, 285, 286, 287, 288, 289, 290, 291, -1, + 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, + 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, + -1, -1, 325, 326, 327, 328, 329, 330, 331, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, + 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, + 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, + -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, + 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, + 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, + 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, + 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, + 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, + 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, -1, + -1, -1, -1, -1, 3, 4, 5, 6, 7, -1, + 9, 10, -1, 526, -1, 528, -1, -1, -1, -1, + 533, 534, 535, 536, 23, 24, 25, 26, 27, 28, + 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, + -1, 40, -1, -1, 43, 44, 45, -1, 47, 48, + 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, + -1, -1, 61, 62, 63, 64, 65, 66, 67, 68, + 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, + 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, + 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, + 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, + 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, + -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, + -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, + 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, + 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, + -1, 210, 211, 212, 213, 214, 215, 216, 217, 218, + 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, + 229, 230, -1, 232, 233, 234, -1, -1, 237, 238, + 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, + 279, -1, 281, 282, 283, 284, 285, 286, 287, 288, + 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, + 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, -1, -1, -1, -1, 325, 326, 327, 328, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, + 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, + -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, + 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, + 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, + 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, + 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, + 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, + 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, + -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, -1, -1, -1, -1, -1, 3, 4, + 5, 6, 7, 8, 9, 10, -1, 526, -1, 528, + -1, -1, -1, -1, 533, 534, 535, 536, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, - 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, + -1, -1, -1, -1, -1, 40, -1, -1, 43, 44, + 45, -1, 47, 48, 49, 50, 51, 52, 53, -1, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, - 65, -1, 67, 68, 69, 70, 71, 72, 73, 74, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 115, 116, 117, 118, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, - 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, + 145, 146, -1, 148, -1, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, - 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, + 175, 176, 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, + 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, - 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, - 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, - -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, + 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, + -1, 226, 227, 228, 229, 230, 231, 232, 233, 234, + -1, -1, 237, 238, 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, - -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, + 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, + 285, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, @@ -15849,324 +15277,628 @@ static const yytype_int16 yycheck[] = 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, - 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, - 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, + 505, 506, 507, 508, 509, 510, 511, -1, -1, -1, + -1, -1, 3, -1, 519, 520, 521, -1, -1, 10, + -1, 526, -1, 528, -1, -1, -1, -1, 533, 534, + 535, 536, 23, 24, 25, 26, 27, 28, 29, 30, + -1, 32, 33, 34, -1, -1, -1, -1, -1, 40, + -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, + 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, + -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, + 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, + 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, + 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, + 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, + 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, + 161, -1, 163, -1, 165, 166, 167, 168, -1, 170, + -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, + 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, + -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, + 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, + 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, + -1, 232, 233, 234, -1, -1, 237, 238, 239, 240, + -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, + 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, + 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, + 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, + 281, 282, 283, 284, -1, 286, 287, 288, 289, 290, + 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, + -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, + 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, + -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, + 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, + 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, + 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, + 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, + 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, + 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, + 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, + 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, + 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, + 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, + -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, + 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, + -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, + 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, + 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, + 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, + 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, + 511, -1, -1, -1, -1, -1, 3, 4, -1, -1, + -1, -1, 9, 10, -1, 526, -1, 528, -1, -1, + -1, -1, 533, 534, 535, 536, 23, 24, 25, 26, + 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, + 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, + -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, + 77, 78, 79, 80, -1, -1, -1, 84, 85, 86, + 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, + 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, + -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, + 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, + 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, + 167, 168, -1, 170, -1, 172, -1, -1, -1, 176, + 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, + 187, -1, 189, 190, 191, 192, 193, 194, 195, -1, + 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, + 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, + 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, + -1, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, + 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, + 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, + 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, + -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, + -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, + 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, + -1, 428, -1, 430, 431, 432, 433, 434, 435, -1, + 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, + -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, + -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, + -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, + 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, + -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 528, -1, -1, -1, 23, 24, 25, + -1, -1, -1, -1, -1, -1, 533, 534, 23, 24, + 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, + -1, -1, -1, -1, -1, -1, 41, -1, -1, 44, + 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, + 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, + -1, 76, 77, 78, 79, 80, -1, -1, -1, 84, + 85, 86, 87, 88, 89, -1, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, + 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, -1, 163, 164, + 165, 166, 167, 168, 169, 170, -1, 172, -1, -1, + -1, 176, 177, 178, -1, 180, 181, 182, -1, 184, + 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, + 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, + 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, -1, 223, -1, + -1, 226, -1, 228, 229, 230, -1, 232, 233, 234, + -1, -1, 237, -1, 239, -1, 241, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, + 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, + -1, 286, 287, 288, 289, 290, 291, 292, 293, 294, + -1, -1, 297, 298, 299, -1, 301, 302, 303, 304, + -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, + 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, + -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, + -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, + 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, + 455, 456, -1, 458, 459, 460, -1, -1, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, + 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, + 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 3, -1, 5, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 529, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, - -1, -1, -1, -1, -1, -1, -1, 43, 44, 45, - -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, - 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, - -1, 67, 68, 69, 70, 71, 72, 73, 74, -1, - 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, - 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, - 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, + -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, + -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, + -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, + -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, + 76, 77, 78, 79, 80, -1, -1, -1, 84, 85, + 86, 87, 88, 89, -1, 91, 92, 93, -1, 95, + 96, 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, - 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, - 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, + 166, 167, 168, -1, 170, -1, 172, -1, -1, -1, + 176, 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, - 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, - 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, - 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, - 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, - -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, + -1, 197, 198, 199, 200, -1, 202, 203, 204, 205, + 206, 207, 208, -1, 210, -1, 212, 213, 214, 215, + 216, 217, 218, 219, -1, 221, -1, 223, -1, -1, + 226, -1, 228, 229, 230, -1, 232, 233, 234, -1, + -1, 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, - 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, - 276, 277, 278, 279, -1, 281, 282, 283, 284, -1, + 266, 267, 268, 269, 270, 271, 272, 273, -1, 275, + 276, 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, - -1, 297, 298, 299, -1, -1, 302, 303, 304, 305, - 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + -1, 297, 298, 299, -1, -1, 302, 303, 304, -1, + 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, - 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, + 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, - 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, + 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, - 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, + 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, - 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, + 426, -1, 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, - -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, + -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 528, -1, -1, -1, 23, 24, 25, 26, + -1, -1, 528, 529, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, - -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, - 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, - -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, - 77, 78, 79, 80, -1, -1, -1, 84, 85, 86, - 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, - 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, -1, -1, 135, 136, - 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, - 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, -1, 174, -1, 176, - 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, - 187, -1, 189, 190, 191, 192, 193, 194, 195, -1, - 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, - 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, - 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, - -1, 228, 229, 230, -1, 232, 233, 234, -1, -1, - 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, - 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, - 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, - 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, - -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, -1, 325, 326, - 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, - 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, -1, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, -1, 401, 402, 403, 404, -1, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, 423, -1, 425, 426, - 427, 428, -1, 430, 431, 432, 433, 434, 435, -1, - 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, - -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, -1, 462, 463, 464, 465, 466, - -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, - -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, -1, 3, 514, 5, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 528, -1, -1, -1, -1, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, - -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, - 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, - -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, - 77, 78, 79, 80, -1, -1, -1, 84, 85, 86, - 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, - 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + -1, 38, -1, -1, -1, -1, 43, 44, 45, -1, + 47, 48, 49, 50, 51, 52, 53, -1, -1, 56, + -1, -1, -1, 60, 61, 62, 63, 64, 65, -1, + -1, 68, 69, 70, 71, -1, -1, 74, -1, 76, + 77, 78, 79, -1, -1, 82, -1, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, + 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, -1, 114, 115, -1, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, - 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, -1, 174, -1, 176, - 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, - 187, -1, 189, 190, 191, 192, 193, 194, 195, -1, + 147, 148, -1, 150, 151, 152, 153, -1, 155, 156, + 157, 158, 159, 160, -1, -1, 163, -1, 165, 166, + -1, 168, -1, 170, -1, 172, 173, -1, 175, 176, + 177, 178, 179, 180, 181, 182, -1, -1, -1, 186, + 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, - 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, - 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, - -1, 228, 229, 230, -1, 232, 233, 234, -1, -1, - 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, + 207, 208, -1, 210, 211, -1, 213, 214, 215, 216, + 217, -1, -1, -1, -1, -1, 223, 224, 225, 226, + 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, - 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, - 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, - 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, - -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, -1, 325, 326, - 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 267, 268, 269, 270, 271, 272, -1, 274, -1, 276, + 277, 278, -1, -1, 281, 282, 283, 284, -1, -1, + 287, -1, 289, 290, 291, -1, 293, 294, -1, -1, + 297, 298, 299, -1, -1, 302, 303, -1, 305, 306, + 307, -1, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, + -1, 328, 329, 330, -1, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, + 347, -1, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, + -1, 368, 369, 370, 371, 372, 373, -1, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, -1, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, + 387, -1, 389, 390, 391, 392, 393, 394, 395, -1, + 397, 398, -1, 400, 401, 402, -1, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, - 427, 428, -1, 430, 431, 432, 433, 434, 435, -1, - 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, + 417, 418, 419, 420, 421, -1, -1, -1, 425, 426, + -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, + 437, -1, -1, -1, -1, 442, 443, -1, 445, -1, -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, -1, 462, 463, 464, 465, 466, - -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, - -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, -1, 3, 514, 5, -1, + -1, 458, 459, 460, 461, -1, 463, 464, 465, 466, + -1, 468, 469, 470, 471, 472, -1, -1, 475, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, + -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 508, 509, 510, 511, -1, -1, -1, -1, -1, + 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, + 33, 34, 529, -1, -1, 38, -1, -1, -1, -1, + 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, + 53, -1, -1, 56, -1, -1, -1, 60, 61, 62, + 63, 64, 65, -1, -1, 68, 69, 70, 71, -1, + -1, 74, -1, 76, 77, 78, 79, -1, -1, 82, + -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + -1, 114, 115, -1, 117, -1, 119, -1, 121, 122, + 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, + -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, + 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, + 153, -1, 155, 156, 157, 158, 159, 160, -1, -1, + 163, -1, 165, 166, -1, 168, -1, 170, -1, 172, + 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, + -1, -1, -1, 186, 187, -1, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, + 203, 204, 205, 206, 207, 208, -1, 210, 211, -1, + 213, 214, 215, 216, 217, -1, -1, -1, -1, -1, + 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, + 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + -1, 274, -1, 276, 277, 278, -1, -1, 281, 282, + 283, 284, -1, -1, 287, -1, 289, 290, 291, -1, + 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, + 303, -1, 305, 306, 307, -1, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, + -1, -1, 325, 326, -1, 328, 329, 330, -1, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, + 343, 344, 345, 346, 347, -1, 349, 350, 351, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, + 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, + 373, -1, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, -1, 389, 390, 391, 392, + 393, 394, 395, -1, 397, 398, -1, 400, 401, 402, + -1, 404, -1, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 421, -1, + -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, + 433, 434, 435, -1, 437, -1, -1, -1, -1, 442, + 443, -1, 445, -1, -1, 448, 449, 450, 451, 452, + 453, 454, 455, -1, -1, 458, 459, 460, 461, -1, + 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, + -1, -1, 475, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, + 493, 494, 495, 496, -1, -1, -1, -1, 3, -1, + -1, -1, -1, -1, -1, 508, 509, 510, 511, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, + 25, 26, 27, 28, 29, 30, 529, 32, 33, 34, + 35, 36, -1, 38, -1, -1, -1, -1, 43, 44, + 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, + 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, + -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, -1, -1, + 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, + 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, + 165, 166, 167, 168, -1, 170, -1, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, + 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, + 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, + 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, + -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, + -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, + -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, -1, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, 461, 462, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, + 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, + 485, -1, -1, 488, -1, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, -1, 3, 514, + 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 528, -1, -1, -1, -1, 23, 24, + 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, + -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, + 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, + 65, -1, 67, 68, 69, 70, 71, 72, 73, 74, + -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, -1, -1, + 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, + 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, + 165, 166, 167, 168, -1, 170, -1, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, + 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, + 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, + 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, + 235, -1, 237, 238, 239, 240, -1, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, + -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, + -1, 296, 297, 298, 299, -1, -1, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, -1, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, 388, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, -1, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, -1, 462, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, + 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, + 485, -1, -1, 488, -1, 490, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, -1, 3, 514, + 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 528, -1, -1, -1, -1, 23, 24, + 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, + -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, + 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, + 65, -1, 67, 68, 69, 70, 71, 72, 73, 74, + -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, + 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, + 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, + 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, + 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, + 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, + 205, 206, 207, 208, -1, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, + 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, + 235, -1, 237, 238, 239, 240, -1, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, -1, 281, 282, 283, 284, + -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, + -1, 296, 297, 298, 299, -1, -1, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, + 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, + 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, + 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 528, -1, -1, -1, -1, 23, 24, 25, 26, - 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, - -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, - 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, - -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, - 77, 78, 79, 80, -1, -1, -1, 84, 85, 86, - 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, - 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, - -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, - 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, - 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, -1, 174, -1, 176, - 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, - 187, -1, 189, 190, 191, 192, 193, 194, 195, -1, - 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, - 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, - 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, - -1, 228, 229, 230, -1, 232, 233, 234, -1, -1, - 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, - 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, - 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, - 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, - -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, -1, 325, 326, - 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, - 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, -1, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, - 427, 428, -1, 430, 431, 432, 433, 434, 435, -1, - 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, - -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, -1, 462, 463, 464, 465, 466, - -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, - -1, 488, -1, 490, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, -1, 3, 514, 5, -1, + -1, -1, -1, 528, -1, -1, -1, 23, 24, 25, + 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, + -1, -1, -1, -1, -1, -1, -1, 43, 44, 45, + -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, + -1, 67, 68, 69, 70, 71, 72, 73, 74, -1, + 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, + 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, + 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, + 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, + 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, + 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, + 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, + 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, + 206, 207, 208, -1, 210, 211, 212, 213, 214, 215, + 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, + 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, + -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, 279, -1, 281, 282, 283, 284, -1, + 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, + 296, 297, 298, 299, -1, -1, 302, 303, 304, 305, + 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, + 326, 327, 328, 329, 330, 331, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, + 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, + -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, + 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, + -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, + 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, + -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, + -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 528, -1, -1, -1, -1, 23, 24, 25, 26, + -1, -1, 528, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, - -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, + -1, -1, -1, -1, -1, -1, 43, 44, 45, -1, + 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, - -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, - 77, 78, 79, 80, -1, -1, -1, 84, 85, 86, - 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, - 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, + 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, + 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, + 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, + 97, 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, - 167, 168, -1, 170, -1, 172, -1, -1, -1, 176, - 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, - 187, -1, 189, 190, 191, 192, 193, 194, 195, -1, + 167, 168, -1, 170, -1, 172, 173, -1, 175, 176, + 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, + 187, -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, - 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, - 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, - -1, 228, 229, 230, -1, 232, 233, 234, -1, -1, - 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, + 207, 208, -1, 210, 211, 212, 213, 214, 215, 216, + 217, 218, 219, -1, 221, -1, 223, 224, 225, 226, + 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, - 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, + 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, + 277, 278, 279, -1, 281, 282, 283, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, - 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, - -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 297, 298, 299, -1, -1, 302, 303, 304, 305, 306, + 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, - 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 327, 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, + -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, - 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, + 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, - -1, 428, -1, 430, 431, 432, 433, 434, 435, -1, + -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, + 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 3, -1, 5, -1, -1, + 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 528, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, - 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, - 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, + -1, -1, -1, -1, -1, 43, 44, 45, -1, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, -1, -1, 61, 62, 63, 64, 65, -1, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, - 78, 79, 80, -1, -1, -1, 84, 85, 86, 87, - 88, 89, -1, 91, 92, 93, -1, 95, 96, 97, - 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, + 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, + 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, - 168, -1, 170, -1, 172, -1, -1, -1, 176, 177, - 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, - -1, 189, 190, 191, 192, 193, 194, 195, -1, 197, + 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, + 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, + -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, - 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, - 218, 219, -1, 221, -1, 223, -1, -1, 226, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, - -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, + 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, -1, 281, 282, 283, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, - 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, + 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, + 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, - 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, - 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, + 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, - 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, + 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, - -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, + 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, + 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 528, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, @@ -16178,6 +15910,159 @@ static const yytype_int16 yycheck[] = 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + 119, -1, 121, 122, 123, 124, 125, 126, 127, 128, + 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, + 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, + -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, + -1, 170, -1, 172, -1, 174, -1, 176, 177, 178, + -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, + 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, + 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, + -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, + 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, + 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, + 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, + 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, + 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, -1, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, + 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 399, -1, 401, 402, 403, 404, -1, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, 423, -1, 425, 426, 427, 428, + -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, + 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, + 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, + 459, 460, -1, 462, 463, 464, 465, 466, -1, 468, + 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, + 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, + -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, -1, 3, 514, 5, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 528, + -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, + 29, 30, 31, 32, 33, 34, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, + -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, + 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, + 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, + 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, + 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, + 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, + 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, + -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, + -1, 170, -1, 172, -1, 174, -1, 176, 177, 178, + -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, + 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, + 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, + -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, + 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, + 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, + 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, + 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, + 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, -1, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, + 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, -1, -1, 425, 426, 427, 428, + -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, + 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, + 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, + 459, 460, -1, 462, 463, 464, 465, 466, -1, 468, + 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, + 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, + -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, -1, 3, 514, 5, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 528, + -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, + 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, + -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, + 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, + 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, + 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, + 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, + 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, + 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, + -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, + -1, 170, -1, 172, -1, 174, -1, 176, 177, 178, + -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, + 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, + 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, + -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, + 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, + 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, + 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, + 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, + 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, 321, 322, 323, -1, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, + 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, + -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, -1, -1, 425, 426, 427, 428, + -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, + 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, + 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, + 459, 460, -1, 462, 463, 464, 465, 466, -1, 468, + 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, + 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, + -1, 490, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, -1, 3, 514, 5, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 528, + -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, + 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, + -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, + 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, + 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, + 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, + 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, @@ -16472,59 +16357,574 @@ static const yytype_int16 yycheck[] = 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, + 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 528, -1, -1, -1, 23, 24, + 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, + 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, + 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, + -1, 76, 77, 78, 79, 80, -1, -1, -1, 84, + 85, 86, 87, 88, 89, -1, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, + 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, + 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, + 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, + 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, + 165, 166, 167, 168, -1, 170, -1, 172, -1, -1, + -1, 176, 177, 178, -1, 180, 181, 182, -1, 184, + 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, + 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, + 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, + -1, 226, -1, 228, 229, 230, -1, 232, 233, 234, + -1, -1, 237, -1, 239, -1, -1, 242, 243, 244, + 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, + 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, + 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, + 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, + -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, + -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, + -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, + 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, + -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, + 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, + 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, + 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, + 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, + -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, + 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, + 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, + 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 3, -1, 5, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 528, -1, -1, -1, 23, 24, 25, + 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, + -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, + -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, + -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, + 76, 77, 78, 79, 80, -1, -1, -1, 84, 85, + 86, 87, 88, 89, -1, 91, 92, 93, -1, 95, + 96, 97, 98, 99, 100, -1, -1, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, + 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, + 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, + 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, + 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, + 166, 167, 168, -1, 170, -1, 172, -1, -1, -1, + 176, 177, 178, -1, 180, 181, 182, -1, 184, 185, + 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, + -1, 197, 198, 199, 200, -1, 202, 203, 204, 205, + 206, 207, 208, -1, 210, -1, 212, 213, 214, 215, + 216, 217, 218, 219, -1, 221, -1, 223, -1, -1, + 226, -1, 228, 229, 230, -1, 232, 233, 234, -1, + -1, 237, -1, 239, -1, -1, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, -1, 275, + 276, 277, 278, 279, -1, 281, 282, -1, 284, -1, + 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, + -1, 297, 298, 299, -1, -1, 302, 303, 304, -1, + 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, + 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, + 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, + 426, -1, 428, -1, 430, 431, 432, 433, 434, 435, + -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, + 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, + -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, + 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, + -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, + -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, + 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, + 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 528, -1, -1, -1, 23, 24, 25, 26, + 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, + -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, + 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, + -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, + 77, 78, 79, 80, -1, -1, -1, 84, 85, 86, + 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, + 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, + 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, + 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, + -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, + 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, + 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, + 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, + 167, 168, -1, 170, -1, 172, -1, -1, -1, 176, + 177, 178, -1, 180, 181, 182, -1, 184, 185, 186, + 187, -1, 189, 190, 191, 192, 193, 194, 195, -1, + 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, + 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, + 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, + -1, 228, 229, 230, -1, 232, 233, 234, -1, -1, + 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, + 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, + 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, + 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, + 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, + 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, + 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, + -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, + 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, + 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, + 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, + 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, + 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, + -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, + 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, + 387, -1, -1, 390, 391, 392, 393, 394, 395, 396, + 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, + 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, + 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, + -1, 428, -1, 430, 431, 432, 433, 434, 435, -1, + 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, + -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, + -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, + -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, + 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, + -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, + 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, + 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, + -1, -1, -1, -1, 521, -1, -1, -1, -1, -1, + -1, 528, -1, -1, -1, 23, 24, 25, 26, 27, + 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, + 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, + 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, + 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, + 78, 79, 80, -1, -1, -1, 84, 85, 86, 87, + 88, 89, -1, 91, 92, 93, -1, 95, 96, 97, + 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, + 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, + -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, + -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, + 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, + 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, + 168, -1, 170, -1, 172, -1, -1, -1, 176, 177, + 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, + -1, 189, 190, 191, 192, 193, 194, 195, -1, 197, + 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, + 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, + 218, 219, -1, 221, -1, 223, -1, -1, 226, -1, + 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, + -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, + 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, + 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, + 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, + 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, + 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, + 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, + 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, + 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, + -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, + 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, + 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, + 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, + -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, + 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, + 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, + 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, + 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, + 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, + 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, + 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, + 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, + -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, + 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, + 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, + 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 528, -1, -1, -1, 23, 24, - 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, - 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, - 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, - 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, - -1, 76, 77, 78, 79, 80, -1, -1, -1, 84, - 85, 86, 87, 88, 89, -1, 91, 92, 93, -1, - 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, + 528, -1, -1, -1, 23, 24, 25, 26, 27, 28, + 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, + -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, + 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, + 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, + 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, + 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, + 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, + 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, + 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, + 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, + -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, + -1, 170, -1, 172, -1, -1, -1, 176, 177, 178, + -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, + 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, + 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, + -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, + 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, + 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, + 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, + 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, + 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, + 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, + 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, + 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, + 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, + 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, + 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, + 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, + 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, + 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, + -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, + 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, + 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, + -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, + 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, + 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, + 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, + 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, + 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, + -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 3, 4, 5, -1, -1, 8, 9, + -1, -1, -1, -1, -1, 15, 16, -1, -1, 528, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, 52, 53, -1, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, + 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + -1, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, + 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, + 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, + 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, -1, 155, 156, 157, 158, 159, + 160, -1, 162, 163, 164, 165, 166, 167, 168, 169, + 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, -1, -1, 186, 187, 188, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, + 210, 211, -1, 213, 214, 215, 216, 217, 218, 219, + 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, + 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, + 280, 281, 282, 283, 284, 285, -1, 287, 288, 289, + 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, + 300, 301, 302, 303, -1, 305, 306, 307, -1, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, 321, 322, 323, 324, 325, 326, -1, 328, 329, + 330, -1, 332, 333, 334, 335, 336, 337, 338, 339, + 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, + 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, + 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, + 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, -1, 423, 424, 425, 426, 427, 428, 429, + 430, 431, 432, 433, 434, 435, 436, 437, 438, 439, + 440, 441, 442, 443, -1, 445, -1, 447, 448, 449, + 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, + 460, 461, 462, 463, 464, 465, 466, 467, 468, 469, + 470, 471, 472, -1, 474, 475, 476, 477, 478, 479, + 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, + 490, 491, 492, 493, 494, 495, 496, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 508, 509, + 510, 511, -1, 3, -1, 515, 516, 517, 8, 519, + 520, 521, 522, 523, 524, 15, 16, -1, -1, -1, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, + -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, + -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, + 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, + 80, -1, -1, -1, 84, 85, 86, 87, 88, 89, + -1, 91, 92, 93, -1, 95, 96, 97, 98, 99, + 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, + -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, + 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, + -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, -1, 163, -1, 165, 166, 167, 168, -1, + 170, -1, 172, -1, -1, -1, 176, 177, 178, -1, + 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, + 190, 191, 192, 193, 194, 195, -1, 197, 198, 199, + 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, + 210, -1, 212, 213, 214, 215, 216, 217, 218, 219, + -1, 221, -1, 223, -1, -1, 226, -1, 228, 229, + 230, -1, 232, 233, 234, -1, -1, 237, -1, 239, + -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, -1, 275, 276, 277, 278, 279, + -1, 281, 282, -1, 284, -1, 286, 287, 288, 289, + 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, + -1, -1, 302, 303, 304, -1, 306, -1, 308, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, -1, -1, -1, -1, 325, 326, 327, -1, 329, + 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, + -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, + 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, + -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, 422, -1, -1, 425, 426, -1, 428, -1, + 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, + -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, + 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, + 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, + 470, 471, 472, 473, 474, 475, -1, 477, -1, 479, + 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, + -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, + 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, + 510, 511, -1, -1, -1, 515, 516, 517, -1, 519, + 520, 521, 522, 523, 524, 8, -1, -1, 11, -1, + -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, + -1, -1, -1, 8, -1, -1, 11, -1, -1, -1, + 15, 16, 17, 18, 37, 20, 21, 22, -1, -1, + -1, -1, -1, -1, 47, -1, -1, -1, -1, -1, + -1, 54, 37, -1, -1, -1, -1, -1, 8, -1, + -1, 11, 47, -1, -1, 15, 16, 17, 18, 54, + 20, 21, 22, -1, -1, -1, 8, -1, 81, 11, + -1, -1, -1, 15, 16, 17, 18, 37, 20, 21, + 22, -1, -1, -1, -1, -1, 81, 47, -1, -1, + -1, -1, -1, -1, 54, 37, -1, -1, -1, -1, + -1, 8, -1, -1, 11, 47, -1, -1, 15, 16, + 17, 18, 54, 20, 21, 22, -1, -1, -1, -1, + -1, 81, -1, -1, -1, -1, -1, -1, -1, -1, + 37, -1, -1, -1, -1, -1, -1, -1, -1, 81, + 47, -1, -1, 8, -1, -1, 11, 54, -1, -1, + 15, 16, 17, 18, -1, 20, 21, 22, -1, -1, + -1, -1, -1, -1, -1, -1, 179, -1, -1, -1, + -1, -1, 37, -1, 81, -1, -1, -1, -1, -1, + -1, -1, 47, 196, 179, -1, -1, -1, 201, 54, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 196, -1, -1, -1, -1, 201, -1, -1, -1, + -1, 224, 225, -1, -1, -1, 81, -1, -1, 179, + -1, -1, -1, -1, -1, -1, -1, 240, -1, 224, + 225, -1, -1, -1, -1, -1, 196, 179, -1, -1, + -1, 201, -1, -1, -1, 240, -1, -1, -1, -1, + -1, -1, -1, -1, 196, -1, -1, -1, -1, 201, + -1, -1, -1, -1, 224, 225, -1, 280, -1, -1, + 283, -1, 179, -1, -1, -1, -1, -1, -1, -1, + 240, -1, 224, 225, 297, 280, -1, 300, 283, 196, + -1, -1, -1, -1, 201, -1, -1, -1, 240, -1, + -1, -1, 297, -1, -1, 300, -1, -1, -1, -1, + -1, -1, -1, -1, 179, -1, -1, 224, 225, -1, + 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, + -1, 196, -1, 240, -1, -1, 201, 297, 280, -1, + 300, 283, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 297, -1, -1, 300, 224, + 225, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 280, -1, 240, 283, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 400, -1, -1, + 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 400, -1, -1, -1, -1, + -1, -1, -1, 8, -1, 280, 11, -1, 283, -1, + 15, 16, 17, 18, -1, 20, 21, 22, -1, -1, + -1, -1, 297, -1, -1, 300, -1, -1, -1, -1, + 400, -1, 37, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 47, -1, -1, -1, -1, -1, 400, 54, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, + -1, -1, -1, 400, -1, -1, -1, -1, -1, 512, + -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, + 523, 524, -1, -1, -1, -1, 529, 512, -1, -1, + 515, 516, 517, -1, 519, 520, 521, 522, 523, 524, + -1, -1, -1, -1, 529, 400, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 512, -1, -1, 515, 516, 517, -1, 519, + 520, 521, 522, 523, 524, -1, -1, -1, -1, 529, + 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, + 522, 523, 524, -1, 179, -1, -1, 529, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 196, -1, -1, -1, 512, 201, -1, 515, 516, + 517, -1, 519, 520, 521, 522, 523, 524, -1, -1, + -1, -1, 529, -1, 8, -1, -1, 11, -1, 224, + 225, 15, 16, 17, 18, -1, 20, 21, 22, -1, + -1, -1, -1, -1, -1, 240, -1, 512, -1, -1, + 515, 516, 517, 37, 519, 520, 521, 522, 523, 524, + -1, -1, -1, 47, 529, 8, -1, -1, 11, -1, + 54, -1, 15, 16, 17, 18, -1, 20, 21, 22, + -1, -1, -1, -1, -1, 280, -1, -1, 283, -1, + -1, -1, -1, -1, 37, -1, -1, 81, -1, -1, + -1, -1, 297, -1, 47, 300, -1, -1, -1, -1, + -1, 54, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, 17, 18, -1, 20, 21, 22, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, + -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 47, -1, -1, -1, -1, -1, -1, + 54, -1, 8, -1, -1, 11, -1, -1, -1, 15, + 16, 17, 18, -1, 20, 21, 22, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, + -1, 37, -1, -1, -1, 179, -1, -1, -1, -1, + -1, 47, -1, -1, -1, 400, -1, -1, 54, -1, + -1, -1, 196, -1, -1, -1, 8, 201, -1, 11, + -1, -1, -1, 15, 16, 17, 18, -1, 20, 21, + 22, -1, -1, -1, -1, 81, 179, -1, -1, -1, + 224, 225, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, -1, 196, -1, 47, 240, -1, 201, -1, + -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 224, 225, -1, -1, 179, -1, -1, -1, 81, + -1, -1, -1, -1, -1, -1, 280, 240, -1, 283, + -1, -1, 196, -1, -1, -1, -1, 201, -1, -1, + -1, -1, -1, 297, -1, -1, 300, 512, -1, -1, + 515, 516, 517, -1, 519, 520, 521, 522, 523, 524, + 224, 225, -1, 179, 529, -1, -1, 280, -1, -1, + 283, -1, -1, -1, -1, -1, 240, -1, -1, -1, + 196, -1, -1, -1, 297, 201, -1, 300, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 224, 225, + -1, -1, -1, -1, -1, -1, 280, 179, -1, 283, + -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, + -1, -1, -1, 297, 196, -1, 300, -1, -1, 201, + -1, -1, -1, -1, -1, -1, 400, 8, -1, -1, + 11, -1, -1, -1, 15, 16, 17, 18, -1, 20, + 21, 22, 224, 225, 280, -1, -1, 283, -1, -1, + -1, -1, -1, -1, -1, -1, 37, -1, 240, -1, + -1, 297, -1, -1, 300, -1, 47, 400, -1, -1, + -1, -1, -1, 54, -1, -1, -1, -1, 8, -1, + -1, 11, -1, -1, -1, 15, 16, 17, 18, -1, + 20, 21, 22, -1, -1, -1, -1, -1, 280, -1, + 81, 283, -1, -1, -1, -1, -1, 37, -1, -1, + -1, -1, -1, -1, -1, 297, 400, 47, 300, -1, + -1, -1, -1, -1, 54, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 512, -1, + -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, + 524, 81, -1, -1, -1, 529, -1, -1, -1, -1, + -1, -1, -1, -1, 400, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 512, + -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, + 523, 524, -1, -1, -1, -1, 529, -1, 179, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 196, -1, -1, 400, -1, + 201, -1, -1, -1, -1, -1, -1, -1, 512, -1, + -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, + 524, -1, -1, 224, 225, 529, -1, -1, -1, 179, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, + -1, -1, -1, -1, -1, -1, 196, -1, -1, -1, + -1, 201, -1, -1, -1, -1, 512, -1, -1, 515, + 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, + -1, 527, -1, -1, 224, 225, -1, -1, -1, 280, + -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, + 240, -1, -1, -1, -1, -1, 297, -1, -1, 300, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, + 522, 523, 524, -1, -1, 527, -1, -1, -1, -1, + 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 297, -1, -1, + 300, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, + 521, 522, 523, 524, -1, -1, 527, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, + -1, -1, 512, -1, -1, 515, 516, 517, -1, 519, + 520, 521, 522, 523, 524, -1, -1, 527, 23, 24, + 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, + 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, - 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, - 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, - 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, - 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, -1, -1, - -1, 176, 177, 178, -1, 180, 181, 182, -1, 184, - 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, - 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, - 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, - 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, - -1, 226, -1, 228, 229, 230, -1, 232, 233, 234, - -1, -1, 237, -1, 239, -1, -1, 242, 243, 244, + 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, + 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, + 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, + 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, + 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, + 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, + 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, + 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, + 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, + 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, - 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, - -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, - -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, - -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, - 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, + 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, + 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, + 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, + 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, + 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, + 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, + 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, + 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, + 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, + 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, - -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, - 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, - 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, - 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, - 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, - 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, - 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, + 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, + 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, + 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, + 415, 416, 417, 418, 419, 420, 421, 422, 423, 424, + 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, + 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, + 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, + 455, 456, 457, 458, 459, 460, 461, 462, 463, 464, + 465, 466, 467, 468, 469, 470, 471, 472, 473, 474, + 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, + 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, 521, -1, -1, -1, - -1, -1, -1, 528, -1, -1, -1, 23, 24, 25, + -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, @@ -16574,8 +16974,8 @@ static const yytype_int16 yycheck[] = -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 528, -1, -1, -1, 23, 24, 25, 26, + -1, -1, -1, -1, -1, 521, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, @@ -16617,631 +17017,275 @@ static const yytype_int16 yycheck[] = 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, 435, -1, - 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, - -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, - -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, - -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, - 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, - -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, - 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 3, 4, 5, -1, -1, - 8, 9, -1, -1, -1, -1, -1, 15, 16, -1, - -1, 528, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, - 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, - 48, 49, 50, 51, 52, 53, -1, 55, 56, 57, - 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, - 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, - 78, 79, -1, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, - 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, - 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, - 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, - 148, 149, 150, 151, 152, 153, -1, 155, 156, 157, - 158, 159, 160, -1, 162, 163, 164, 165, 166, 167, - 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, - 178, 179, 180, 181, 182, 183, -1, -1, 186, 187, - 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, - 208, 209, 210, 211, -1, 213, 214, 215, 216, 217, - 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, - 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, - 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, 280, 281, 282, 283, 284, 285, -1, 287, - 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, - 298, 299, 300, 301, 302, 303, -1, 305, 306, 307, - -1, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, 321, 322, 323, 324, 325, 326, -1, - 328, 329, 330, -1, 332, 333, 334, 335, 336, 337, - 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, - 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, -1, 423, 424, 425, 426, 427, - 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, - 438, 439, 440, 441, 442, 443, -1, 445, -1, 447, - 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, - 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, - 468, 469, 470, 471, 472, -1, 474, 475, 476, 477, - 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, - 488, 489, 490, 491, 492, 493, 494, 495, 496, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 508, 509, 510, 511, -1, 3, -1, 515, 516, 517, - 8, 519, 520, 521, 522, 523, 524, 15, 16, -1, - -1, -1, 20, 21, 22, 23, 24, 25, 26, 27, - 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, - 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, - 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, - 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, - 78, 79, 80, -1, -1, -1, 84, 85, 86, 87, - 88, 89, -1, 91, 92, 93, -1, 95, 96, 97, - 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, - -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, - 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, - 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, - 168, -1, 170, -1, 172, -1, -1, -1, 176, 177, - 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, - -1, 189, 190, 191, 192, 193, 194, 195, -1, 197, - 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, - 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, - 218, 219, -1, 221, -1, 223, -1, -1, 226, -1, - 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, - -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, - 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, - 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, - 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, - 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, - 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, - 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, - 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, - 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, - 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, - -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, - 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, -1, -1, -1, 515, 516, 517, - -1, 519, 520, 521, 522, 523, 524, 8, -1, -1, - 11, -1, -1, -1, 15, 16, 17, 18, -1, 20, - 21, 22, -1, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, 37, 20, 21, 22, - -1, -1, -1, -1, -1, -1, 47, -1, -1, -1, - -1, -1, -1, 54, 37, -1, -1, -1, -1, -1, - 8, -1, -1, 11, 47, -1, -1, 15, 16, 17, - 18, 54, 20, 21, 22, -1, -1, -1, 8, -1, - 81, 11, -1, -1, -1, 15, 16, 17, 18, 37, - 20, 21, 22, -1, -1, -1, -1, -1, 81, 47, - -1, -1, -1, -1, -1, -1, 54, 37, -1, -1, - -1, -1, -1, 8, -1, -1, 11, 47, -1, -1, - 15, 16, 17, 18, 54, 20, 21, 22, -1, -1, - -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, - -1, -1, 37, -1, -1, -1, -1, -1, -1, -1, - -1, 81, 47, -1, -1, 8, -1, -1, 11, 54, - -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, - -1, -1, -1, -1, -1, -1, -1, -1, 179, -1, - -1, -1, -1, -1, 37, -1, 81, -1, -1, -1, - -1, -1, -1, -1, 47, 196, 179, -1, -1, -1, - 201, 54, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 196, -1, -1, -1, -1, 201, -1, - -1, -1, -1, 224, 225, -1, -1, -1, 81, -1, - -1, 179, -1, -1, -1, -1, -1, -1, -1, 240, - -1, 224, 225, -1, -1, -1, -1, -1, 196, 179, - -1, -1, -1, 201, -1, -1, -1, 240, -1, -1, - -1, -1, -1, -1, -1, -1, 196, -1, -1, -1, - -1, 201, -1, -1, -1, -1, 224, 225, -1, 280, - -1, -1, 283, -1, 179, -1, -1, -1, -1, -1, - -1, -1, 240, -1, 224, 225, 297, 280, -1, 300, - 283, 196, -1, -1, -1, -1, 201, -1, -1, -1, - 240, -1, -1, -1, 297, -1, -1, 300, -1, -1, - -1, -1, -1, -1, -1, -1, 179, -1, -1, 224, - 225, -1, 280, -1, -1, 283, -1, -1, -1, -1, - -1, -1, -1, 196, -1, 240, -1, -1, 201, 297, - 280, -1, 300, 283, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 297, -1, -1, - 300, 224, 225, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 280, -1, 240, 283, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, - -1, -1, 297, -1, -1, 300, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 400, -1, -1, - -1, -1, -1, -1, -1, 8, -1, 280, 11, -1, - 283, -1, 15, 16, 17, 18, -1, 20, 21, 22, - -1, -1, -1, -1, 297, -1, -1, 300, -1, -1, - -1, -1, 400, -1, 37, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 47, -1, -1, -1, -1, -1, - 400, 54, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, - -1, -1, -1, -1, -1, 400, -1, -1, -1, -1, - -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, - 521, 522, 523, 524, -1, -1, -1, -1, 529, 512, - -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, - 523, 524, -1, -1, -1, -1, 529, 400, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 512, -1, -1, 515, 516, 517, - -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, - -1, 529, 512, -1, -1, 515, 516, 517, -1, 519, - 520, 521, 522, 523, 524, -1, 179, -1, -1, 529, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 196, -1, -1, -1, 512, 201, -1, - 515, 516, 517, -1, 519, 520, 521, 522, 523, 524, - -1, -1, -1, -1, 529, -1, 8, -1, -1, 11, - -1, 224, 225, 15, 16, 17, 18, -1, 20, 21, - 22, -1, -1, -1, -1, -1, -1, 240, -1, 512, - -1, -1, 515, 516, 517, 37, 519, 520, 521, 522, - 523, 524, -1, -1, 527, 47, -1, -1, -1, -1, - -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 280, -1, -1, - 283, -1, -1, -1, -1, -1, -1, -1, -1, 81, - -1, -1, -1, -1, 297, -1, -1, 300, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 179, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 400, -1, -1, - -1, -1, -1, -1, 196, -1, -1, -1, -1, 201, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 224, 225, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 280, -1, - -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 297, -1, -1, 300, 512, - -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, - 523, 524, -1, -1, 527, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 400, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 3, -1, -1, -1, - 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, - 522, 523, 524, -1, -1, 527, 23, 24, 25, 26, - 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, - 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, - 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, - 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, - 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, - 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, - 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, - 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, - 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, - 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, - 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, - 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, - 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, - 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, - 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, - 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, - 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, - 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, - 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, - 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, - 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, - 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, - 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, - 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, - 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, - 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, - 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, - 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, - 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, - 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, - 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, - 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, - 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, - 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, - 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, - 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, - 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, - 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, - 417, 418, 419, 420, 421, 422, 423, 424, 425, 426, - 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, - 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, - 447, 448, 449, 450, 451, 452, 453, 454, 455, 456, - 457, 458, 459, 460, 461, 462, 463, 464, 465, 466, - 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, - 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, - 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, + 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, + -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, + -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, + -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, + 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, + -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, - -1, -1, -1, -1, 521, -1, -1, -1, -1, -1, + 507, 508, 509, 510, 511, 3, 4, 5, -1, -1, + -1, 9, -1, -1, 521, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, - 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, - 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, + 38, -1, -1, -1, -1, 43, 44, 45, -1, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, + 58, -1, 60, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, - 78, 79, 80, -1, -1, -1, 84, 85, 86, 87, - 88, 89, -1, 91, 92, 93, -1, 95, 96, 97, - 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, + 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, + 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, - 168, -1, 170, -1, 172, -1, -1, -1, 176, 177, - 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, - -1, 189, 190, 191, 192, 193, 194, 195, -1, 197, + 158, 159, 160, 161, 162, 163, -1, 165, 166, 167, + 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, + 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, + -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, - 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, - 218, 219, -1, 221, -1, 223, -1, -1, 226, -1, + 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, - -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, + 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, - 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, - 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, + 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, + 278, 279, -1, 281, 282, 283, 284, -1, 286, 287, + 288, 289, 290, 291, -1, 293, 294, 295, -1, 297, + 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, + 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, - 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, + 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, - 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, + -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, - 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, - 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, + 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, + 438, 439, -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, - 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, + 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, - -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, + 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, - -1, -1, -1, 521, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, - 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, - -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, - 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, - 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, - 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, - 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, - 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, - 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, - 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, - -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, - -1, 170, -1, 172, -1, -1, -1, 176, 177, 178, - -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, - 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, - 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, - -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, - 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, - 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, - 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, - 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, - 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, - 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, - 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, - 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, - 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, - -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, - -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, - -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, - 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, - 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, - 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, - -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 3, 4, 5, -1, -1, -1, 9, - -1, -1, 521, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, - 30, -1, 32, 33, 34, -1, -1, -1, 38, -1, - -1, -1, -1, 43, 44, 45, -1, 47, 48, 49, - 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, - 60, 61, 62, 63, 64, 65, -1, -1, 68, 69, - 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, - 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, - 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, - 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, - 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, - -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, - 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, - -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, - 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, - 160, 161, 162, 163, -1, 165, 166, 167, 168, -1, - 170, -1, 172, 173, -1, 175, 176, 177, 178, 179, - 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, - 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, - 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, - 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, - -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, - 230, -1, 232, 233, 234, -1, -1, 237, 238, 239, - 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, - 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, - 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, - 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, - -1, 281, 282, 283, 284, -1, 286, 287, 288, 289, - 290, 291, -1, 293, 294, 295, -1, 297, 298, 299, - -1, -1, 302, 303, 304, 305, 306, 307, 308, 309, - 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, - 320, -1, -1, -1, -1, 325, 326, 327, 328, 329, - 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, - 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, - 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, - 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, - 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, - 380, 381, 382, 383, 384, 385, 386, 387, -1, 389, - 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, - 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, - 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, - 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, - 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, - -1, -1, 442, 443, 444, 445, 446, 447, 448, 449, - 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, - 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, - 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, - 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, - -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, - 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, -1, -1, 8, -1, -1, 11, -1, 519, - 520, 15, 16, 17, 18, -1, 20, 21, 22, -1, - -1, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, 37, 20, 21, 22, -1, 42, -1, - -1, -1, -1, 47, -1, -1, -1, -1, -1, -1, - 54, 37, -1, -1, -1, -1, -1, 8, -1, -1, - 11, 47, -1, -1, 15, 16, 17, 18, 54, 20, - 21, 22, -1, -1, -1, 8, -1, 81, 11, -1, - -1, -1, 15, 16, 17, 18, 37, 20, 21, 22, - -1, -1, -1, -1, -1, 81, 47, -1, -1, -1, - -1, -1, -1, 54, 37, -1, -1, -1, 41, -1, - -1, -1, -1, -1, 47, -1, -1, -1, -1, -1, - -1, 54, -1, 127, -1, -1, -1, -1, -1, -1, - 81, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, - -1, -1, 8, -1, -1, 11, -1, -1, -1, 15, - 16, 17, 18, -1, 20, 21, 22, -1, -1, -1, - -1, -1, -1, -1, -1, 179, -1, -1, -1, -1, - -1, 37, -1, 169, -1, -1, -1, -1, 174, -1, - -1, 47, 196, 179, -1, -1, -1, 201, 54, -1, + 508, 509, 510, 511, -1, -1, 8, -1, -1, 11, + -1, 519, 520, 15, 16, 17, 18, -1, 20, 21, + 22, -1, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, 17, 18, 37, 20, 21, 22, -1, + 42, -1, -1, -1, -1, 47, -1, -1, -1, -1, + -1, -1, 54, 37, -1, -1, -1, -1, -1, 8, + -1, -1, 11, 47, -1, -1, 15, 16, 17, 18, + 54, 20, 21, 22, -1, -1, -1, 8, -1, 81, + 11, -1, -1, -1, 15, 16, 17, 18, 37, 20, + 21, 22, -1, -1, -1, -1, -1, 81, 47, -1, + -1, -1, -1, -1, -1, 54, 37, -1, -1, -1, + 41, -1, -1, -1, -1, -1, 47, -1, -1, -1, + -1, -1, -1, 54, -1, 127, -1, -1, -1, -1, + -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 196, -1, -1, -1, -1, 201, -1, 168, -1, -1, - 224, 225, -1, -1, -1, 81, -1, -1, 179, -1, - -1, -1, -1, -1, -1, -1, 240, -1, 224, 225, - -1, -1, -1, -1, -1, 196, 179, -1, -1, -1, - 201, -1, -1, -1, 240, -1, -1, -1, -1, -1, - -1, -1, -1, 196, -1, -1, -1, -1, 201, -1, - -1, -1, -1, 224, 225, -1, 280, -1, -1, 283, + 81, -1, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, 17, 18, -1, 20, 21, 22, -1, + -1, -1, -1, -1, -1, -1, -1, 179, -1, -1, + -1, -1, -1, 37, -1, 169, -1, -1, -1, -1, + 174, -1, -1, 47, 196, 179, -1, -1, -1, 201, + 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 196, -1, -1, -1, -1, 201, -1, 168, + -1, -1, 224, 225, -1, -1, -1, 81, -1, -1, + 179, -1, -1, -1, -1, -1, -1, -1, 240, -1, + 224, 225, -1, -1, -1, -1, -1, 196, 179, -1, + -1, -1, 201, -1, -1, -1, 240, -1, -1, -1, + -1, -1, -1, -1, -1, 196, -1, -1, -1, -1, + 201, -1, -1, -1, -1, 224, 225, -1, 280, -1, + -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 240, -1, 224, 225, 297, 280, -1, 300, 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, - -1, 224, 225, 297, 280, -1, 300, 283, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, - -1, 297, -1, -1, 300, -1, -1, -1, -1, -1, - -1, -1, -1, 179, -1, -1, -1, -1, -1, 280, - -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, - 196, -1, -1, -1, -1, 201, 297, 280, -1, 300, - 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 297, -1, -1, 300, 224, 225, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 330, - -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 400, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 8, - -1, -1, 11, -1, 400, -1, 15, 16, 17, 18, - -1, 20, 21, 22, 280, -1, -1, 283, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 37, -1, - -1, 297, 41, -1, 300, -1, -1, -1, 47, 400, - -1, -1, -1, -1, -1, 54, -1, -1, -1, -1, - -1, -1, -1, 467, -1, -1, -1, 400, 324, -1, + -1, -1, -1, 297, -1, -1, 300, -1, -1, -1, + -1, -1, -1, -1, -1, 179, -1, -1, -1, -1, + -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, + -1, -1, 196, -1, -1, -1, -1, 201, 297, 280, + -1, 300, 283, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 297, -1, -1, 300, + 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 330, -1, -1, -1, -1, 240, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, + -1, 8, -1, -1, 11, -1, 400, -1, 15, 16, + 17, 18, -1, 20, 21, 22, 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 37, -1, -1, 297, 41, -1, 300, -1, -1, -1, + 47, 400, -1, -1, -1, -1, -1, 54, -1, -1, + -1, -1, -1, -1, -1, 467, -1, -1, -1, 400, + 324, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, + 522, 523, 524, -1, -1, -1, -1, -1, 512, -1, + -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, + 524, -1, -1, -1, -1, -1, 400, -1, 8, -1, + -1, 11, -1, -1, -1, 15, 16, 17, 18, -1, + 20, 21, 22, 512, -1, -1, 515, 516, 517, -1, + 519, 520, 521, 522, 523, 524, -1, 37, -1, -1, + -1, 512, 179, -1, 515, 516, 517, 47, 519, 520, + 521, 522, 523, 524, 54, -1, -1, -1, -1, 196, + 8, -1, -1, 11, 201, -1, -1, 15, 16, 17, + 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, + -1, 81, -1, -1, -1, -1, -1, 224, 225, 37, + -1, -1, -1, 41, -1, -1, -1, -1, -1, 47, + -1, -1, -1, 240, -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, - 524, -1, -1, -1, -1, -1, 512, -1, -1, 515, - 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, - -1, -1, -1, -1, 400, -1, 8, -1, -1, 11, - -1, -1, -1, 15, 16, 17, 18, -1, 20, 21, - 22, 512, -1, -1, 515, 516, 517, -1, 519, 520, - 521, 522, 523, 524, -1, 37, -1, -1, -1, 512, - 179, -1, 515, 516, 517, 47, 519, 520, 521, 522, - 523, 524, 54, -1, -1, -1, -1, 196, 8, -1, - -1, 11, 201, -1, -1, 15, 16, 17, 18, -1, - 20, 21, 22, -1, -1, -1, -1, -1, -1, 81, - -1, -1, -1, -1, -1, 224, 225, 37, -1, -1, - -1, 41, -1, -1, -1, -1, -1, 47, -1, -1, - -1, 240, -1, -1, 54, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 512, -1, -1, 515, - 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, - -1, 81, -1, -1, -1, -1, -1, -1, -1, 8, - -1, 280, 11, -1, 283, -1, 15, 16, 17, 18, - -1, 20, 21, 22, -1, -1, -1, -1, 297, -1, - -1, 300, -1, -1, -1, -1, -1, -1, 37, -1, - -1, -1, 174, -1, -1, -1, -1, 179, 47, -1, - -1, -1, -1, -1, -1, 54, -1, -1, -1, -1, - -1, -1, -1, -1, 196, -1, -1, -1, -1, 201, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 224, 225, -1, -1, -1, -1, -1, 179, - -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, + 524, -1, -1, 81, -1, -1, -1, -1, -1, -1, + -1, 8, -1, 280, 11, -1, 283, -1, 15, 16, + 17, 18, -1, 20, 21, 22, -1, -1, -1, -1, + 297, -1, -1, 300, -1, -1, -1, -1, -1, -1, + 37, -1, -1, -1, 174, -1, -1, -1, -1, 179, + 47, -1, -1, -1, -1, -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, 196, -1, -1, -1, -1, 201, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 224, 225, -1, -1, 280, -1, - -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, - 240, -1, -1, -1, -1, 297, -1, -1, 300, -1, - 169, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 179, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 196, -1, -1, - 280, -1, 201, 283, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 297, -1, -1, - 300, -1, -1, -1, -1, 224, 225, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 240, -1, 512, -1, -1, 515, 516, 517, -1, - 519, 520, 521, 522, 523, 524, -1, -1, -1, -1, - -1, -1, -1, 8, -1, -1, 11, -1, 400, -1, - 15, 16, 17, 18, 19, 20, 21, 22, -1, -1, - -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, - -1, -1, 37, -1, -1, -1, -1, -1, 297, -1, - -1, 300, 47, -1, -1, -1, -1, -1, -1, 54, + -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 224, 225, -1, -1, -1, -1, + -1, 179, -1, -1, -1, -1, -1, -1, -1, -1, + 240, -1, -1, -1, -1, -1, -1, -1, 196, -1, + -1, -1, -1, 201, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 400, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 224, 225, -1, -1, + 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, + -1, -1, 240, -1, -1, -1, -1, 297, -1, -1, + 300, -1, 169, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 179, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 196, + -1, -1, 280, -1, 201, 283, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 297, + -1, -1, 300, -1, -1, -1, -1, 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, - 8, -1, -1, 11, -1, -1, -1, 15, 16, 17, - 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 37, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 47, - 512, -1, -1, 515, 516, 517, 54, 519, 520, 521, - 522, 523, 524, -1, -1, -1, -1, -1, -1, -1, - -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 240, -1, 512, -1, -1, 515, 516, + 517, -1, 519, 520, 521, 522, 523, 524, -1, -1, + -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, + 400, -1, 15, 16, 17, 18, 19, 20, 21, 22, + -1, -1, -1, 280, -1, -1, 283, -1, -1, -1, + -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, + 297, -1, -1, 300, 47, -1, -1, -1, -1, -1, + -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 400, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 81, -1, + -1, -1, 8, -1, -1, 11, -1, -1, -1, 15, + 16, 17, 18, -1, 20, 21, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 512, -1, 179, 515, 516, 517, -1, 519, + -1, 37, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 47, 512, -1, -1, 515, 516, 517, 54, 519, 520, 521, 522, 523, 524, -1, -1, -1, -1, -1, - -1, 196, -1, -1, 8, -1, 201, 11, -1, -1, - -1, 15, 16, 17, 18, -1, 20, 21, 22, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 224, - 225, -1, -1, 37, -1, -1, -1, 41, -1, -1, - -1, -1, -1, 47, -1, 240, -1, -1, -1, -1, - 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 179, -1, 512, -1, -1, 515, 516, 517, -1, - 519, 520, 521, 522, 523, 524, -1, 81, 196, -1, - -1, -1, -1, 201, 8, 280, -1, 11, 283, -1, - -1, 15, 16, 17, 18, -1, 20, 21, 22, -1, - -1, -1, 297, -1, -1, 300, 224, 225, -1, -1, - -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, - -1, -1, 240, 47, -1, -1, -1, -1, -1, -1, - 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, - -1, -1, 280, -1, -1, 283, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 179, -1, -1, -1, 297, - -1, -1, 300, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 196, -1, -1, -1, -1, 201, -1, -1, - -1, -1, -1, -1, -1, 400, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, + -1, -1, -1, 400, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 179, -1, -1, -1, -1, + -1, -1, -1, -1, 512, -1, 179, 515, 516, 517, + -1, 519, 520, 521, 522, 523, 524, -1, -1, -1, + -1, -1, -1, 196, -1, -1, 8, -1, 201, 11, + -1, -1, -1, 15, 16, 17, 18, -1, 20, 21, + 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 224, 225, -1, -1, 37, -1, -1, -1, 41, + -1, -1, -1, -1, -1, 47, -1, 240, -1, -1, + -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 179, -1, 512, -1, -1, 515, 516, + 517, -1, 519, 520, 521, 522, 523, 524, -1, 81, + 196, -1, -1, -1, -1, 201, 8, 280, -1, 11, + 283, -1, -1, 15, 16, 17, 18, -1, 20, 21, + 22, -1, -1, -1, 297, -1, -1, 300, 224, 225, + -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, + -1, -1, -1, -1, 240, 47, -1, -1, -1, -1, + -1, -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 196, -1, -1, -1, 280, 201, -1, 283, - -1, -1, 400, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 297, -1, -1, 300, -1, -1, -1, - 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 240, 512, 436, -1, - 515, 516, 517, -1, 519, 520, 521, 522, 523, 524, - -1, -1, -1, -1, -1, 8, -1, -1, 11, -1, - -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, - -1, -1, -1, -1, -1, -1, 280, -1, -1, 283, - -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, - -1, -1, -1, 297, 47, -1, 300, -1, -1, -1, - -1, 54, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 512, -1, 400, 515, 516, 517, - -1, 519, 520, 521, 522, 523, 524, -1, 81, -1, - -1, -1, -1, 8, -1, -1, 11, -1, -1, -1, - 15, 16, 17, 18, -1, 20, 21, 22, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 81, + -1, -1, -1, -1, 280, -1, -1, 283, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 179, -1, -1, + -1, 297, -1, -1, 300, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 196, -1, -1, -1, -1, 201, + -1, -1, -1, -1, -1, -1, -1, 400, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 37, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 47, -1, -1, -1, -1, -1, -1, 54, + -1, -1, 224, 225, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 400, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 179, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 179, -1, 512, -1, - -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, - 524, -1, -1, 196, -1, -1, -1, -1, 201, -1, + -1, -1, -1, -1, 196, -1, -1, -1, 280, 201, + -1, 283, -1, -1, 400, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 297, -1, -1, 300, -1, + -1, -1, 224, 225, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 240, 512, + 436, -1, 515, 516, 517, -1, 519, 520, 521, 522, + 523, 524, -1, -1, -1, -1, -1, 8, -1, -1, + 11, -1, -1, -1, 15, 16, 17, 18, -1, 20, + 21, 22, -1, -1, -1, -1, -1, -1, 280, -1, + -1, 283, -1, -1, -1, -1, 37, -1, -1, -1, + -1, -1, -1, -1, -1, 297, 47, -1, 300, -1, + -1, -1, -1, 54, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 512, -1, 400, 515, + 516, 517, -1, 519, 520, 521, 522, 523, 524, -1, + 81, -1, -1, -1, -1, 8, -1, -1, 11, -1, + -1, -1, 15, 16, 17, 18, -1, 20, 21, 22, + -1, -1, -1, -1, 8, -1, -1, 11, -1, -1, + -1, 15, 16, -1, 37, -1, 20, 21, 22, -1, + -1, -1, -1, -1, 47, -1, -1, -1, -1, -1, + -1, 54, -1, 37, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 47, -1, -1, -1, -1, 400, -1, + 54, -1, -1, -1, -1, -1, -1, -1, 81, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 81, 179, -1, + 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, + 522, 523, 524, -1, -1, 196, -1, -1, -1, -1, + 201, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 8, -1, -1, 11, -1, -1, -1, + 15, 16, -1, 224, 225, 20, 21, 22, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 47, -1, -1, -1, 179, -1, -1, 54, + 512, -1, -1, 515, 516, 517, -1, 519, 520, 521, + 522, 523, 524, 196, -1, 179, -1, -1, 201, 280, + -1, -1, 283, -1, -1, -1, 81, -1, -1, -1, + -1, -1, 196, -1, -1, -1, 297, 201, -1, 300, -1, 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, + 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 179, -1, -1, -1, 512, -1, - -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, - 524, 196, -1, -1, -1, -1, 201, 280, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 280, -1, -1, 283, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 297, -1, -1, 300, -1, 224, + -1, -1, -1, -1, 297, -1, 280, 300, -1, 283, + -1, -1, -1, -1, 179, -1, -1, -1, -1, -1, + -1, -1, -1, 297, -1, -1, 300, -1, -1, 400, + -1, 196, -1, -1, -1, -1, 201, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 224, 225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 240, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 280, -1, -1, 283, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 297, -1, -1, 300, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 400, -1, -1, + -1, -1, -1, -1, -1, 280, -1, -1, 283, -1, + -1, -1, -1, -1, -1, -1, 400, -1, -1, -1, + -1, -1, 297, -1, -1, -1, -1, -1, -1, -1, + -1, 512, -1, -1, 515, 516, 517, -1, 519, 520, + 521, 522, 523, 524, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 512, + -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, + 523, 524, -1, -1, -1, 400, -1, -1, 512, -1, + -1, 515, 516, 517, -1, 519, 520, 521, 522, 523, + 524, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 400, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 512, - -1, -1, 515, 516, 517, -1, 519, 520, 521, 522, - 523, 524, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, @@ -17298,7 +17342,7 @@ static const yytype_int16 yycheck[] = 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, @@ -17504,61 +17548,61 @@ static const yytype_int16 yycheck[] = 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, - 28, 29, 30, -1, 32, 33, 34, 35, 36, -1, - 38, -1, -1, -1, -1, 43, 44, 45, -1, 47, + 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, - 58, -1, 60, 61, 62, 63, 64, 65, -1, -1, - 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, - 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, - 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, - 98, 99, 100, -1, 102, 103, 104, 105, 106, 107, + 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, + 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, + 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, - -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, - 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, - 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, - 168, -1, 170, -1, 172, 173, -1, 175, 176, 177, - 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, - -1, 189, 190, 191, 192, 193, 194, 195, 196, 197, - 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, - 208, -1, 210, 211, 212, 213, 214, 215, 216, 217, - 218, 219, -1, 221, -1, 223, 224, 225, 226, 227, - 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, - 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, + 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, + 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, + 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, + 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, + 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, + 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, + 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, + 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, + 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, + 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, - 278, 279, -1, 281, 282, 283, 284, -1, 286, 287, - 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, - 298, 299, -1, -1, 302, 303, 304, 305, 306, 307, + 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, + 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, - 328, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, + 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, + 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, + 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, + 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, + 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - -1, 389, 390, 391, 392, 393, 394, 395, 396, 397, - 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, + 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, + 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, - 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, - 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, - 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, - 458, 459, 460, 461, -1, 463, 464, 465, 466, -1, - 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, - 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, - 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, + 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, + 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, + 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, + 448, 449, 450, 451, 452, 453, 454, 455, 456, 457, + 458, 459, 460, 461, 462, 463, 464, 465, 466, 467, + 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, + 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, + 488, 489, 490, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, + 29, 30, -1, 32, 33, 34, 35, 36, -1, 38, -1, -1, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, - -1, -1, 61, 62, 63, 64, 65, -1, 67, 68, + -1, 60, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, @@ -17591,14 +17635,14 @@ static const yytype_int16 yycheck[] = 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, - -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, + 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, @@ -17609,7 +17653,7 @@ static const yytype_int16 yycheck[] = 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, -1, - -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, + -1, 61, 62, 63, 64, 65, -1, 67, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, @@ -17658,50 +17702,50 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, - 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, + -1, -1, 43, 44, 45, -1, 47, 48, 49, 50, + 51, 52, 53, 54, 55, 56, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, - 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, - -1, -1, 83, 84, 85, 86, 87, 88, 89, -1, - 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, - -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, + 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, + -1, 82, -1, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, + -1, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, -1, 170, - 171, 172, -1, -1, -1, 176, 177, 178, -1, 180, + -1, 172, 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, - 191, 192, 193, 194, 195, -1, 197, 198, 199, 200, + 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, - -1, 212, 213, 214, 215, 216, 217, 218, 219, -1, - 221, -1, 223, -1, -1, 226, -1, 228, 229, 230, - -1, 232, 233, 234, -1, -1, 237, -1, 239, -1, + 211, 212, 213, 214, 215, 216, 217, 218, 219, -1, + 221, -1, 223, 224, 225, 226, 227, 228, 229, 230, + -1, 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, -1, 275, 276, 277, 278, 279, -1, - 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, + 271, 272, 273, 274, 275, 276, 277, 278, 279, -1, + 281, 282, 283, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, - -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, + -1, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, + -1, -1, -1, -1, 325, 326, 327, 328, 329, 330, + 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, 366, -1, 368, 369, -1, + 361, 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, - 391, 392, 393, 394, 395, 396, 397, 398, -1, -1, + 391, 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, -1, -1, 425, 426, -1, 428, -1, 430, + 421, 422, -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, - 451, 452, 453, 454, 455, -1, 457, 458, 459, 460, + 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, - 471, 472, 473, 474, 475, -1, 477, -1, 479, 480, + 471, 472, 473, 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, @@ -17713,7 +17757,7 @@ static const yytype_int16 yycheck[] = 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, -1, - -1, -1, 84, 85, 86, 87, 88, 89, -1, 91, + -1, 83, 84, 85, 86, 87, 88, 89, -1, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, @@ -17728,7 +17772,7 @@ static const yytype_int16 yycheck[] = 202, 203, 204, 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, 229, 230, -1, - 232, 233, 234, -1, -1, 237, -1, 239, 240, -1, + 232, 233, 234, -1, -1, 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, @@ -17759,107 +17803,107 @@ static const yytype_int16 yycheck[] = 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, - 33, 34, -1, -1, -1, 38, -1, -1, 41, -1, - 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, - 53, -1, 55, 56, 57, 58, -1, 60, 61, 62, + 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, + 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, - 73, 74, -1, 76, 77, 78, 79, -1, -1, 82, - -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, - 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, + 73, 74, 75, 76, 77, 78, 79, 80, -1, -1, + -1, 84, 85, 86, 87, 88, 89, -1, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, - 153, -1, 155, 156, 157, 158, 159, 160, -1, -1, - 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, - 173, -1, 175, 176, 177, 178, 179, 180, 181, 182, - -1, -1, -1, 186, 187, -1, 189, 190, 191, 192, - 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, - 203, 204, 205, 206, 207, 208, -1, 210, 211, -1, + 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, + 163, -1, 165, 166, 167, 168, -1, 170, 171, 172, + -1, -1, -1, 176, 177, 178, -1, 180, 181, 182, + -1, 184, 185, 186, 187, -1, 189, 190, 191, 192, + 193, 194, 195, -1, 197, 198, 199, 200, -1, 202, + 203, 204, 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, - 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, - 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, + 223, -1, -1, 226, -1, 228, 229, 230, -1, 232, + 233, 234, -1, -1, 237, -1, 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, - 273, 274, 275, 276, 277, 278, -1, -1, 281, 282, - 283, 284, -1, -1, 287, 288, 289, 290, 291, -1, + 273, -1, 275, 276, 277, 278, 279, -1, 281, 282, + -1, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, - 303, -1, 305, 306, 307, -1, 309, 310, 311, 312, + 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, - -1, -1, 325, 326, -1, 328, 329, 330, -1, 332, - 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, + -1, -1, 325, 326, 327, -1, 329, 330, 331, 332, + 333, 334, 335, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, - 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, + 363, 364, 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, - 383, 384, 385, 386, 387, -1, 389, 390, 391, 392, - 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, + 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, + 393, 394, 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, - 413, 414, 415, 416, 417, 418, 419, 420, 421, -1, - -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, + 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, + -1, -1, 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, - 443, -1, 445, -1, -1, 448, 449, 450, 451, 452, - 453, 454, 455, 456, -1, 458, 459, 460, 461, -1, + 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, + 453, 454, 455, -1, 457, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, - -1, 474, 475, -1, 477, 478, 479, 480, 481, 482, + 473, 474, 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, - 493, 494, 495, 496, 3, -1, 5, -1, -1, -1, - -1, -1, -1, -1, -1, 508, 509, 510, 511, -1, - -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, 35, 36, -1, -1, - -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, - 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, - -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, - 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, - 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, - 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, - 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, - 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, - 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, - 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, - 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, - -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, - 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, - -1, 170, -1, 172, -1, -1, -1, 176, 177, 178, - -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, - 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, - 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, - -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, - 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, - 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, - 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, - 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, - 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, - 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, - 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, - 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, - 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, - 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, - 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, - 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, - 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, - 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, - 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, - -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, - -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, - 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, - -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, - 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, - 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, - 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, - -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, - 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, + 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, + 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, + 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, + 34, -1, -1, -1, 38, -1, -1, 41, -1, 43, + 44, 45, -1, 47, 48, 49, 50, 51, 52, 53, + -1, 55, 56, 57, 58, -1, 60, 61, 62, 63, + 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, + 74, -1, 76, 77, 78, 79, -1, -1, 82, -1, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + -1, 95, 96, 97, 98, 99, 100, -1, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, + 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, + 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, + -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, + -1, 145, 146, 147, 148, -1, 150, 151, 152, 153, + -1, 155, 156, 157, 158, 159, 160, -1, -1, 163, + -1, 165, 166, 167, 168, -1, 170, -1, 172, 173, + -1, 175, 176, 177, 178, 179, 180, 181, 182, -1, + -1, -1, 186, 187, -1, 189, 190, 191, 192, 193, + 194, 195, 196, 197, 198, 199, 200, -1, 202, 203, + 204, 205, 206, 207, 208, -1, 210, 211, -1, 213, + 214, 215, 216, 217, 218, 219, -1, 221, -1, 223, + 224, 225, 226, 227, 228, 229, 230, -1, 232, 233, + 234, -1, -1, 237, 238, 239, 240, -1, 242, 243, + 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, + 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, + 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, + 274, 275, 276, 277, 278, -1, -1, 281, 282, 283, + 284, -1, -1, 287, 288, 289, 290, 291, -1, 293, + 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, + -1, 305, 306, 307, -1, 309, 310, 311, 312, 313, + 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, + -1, 325, 326, -1, 328, 329, 330, -1, 332, 333, + 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, + 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, + 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, + 364, 365, 366, -1, 368, 369, 370, 371, 372, 373, + 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, + 384, 385, 386, 387, -1, 389, 390, 391, 392, 393, + 394, 395, 396, 397, 398, -1, 400, 401, 402, 403, + 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, + 414, 415, 416, 417, 418, 419, 420, 421, -1, -1, + -1, 425, 426, -1, 428, 429, 430, 431, 432, 433, + 434, 435, -1, 437, 438, 439, -1, -1, 442, 443, + -1, 445, -1, -1, 448, 449, 450, 451, 452, 453, + 454, 455, 456, -1, 458, 459, 460, 461, -1, 463, + 464, 465, 466, -1, 468, 469, 470, 471, 472, -1, + 474, 475, -1, 477, 478, 479, 480, 481, 482, 483, + 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, + 494, 495, 496, 3, -1, 5, -1, -1, -1, -1, + -1, -1, -1, -1, 508, 509, 510, 511, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, -1, -1, -1, -1, -1, + 30, -1, 32, 33, 34, 35, 36, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, @@ -17910,7 +17954,7 @@ static const yytype_int16 yycheck[] = 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, + 31, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, @@ -17936,7 +17980,7 @@ static const yytype_int16 yycheck[] = 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, - 291, -1, 293, 294, -1, 296, 297, 298, 299, -1, + 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, 329, 330, @@ -18011,7 +18055,7 @@ static const yytype_int16 yycheck[] = 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, + 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, @@ -18038,7 +18082,7 @@ static const yytype_int16 yycheck[] = 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, 291, -1, - 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, + 293, 294, -1, 296, 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, 329, 330, 331, 332, @@ -18062,7 +18106,7 @@ static const yytype_int16 yycheck[] = 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, - 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, + 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, @@ -18089,7 +18133,7 @@ static const yytype_int16 yycheck[] = 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, - 294, -1, 296, 297, 298, 299, -1, -1, 302, 303, + 294, -1, -1, 297, 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, 329, 330, 331, 332, 333, @@ -18111,208 +18155,208 @@ static const yytype_int16 yycheck[] = 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 3, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, 38, -1, -1, -1, -1, 43, 44, - 45, -1, 47, 48, 49, 50, 51, 52, 53, -1, - 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, + 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, + 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, - -1, 76, 77, 78, 79, -1, -1, 82, -1, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, - 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, + -1, 76, 77, 78, 79, 80, -1, -1, -1, 84, + 85, 86, 87, 88, 89, -1, 91, 92, 93, -1, + 95, 96, 97, 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, - 145, 146, 147, 148, -1, 150, 151, 152, 153, -1, - 155, 156, 157, 158, 159, 160, -1, -1, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, - 175, 176, 177, -1, 179, 180, 181, 182, -1, -1, - -1, 186, 187, -1, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, - 205, 206, 207, 208, -1, 210, 211, -1, 213, 214, - 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, - 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, - -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, + 145, 146, 147, 148, -1, 150, 151, 152, 153, 154, + 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, + 165, 166, 167, 168, -1, 170, -1, 172, -1, -1, + -1, 176, 177, 178, -1, 180, 181, 182, -1, 184, + 185, 186, 187, -1, 189, 190, 191, 192, 193, 194, + 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, + 205, 206, 207, 208, -1, 210, -1, 212, 213, 214, + 215, 216, 217, 218, 219, -1, 221, -1, 223, -1, + -1, 226, -1, 228, 229, 230, -1, 232, 233, 234, + -1, -1, 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, -1, -1, 281, 282, 283, 284, - -1, -1, 287, 288, 289, 290, 291, -1, 293, 294, - -1, -1, 297, 298, 299, -1, -1, 302, 303, -1, - 305, 306, 307, -1, 309, 310, 311, 312, 313, 314, + 265, 266, 267, 268, 269, 270, 271, 272, 273, -1, + 275, 276, 277, 278, 279, -1, 281, 282, -1, 284, + -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, + -1, 296, 297, 298, 299, -1, -1, 302, 303, 304, + -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, - 325, 326, -1, 328, 329, 330, -1, 332, 333, 334, + 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, -1, 368, 369, 370, 371, 372, 373, 374, + 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, - 395, 396, 397, 398, -1, 400, 401, 402, 403, 404, + 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, + 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, 420, 421, -1, -1, -1, - 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, - 435, -1, 437, 438, 439, -1, -1, 442, 443, -1, - 445, -1, -1, 448, 449, 450, 451, 452, 453, 454, - 455, 456, -1, 458, 459, 460, 461, -1, 463, 464, - 465, 466, -1, 468, 469, 470, 471, 472, -1, 474, - 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, + 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, + 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, + 435, -1, 437, 438, 439, -1, -1, 442, 443, 444, + 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, + 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, + 465, 466, -1, 468, 469, 470, 471, 472, 473, 474, + 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, - 495, 496, 3, -1, 5, -1, -1, -1, -1, -1, - -1, -1, -1, 508, 509, 510, 511, -1, -1, -1, - -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, - 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, - 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, - 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, - -1, -1, -1, 84, 85, 86, 87, 88, 89, -1, - 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, - -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, - 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, - 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, - 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, -1, 165, 166, 167, 168, -1, 170, - -1, 172, -1, -1, -1, 176, 177, 178, -1, 180, - 181, 182, -1, 184, 185, 186, 187, -1, 189, 190, - 191, 192, 193, 194, 195, -1, 197, 198, 199, 200, - -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, - -1, 212, 213, 214, 215, 216, 217, 218, 219, -1, - 221, -1, 223, -1, -1, 226, -1, 228, 229, 230, - -1, 232, 233, 234, -1, -1, 237, -1, 239, -1, - -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, -1, 275, 276, 277, 278, 279, -1, - 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, - 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, - -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, - 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, - 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, 366, -1, 368, 369, -1, - 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, - 391, 392, 393, 394, 395, 396, 397, 398, -1, -1, - 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, -1, -1, 425, 426, 427, 428, -1, 430, - 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, - -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, - 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, - 471, 472, 473, 474, 475, -1, 477, -1, 479, 480, - 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, + 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, + 505, 506, 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, + 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, + -1, -1, 38, -1, -1, -1, -1, 43, 44, 45, + -1, 47, 48, 49, 50, 51, 52, 53, -1, 55, + 56, 57, 58, -1, 60, 61, 62, 63, 64, 65, + -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, + 76, 77, 78, 79, -1, -1, 82, -1, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, + 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, + 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, + 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, + 146, 147, 148, -1, 150, 151, 152, 153, -1, 155, + 156, 157, 158, 159, 160, -1, -1, 163, -1, 165, + 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, + 176, 177, -1, 179, 180, 181, 182, -1, -1, -1, + 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, + 206, 207, 208, -1, 210, 211, -1, 213, 214, 215, + 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, + 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, + -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, + 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, -1, -1, 281, 282, 283, 284, -1, + -1, 287, 288, 289, 290, 291, -1, 293, 294, -1, + -1, 297, 298, 299, -1, -1, 302, 303, -1, 305, + 306, 307, -1, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, + 326, -1, 328, 329, 330, -1, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, -1, 368, 369, 370, 371, 372, 373, 374, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, -1, 389, 390, 391, 392, 393, 394, 395, + 396, 397, 398, -1, 400, 401, 402, 403, 404, -1, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, 420, 421, -1, -1, -1, 425, + 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, + -1, 437, 438, 439, -1, -1, 442, 443, -1, 445, + -1, -1, 448, 449, 450, 451, 452, 453, 454, 455, + 456, -1, 458, 459, 460, 461, -1, 463, 464, 465, + 466, -1, 468, 469, 470, 471, 472, -1, 474, 475, + -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, + -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, + 496, 3, -1, 5, -1, -1, -1, -1, -1, -1, + -1, -1, 508, 509, 510, 511, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, - 32, 33, 34, -1, -1, -1, 38, -1, -1, -1, - -1, 43, 44, 45, -1, 47, 48, 49, 50, 51, - 52, 53, -1, 55, 56, 57, 58, -1, 60, 61, + 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, + 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, - 72, 73, 74, -1, 76, 77, 78, 79, -1, -1, - 82, -1, 84, 85, 86, 87, 88, 89, 90, 91, + 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, + -1, -1, 84, 85, 86, 87, 88, 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, - 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, - 152, 153, -1, 155, 156, 157, 158, 159, 160, -1, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, -1, 170, -1, - 172, 173, -1, 175, 176, 177, -1, 179, 180, 181, - 182, -1, -1, -1, 186, 187, -1, 189, 190, 191, - 192, 193, 194, 195, 196, 197, 198, 199, 200, -1, - 202, 203, 204, 205, 206, 207, 208, -1, 210, 211, - -1, 213, 214, 215, 216, 217, 218, 219, -1, 221, - -1, 223, 224, 225, 226, 227, 228, 229, 230, -1, - 232, 233, 234, -1, -1, 237, 238, 239, 240, -1, + 172, -1, -1, -1, 176, 177, 178, -1, 180, 181, + 182, -1, 184, 185, 186, 187, -1, 189, 190, 191, + 192, 193, 194, 195, -1, 197, 198, 199, 200, -1, + 202, 203, 204, 205, 206, 207, 208, -1, 210, -1, + 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, + -1, 223, -1, -1, 226, -1, 228, 229, 230, -1, + 232, 233, 234, -1, -1, 237, -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, - 272, 273, 274, 275, 276, 277, 278, -1, -1, 281, - 282, 283, 284, -1, -1, 287, 288, 289, 290, 291, + 272, 273, -1, 275, 276, 277, 278, 279, -1, 281, + 282, -1, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, - 302, 303, -1, 305, 306, 307, -1, 309, 310, 311, + 302, 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, -1, - -1, -1, -1, 325, 326, -1, 328, 329, 330, -1, + -1, -1, -1, 325, 326, 327, -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, - 362, 363, 364, 365, 366, -1, 368, 369, 370, 371, + 362, 363, 364, 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, - 382, 383, 384, 385, 386, 387, -1, 389, 390, 391, - 392, 393, 394, 395, 396, 397, 398, -1, 400, 401, + 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, + 392, 393, 394, 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, - -1, -1, -1, 425, 426, -1, 428, 429, 430, 431, + 422, -1, -1, 425, 426, 427, 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, - 442, 443, -1, 445, -1, -1, 448, 449, 450, 451, - 452, 453, 454, 455, 456, -1, 458, 459, 460, 461, + 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, + 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, - 472, -1, 474, 475, -1, 477, 478, 479, 480, 481, + 472, 473, 474, 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, - 492, 493, 494, 495, 496, 3, -1, 5, -1, -1, - -1, -1, -1, -1, -1, -1, 508, 509, 510, 511, - -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, - 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, - 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, - 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, - 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, - 78, 79, 80, -1, -1, -1, 84, 85, 86, 87, - 88, 89, -1, 91, 92, 93, -1, 95, 96, 97, - 98, 99, 100, -1, -1, 103, 104, 105, 106, 107, - 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, - -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, - -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, - 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, - 148, -1, 150, 151, 152, 153, 154, 155, 156, 157, - 158, 159, 160, 161, -1, 163, -1, 165, 166, 167, - 168, -1, 170, -1, 172, -1, -1, -1, 176, 177, - 178, -1, 180, 181, 182, -1, 184, 185, 186, 187, - -1, 189, 190, 191, 192, 193, 194, 195, -1, 197, - 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, - 208, -1, 210, -1, 212, 213, 214, 215, 216, 217, - 218, 219, -1, 221, -1, 223, -1, -1, 226, -1, - 228, 229, 230, -1, 232, 233, 234, -1, -1, 237, - -1, 239, -1, -1, 242, 243, 244, 245, 246, 247, - 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, - 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, - 268, 269, 270, 271, 272, 273, -1, 275, 276, 277, - 278, 279, -1, 281, 282, -1, 284, -1, 286, 287, - 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, - 298, 299, -1, -1, 302, 303, 304, -1, 306, -1, - 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, - 318, 319, 320, -1, -1, -1, -1, 325, 326, 327, - -1, 329, 330, 331, 332, 333, 334, -1, 336, 337, - 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, - 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, - 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, - 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, - 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, - -1, -1, 390, 391, 392, 393, 394, 395, 396, 397, - 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, - 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, - 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, - 428, -1, 430, 431, 432, 433, 434, 435, -1, 437, - 438, 439, -1, -1, 442, 443, 444, 445, 446, -1, - 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, - 458, 459, 460, -1, -1, 463, 464, 465, 466, -1, - 468, 469, 470, 471, 472, 473, 474, 475, -1, 477, - -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, - 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, - 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, - 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, + 33, 34, -1, -1, -1, 38, -1, -1, -1, -1, + 43, 44, 45, -1, 47, 48, 49, 50, 51, 52, + 53, -1, 55, 56, 57, 58, -1, 60, 61, 62, + 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, + 73, 74, -1, 76, 77, 78, 79, -1, -1, 82, + -1, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, -1, 95, 96, 97, 98, 99, 100, -1, 102, + 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, + 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, + -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, + 143, -1, 145, 146, 147, 148, -1, 150, 151, 152, + 153, -1, 155, 156, 157, 158, 159, 160, -1, -1, + 163, -1, 165, 166, 167, 168, -1, 170, -1, 172, + 173, -1, 175, 176, 177, -1, 179, 180, 181, 182, + -1, -1, -1, 186, 187, -1, 189, 190, 191, 192, + 193, 194, 195, 196, 197, 198, 199, 200, -1, 202, + 203, 204, 205, 206, 207, 208, -1, 210, 211, -1, + 213, 214, 215, 216, 217, 218, 219, -1, 221, -1, + 223, 224, 225, 226, 227, 228, 229, 230, -1, 232, + 233, 234, -1, -1, 237, 238, 239, 240, -1, 242, + 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, + 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, + 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, + 273, 274, 275, 276, 277, 278, -1, -1, 281, 282, + 283, 284, -1, -1, 287, 288, 289, 290, 291, -1, + 293, 294, -1, -1, 297, 298, 299, -1, -1, 302, + 303, -1, 305, 306, 307, -1, 309, 310, 311, 312, + 313, 314, 315, 316, 317, 318, 319, 320, -1, -1, + -1, -1, 325, 326, -1, 328, 329, 330, -1, 332, + 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, + 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, + -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, + 363, 364, 365, 366, -1, 368, 369, 370, 371, 372, + 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, + 383, 384, 385, 386, 387, -1, 389, 390, 391, 392, + 393, 394, 395, 396, 397, 398, -1, 400, 401, 402, + 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, + 413, 414, 415, 416, 417, 418, 419, 420, 421, -1, + -1, -1, 425, 426, -1, 428, 429, 430, 431, 432, + 433, 434, 435, -1, 437, 438, 439, -1, -1, 442, + 443, -1, 445, -1, -1, 448, 449, 450, 451, 452, + 453, 454, 455, 456, -1, 458, 459, 460, 461, -1, + 463, 464, 465, 466, -1, 468, 469, 470, 471, 472, + -1, 474, 475, -1, 477, 478, 479, 480, 481, 482, + 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, + 493, 494, 495, 496, 3, -1, 5, -1, -1, -1, + -1, -1, -1, -1, -1, 508, 509, 510, 511, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, @@ -18362,10 +18406,10 @@ static const yytype_int16 yycheck[] = 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, - 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, + 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, -1, -1, -1, -1, -1, + 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, @@ -18413,10 +18457,10 @@ static const yytype_int16 yycheck[] = 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, + 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, + 31, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, @@ -18769,11 +18813,11 @@ static const yytype_int16 yycheck[] = 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, + 507, 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, - -1, -1, -1, 41, -1, -1, 44, 45, -1, -1, + -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, @@ -18874,8 +18918,8 @@ static const yytype_int16 yycheck[] = 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, - 30, 31, 32, 33, 34, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, + 30, -1, 32, 33, 34, -1, -1, -1, -1, -1, + -1, 41, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, @@ -18922,10 +18966,10 @@ static const yytype_int16 yycheck[] = 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, + 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, + 31, 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, @@ -19278,7 +19322,7 @@ static const yytype_int16 yycheck[] = 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 508, 509, 510, 511, 3, -1, -1, -1, -1, + 507, 508, 509, 510, 511, 3, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, -1, -1, @@ -19638,7 +19682,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, -1, -1, -1, 41, -1, -1, 44, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, @@ -19674,7 +19718,7 @@ static const yytype_int16 yycheck[] = 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, 392, 393, 394, - -1, 396, 397, 398, -1, -1, 401, 402, 403, 404, + 395, 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, -1, 430, 431, 432, 433, 434, @@ -19689,7 +19733,7 @@ static const yytype_int16 yycheck[] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, - -1, -1, -1, -1, -1, -1, -1, -1, 44, 45, + -1, -1, -1, -1, -1, 41, -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, @@ -19724,7 +19768,7 @@ static const yytype_int16 yycheck[] = 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, - 386, 387, -1, -1, 390, 391, 392, 393, 394, 395, + 386, 387, -1, -1, 390, 391, 392, 393, 394, -1, 396, 397, 398, -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, -1, -1, 425, @@ -19841,206 +19885,257 @@ static const yytype_int16 yycheck[] = 508, 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, 24, 25, 26, 27, 28, - 29, 30, -1, 32, 33, 34, -1, -1, -1, 38, - -1, -1, -1, -1, 43, 44, 45, -1, 47, 48, - 49, 50, 51, 52, 53, -1, 55, 56, 57, 58, - -1, 60, 61, 62, 63, 64, 65, -1, -1, 68, + 29, 30, -1, 32, 33, 34, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 44, 45, -1, -1, 48, + 49, -1, 51, 52, 53, 54, 55, -1, 57, 58, + -1, -1, 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, 76, 77, 78, - 79, -1, -1, 82, -1, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 93, -1, 95, 96, 97, 98, - 99, 100, -1, 102, 103, 104, 105, 106, 107, 108, + 79, 80, -1, -1, -1, 84, 85, 86, 87, 88, + 89, -1, 91, 92, 93, -1, 95, 96, 97, 98, + 99, 100, -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, 146, 147, 148, - -1, 150, 151, 152, 153, -1, 155, 156, 157, 158, - 159, 160, -1, -1, 163, -1, 165, 166, 167, 168, - -1, 170, -1, 172, 173, -1, 175, 176, 177, 178, - 179, 180, 181, 182, -1, -1, -1, 186, 187, -1, - 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, + -1, 150, 151, 152, 153, 154, 155, 156, 157, 158, + 159, 160, 161, -1, 163, -1, 165, 166, 167, 168, + -1, 170, -1, 172, -1, -1, -1, 176, 177, 178, + -1, 180, 181, 182, -1, 184, 185, 186, 187, -1, + 189, 190, 191, 192, 193, 194, 195, -1, 197, 198, 199, 200, -1, 202, 203, 204, 205, 206, 207, 208, - -1, 210, 211, -1, 213, 214, 215, 216, 217, 218, - 219, -1, 221, -1, 223, 224, 225, 226, 227, 228, - 229, 230, -1, 232, 233, 234, -1, -1, 237, 238, - 239, 240, -1, 242, 243, 244, 245, 246, 247, 248, + -1, 210, -1, 212, 213, 214, 215, 216, 217, 218, + 219, -1, 221, -1, 223, -1, -1, 226, -1, 228, + 229, 230, -1, 232, 233, 234, -1, -1, 237, -1, + 239, -1, -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, - 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, - -1, -1, 281, 282, 283, 284, -1, -1, 287, 288, + 269, 270, 271, 272, 273, -1, 275, 276, 277, 278, + 279, -1, 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, 291, -1, 293, 294, -1, -1, 297, 298, - 299, -1, -1, 302, 303, -1, 305, 306, 307, -1, + 299, -1, -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, - 319, 320, -1, -1, -1, -1, 325, 326, -1, 328, - 329, 330, -1, 332, 333, 334, -1, 336, 337, 338, + 319, 320, -1, -1, -1, -1, 325, 326, 327, -1, + 329, 330, 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, -1, 368, - 369, 370, 371, 372, 373, -1, 375, 376, 377, 378, + 369, -1, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, -1, - 389, 390, 391, 392, 393, 394, 395, -1, 397, 398, - -1, 400, 401, 402, 403, 404, -1, 406, 407, 408, + -1, 390, 391, 392, 393, 394, 395, 396, 397, 398, + -1, -1, 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, - 419, 420, 421, -1, -1, -1, 425, 426, -1, 428, - 429, 430, 431, 432, 433, 434, 435, -1, 437, 438, - 439, -1, -1, 442, 443, -1, 445, -1, -1, 448, + 419, 420, 421, 422, -1, -1, 425, 426, -1, 428, + -1, 430, 431, 432, 433, 434, 435, -1, 437, 438, + 439, -1, -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, 452, 453, 454, 455, -1, -1, 458, - 459, 460, 461, -1, 463, 464, 465, 466, -1, 468, - 469, 470, 471, 472, -1, 474, 475, -1, 477, 478, + 459, 460, -1, -1, 463, 464, 465, 466, -1, 468, + 469, 470, 471, 472, 473, 474, 475, -1, 477, -1, 479, 480, 481, 482, 483, 484, 485, -1, -1, 488, - -1, -1, 491, 492, 493, 494, 495, 496, 3, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 508, - 509, 510, 511, -1, -1, -1, -1, -1, 23, 24, - 25, 26, 27, 28, 29, 30, -1, 32, 33, 34, - -1, -1, -1, 38, -1, -1, -1, -1, 43, 44, - 45, -1, 47, 48, 49, 50, 51, 52, 53, -1, - 55, 56, 57, 58, -1, 60, 61, 62, 63, 64, - 65, -1, -1, 68, 69, 70, 71, 72, 73, 74, - -1, 76, 77, 78, 79, -1, -1, 82, -1, 84, - 85, 86, 87, 88, 89, 90, 91, 92, 93, -1, - 95, 96, 97, 98, 99, 100, -1, 102, 103, 104, - 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, - 115, 116, 117, -1, 119, -1, 121, 122, 123, 124, - 125, 126, -1, -1, 129, 130, 131, 132, -1, -1, - 135, 136, 137, 138, 139, -1, 141, 142, 143, -1, - 145, 146, 147, 148, -1, 150, 151, 152, 153, -1, - 155, 156, 157, 158, 159, 160, -1, -1, 163, -1, - 165, 166, 167, 168, -1, 170, -1, 172, 173, -1, - 175, 176, 177, -1, 179, 180, 181, 182, -1, -1, - -1, 186, 187, -1, 189, 190, 191, 192, 193, 194, - 195, 196, 197, 198, 199, 200, -1, 202, 203, 204, - 205, 206, 207, 208, -1, 210, 211, -1, 213, 214, - 215, 216, 217, 218, 219, -1, 221, -1, 223, 224, - 225, 226, 227, 228, 229, 230, -1, 232, 233, 234, - -1, -1, 237, 238, 239, 240, -1, 242, 243, 244, - 245, 246, 247, 248, 249, -1, 251, 252, 253, 254, - 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, - 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, - 275, 276, 277, 278, -1, -1, 281, 282, 283, 284, - -1, -1, 287, 288, 289, 290, 291, -1, 293, 294, - -1, -1, 297, 298, 299, -1, -1, 302, 303, -1, - 305, 306, 307, -1, 309, 310, 311, 312, 313, 314, - 315, 316, 317, 318, 319, 320, -1, -1, -1, -1, - 325, 326, -1, 328, 329, 330, -1, 332, 333, 334, - -1, 336, 337, 338, 339, 340, 341, -1, 343, 344, - 345, 346, 347, 348, 349, 350, 351, 352, -1, 354, - 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, - 365, 366, -1, 368, 369, 370, 371, 372, 373, -1, - 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, - 385, 386, 387, -1, 389, 390, 391, 392, 393, 394, - 395, -1, 397, 398, -1, 400, 401, 402, 403, 404, - -1, 406, 407, 408, 409, 410, 411, 412, 413, 414, - 415, 416, 417, 418, 419, -1, 421, -1, -1, -1, - 425, 426, -1, 428, 429, 430, 431, 432, 433, 434, - 435, -1, 437, 438, 439, -1, -1, 442, 443, -1, - 445, -1, -1, 448, 449, 450, 451, 452, 453, 454, - 455, -1, -1, 458, 459, 460, 461, -1, 463, 464, - 465, 466, -1, 468, 469, 470, 471, 472, -1, 474, - 475, -1, 477, 478, 479, 480, 481, 482, 483, 484, - 485, -1, -1, 488, -1, -1, 491, 492, 493, 494, - 495, 496, 3, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 508, 509, 510, 511, -1, -1, -1, - -1, -1, 23, 24, 25, 26, 27, 28, 29, 30, - -1, 32, 33, 34, -1, -1, -1, -1, -1, -1, - -1, -1, -1, 44, 45, -1, -1, 48, 49, -1, - 51, 52, 53, 54, 55, -1, 57, 58, -1, -1, - 61, 62, 63, 64, 65, -1, -1, 68, 69, 70, - 71, 72, 73, 74, -1, 76, 77, 78, 79, 80, - -1, -1, -1, 84, 85, 86, 87, 88, 89, -1, - 91, 92, 93, -1, 95, 96, 97, 98, 99, 100, - -1, -1, 103, 104, 105, 106, 107, 108, 109, 110, - 111, 112, 113, 114, 115, 116, 117, -1, 119, -1, - 121, 122, 123, 124, 125, 126, -1, -1, 129, 130, - 131, 132, -1, -1, 135, 136, 137, 138, 139, -1, - 141, 142, 143, -1, 145, 146, 147, 148, -1, 150, - 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, - 161, -1, 163, -1, 165, 166, 167, 168, -1, 170, - -1, 172, -1, -1, -1, 176, 177, 178, -1, 180, - 181, 182, -1, 184, 185, -1, 187, -1, 189, 190, - 191, 192, 193, 194, 195, -1, 197, 198, 199, 200, - -1, 202, 203, 204, 205, 206, 207, 208, -1, 210, - -1, 212, 213, 214, 215, 216, 217, 218, 219, -1, - 221, -1, 223, -1, -1, 226, -1, 228, 229, 230, - -1, 232, 233, 234, -1, -1, 237, -1, 239, -1, - -1, 242, 243, 244, 245, 246, 247, 248, 249, 250, - 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, - 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, - 271, 272, 273, -1, 275, 276, 277, 278, 279, -1, - 281, 282, -1, 284, -1, 286, 287, 288, 289, 290, - 291, -1, 293, 294, -1, -1, 297, 298, 299, -1, - -1, 302, 303, 304, -1, 306, -1, 308, 309, 310, - 311, 312, 313, 314, -1, 316, 317, 318, 319, 320, - -1, -1, -1, -1, 325, 326, 327, -1, 329, 330, - 331, 332, 333, 334, -1, 336, 337, 338, 339, 340, - 341, -1, 343, 344, 345, -1, 347, 348, 349, 350, - 351, 352, -1, 354, 355, 356, 357, 358, 359, 360, - 361, 362, 363, 364, 365, 366, -1, 368, 369, -1, - 371, 372, 373, 374, -1, 376, 377, 378, 379, 380, - 381, 382, 383, 384, 385, 386, 387, -1, -1, 390, - 391, 392, 393, 394, 395, 396, 397, 398, -1, -1, - 401, 402, 403, 404, -1, 406, 407, 408, 409, 410, - 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, - 421, 422, -1, -1, 425, 426, -1, 428, -1, 430, - 431, 432, 433, 434, 435, -1, 437, 438, 439, -1, - -1, 442, 443, 444, 445, 446, -1, 448, 449, 450, - 451, 452, 453, 454, 455, -1, -1, 458, 459, 460, - -1, -1, 463, 464, 465, 466, -1, 468, 469, 470, - 471, 472, 473, 474, 475, -1, 477, -1, 479, 480, - 481, 482, 483, 484, 485, -1, -1, 488, -1, -1, - 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, - 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, - 511, 23, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 33, -1, 35, 36, -1, -1, -1, -1, 23, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, - -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, -1, -1, -1, -1, -1, -1, 53, - -1, -1, -1, -1, 76, -1, -1, -1, 62, -1, - -1, -1, -1, -1, -1, 87, -1, -1, -1, -1, - -1, -1, 76, -1, -1, -1, -1, 99, -1, 101, - -1, -1, -1, 87, -1, -1, -1, -1, -1, -1, - 112, -1, -1, -1, -1, 99, -1, 101, -1, -1, - -1, -1, -1, -1, -1, 127, 128, -1, 112, -1, - -1, -1, -1, -1, -1, -1, 138, -1, -1, -1, - -1, -1, 144, 127, 128, -1, -1, -1, -1, -1, - -1, 153, -1, -1, 138, -1, -1, -1, -1, -1, - 144, -1, -1, -1, -1, -1, -1, -1, 170, 153, - -1, -1, 174, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 170, -1, -1, -1, - 174, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 491, 492, 493, 494, 495, 496, 497, 498, + 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, + 509, 510, 511, 3, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 23, 24, 25, 26, 27, 28, 29, + 30, -1, 32, 33, 34, -1, -1, -1, 38, -1, + -1, -1, -1, 43, 44, 45, -1, 47, 48, 49, + 50, 51, 52, 53, -1, 55, 56, 57, 58, -1, + 60, 61, 62, 63, 64, 65, -1, -1, 68, 69, + 70, 71, 72, 73, 74, -1, 76, 77, 78, 79, + -1, -1, 82, -1, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, -1, 95, 96, 97, 98, 99, + 100, -1, 102, 103, 104, 105, 106, 107, 108, 109, + 110, 111, 112, 113, 114, 115, 116, 117, -1, 119, + -1, 121, 122, 123, 124, 125, 126, -1, -1, 129, + 130, 131, 132, -1, -1, 135, 136, 137, 138, 139, + -1, 141, 142, 143, -1, 145, 146, 147, 148, -1, + 150, 151, 152, 153, -1, 155, 156, 157, 158, 159, + 160, -1, -1, 163, -1, 165, 166, 167, 168, -1, + 170, -1, 172, 173, -1, 175, 176, 177, 178, 179, + 180, 181, 182, -1, -1, -1, 186, 187, -1, 189, + 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, + 200, -1, 202, 203, 204, 205, 206, 207, 208, -1, + 210, 211, -1, 213, 214, 215, 216, 217, 218, 219, + -1, 221, -1, 223, 224, 225, 226, 227, 228, 229, + 230, -1, 232, 233, 234, -1, -1, 237, 238, 239, + 240, -1, 242, 243, 244, 245, 246, 247, 248, 249, + 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, + 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, + 270, 271, 272, 273, 274, 275, 276, 277, 278, -1, + -1, 281, 282, 283, 284, -1, -1, 287, 288, 289, + 290, 291, -1, 293, 294, -1, -1, 297, 298, 299, + -1, -1, 302, 303, -1, 305, 306, 307, -1, 309, + 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, + 320, -1, -1, -1, -1, 325, 326, -1, 328, 329, + 330, -1, 332, 333, 334, -1, 336, 337, 338, 339, + 340, 341, -1, 343, 344, 345, 346, 347, 348, 349, + 350, 351, 352, -1, 354, 355, 356, 357, 358, 359, + 360, 361, 362, 363, 364, 365, 366, -1, 368, 369, + 370, 371, 372, 373, -1, 375, 376, 377, 378, 379, + 380, 381, 382, 383, 384, 385, 386, 387, -1, 389, + 390, 391, 392, 393, 394, 395, -1, 397, 398, -1, + 400, 401, 402, 403, 404, -1, 406, 407, 408, 409, + 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, + 420, 421, -1, -1, -1, 425, 426, -1, 428, 429, + 430, 431, 432, 433, 434, 435, -1, 437, 438, 439, + -1, -1, 442, 443, -1, 445, -1, -1, 448, 449, + 450, 451, 452, 453, 454, 455, -1, -1, 458, 459, + 460, 461, -1, 463, 464, 465, 466, -1, 468, 469, + 470, 471, 472, -1, 474, 475, -1, 477, 478, 479, + 480, 481, 482, 483, 484, 485, -1, -1, 488, -1, + -1, 491, 492, 493, 494, 495, 496, 3, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 508, 509, + 510, 511, -1, -1, -1, -1, -1, 23, 24, 25, + 26, 27, 28, 29, 30, -1, 32, 33, 34, -1, + -1, -1, 38, -1, -1, -1, -1, 43, 44, 45, + -1, 47, 48, 49, 50, 51, 52, 53, -1, 55, + 56, 57, 58, -1, 60, 61, 62, 63, 64, 65, + -1, -1, 68, 69, 70, 71, 72, 73, 74, -1, + 76, 77, 78, 79, -1, -1, 82, -1, 84, 85, + 86, 87, 88, 89, 90, 91, 92, 93, -1, 95, + 96, 97, 98, 99, 100, -1, 102, 103, 104, 105, + 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, + 116, 117, -1, 119, -1, 121, 122, 123, 124, 125, + 126, -1, -1, 129, 130, 131, 132, -1, -1, 135, + 136, 137, 138, 139, -1, 141, 142, 143, -1, 145, + 146, 147, 148, -1, 150, 151, 152, 153, -1, 155, + 156, 157, 158, 159, 160, -1, -1, 163, -1, 165, + 166, 167, 168, -1, 170, -1, 172, 173, -1, 175, + 176, 177, -1, 179, 180, 181, 182, -1, -1, -1, + 186, 187, -1, 189, 190, 191, 192, 193, 194, 195, + 196, 197, 198, 199, 200, -1, 202, 203, 204, 205, + 206, 207, 208, -1, 210, 211, -1, 213, 214, 215, + 216, 217, 218, 219, -1, 221, -1, 223, 224, 225, + 226, 227, 228, 229, 230, -1, 232, 233, 234, -1, + -1, 237, 238, 239, 240, -1, 242, 243, 244, 245, + 246, 247, 248, 249, -1, 251, 252, 253, 254, 255, + 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, + 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, + 276, 277, 278, -1, -1, 281, 282, 283, 284, -1, + -1, 287, 288, 289, 290, 291, -1, 293, 294, -1, + -1, 297, 298, 299, -1, -1, 302, 303, -1, 305, + 306, 307, -1, 309, 310, 311, 312, 313, 314, 315, + 316, 317, 318, 319, 320, -1, -1, -1, -1, 325, + 326, -1, 328, 329, 330, -1, 332, 333, 334, -1, + 336, 337, 338, 339, 340, 341, -1, 343, 344, 345, + 346, 347, 348, 349, 350, 351, 352, -1, 354, 355, + 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, + 366, -1, 368, 369, 370, 371, 372, 373, -1, 375, + 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, + 386, 387, -1, 389, 390, 391, 392, 393, 394, 395, + -1, 397, 398, -1, 400, 401, 402, 403, 404, -1, + 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, + 416, 417, 418, 419, -1, 421, -1, -1, -1, 425, + 426, -1, 428, 429, 430, 431, 432, 433, 434, 435, + -1, 437, 438, 439, -1, -1, 442, 443, -1, 445, + -1, -1, 448, 449, 450, 451, 452, 453, 454, 455, + -1, -1, 458, 459, 460, 461, -1, 463, 464, 465, + 466, -1, 468, 469, 470, 471, 472, -1, 474, 475, + -1, 477, 478, 479, 480, 481, 482, 483, 484, 485, + -1, -1, 488, -1, -1, 491, 492, 493, 494, 495, + 496, 3, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 508, 509, 510, 511, -1, -1, -1, -1, + -1, 23, 24, 25, 26, 27, 28, 29, 30, -1, + 32, 33, 34, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 44, 45, -1, -1, 48, 49, -1, 51, + 52, 53, 54, 55, -1, 57, 58, -1, -1, 61, + 62, 63, 64, 65, -1, -1, 68, 69, 70, 71, + 72, 73, 74, -1, 76, 77, 78, 79, 80, -1, + -1, -1, 84, 85, 86, 87, 88, 89, -1, 91, + 92, 93, -1, 95, 96, 97, 98, 99, 100, -1, + -1, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, -1, 119, -1, 121, + 122, 123, 124, 125, 126, -1, -1, 129, 130, 131, + 132, -1, -1, 135, 136, 137, 138, 139, -1, 141, + 142, 143, -1, 145, 146, 147, 148, -1, 150, 151, + 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, + -1, 163, -1, 165, 166, 167, 168, -1, 170, -1, + 172, -1, -1, -1, 176, 177, 178, -1, 180, 181, + 182, -1, 184, 185, -1, 187, -1, 189, 190, 191, + 192, 193, 194, 195, -1, 197, 198, 199, 200, -1, + 202, 203, 204, 205, 206, 207, 208, -1, 210, -1, + 212, 213, 214, 215, 216, 217, 218, 219, -1, 221, + -1, 223, -1, -1, 226, -1, 228, 229, 230, -1, + 232, 233, 234, -1, -1, 237, -1, 239, -1, -1, + 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, + 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, + 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, + 272, 273, -1, 275, 276, 277, 278, 279, -1, 281, + 282, -1, 284, -1, 286, 287, 288, 289, 290, 291, + -1, 293, 294, -1, -1, 297, 298, 299, -1, -1, + 302, 303, 304, -1, 306, -1, 308, 309, 310, 311, + 312, 313, 314, -1, 316, 317, 318, 319, 320, -1, + -1, -1, -1, 325, 326, 327, -1, 329, 330, 331, + 332, 333, 334, -1, 336, 337, 338, 339, 340, 341, + -1, 343, 344, 345, -1, 347, 348, 349, 350, 351, + 352, -1, 354, 355, 356, 357, 358, 359, 360, 361, + 362, 363, 364, 365, 366, -1, 368, 369, -1, 371, + 372, 373, 374, -1, 376, 377, 378, 379, 380, 381, + 382, 383, 384, 385, 386, 387, -1, -1, 390, 391, + 392, 393, 394, 395, 396, 397, 398, -1, -1, 401, + 402, 403, 404, -1, 406, 407, 408, 409, 410, 411, + 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, + 422, -1, -1, 425, 426, -1, 428, -1, 430, 431, + 432, 433, 434, 435, -1, 437, 438, 439, -1, -1, + 442, 443, 444, 445, 446, -1, 448, 449, 450, 451, + 452, 453, 454, 455, -1, -1, 458, 459, 460, -1, + -1, 463, 464, 465, 466, -1, 468, 469, 470, 471, + 472, 473, 474, 475, -1, 477, -1, 479, 480, 481, + 482, 483, 484, 485, -1, -1, 488, -1, -1, 491, + 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, + 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, + 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, + 33, -1, 35, 36, -1, -1, -1, -1, 23, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 33, -1, + 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, + -1, -1, -1, -1, -1, -1, -1, -1, 53, -1, + -1, -1, -1, 76, -1, -1, -1, 62, -1, -1, + -1, -1, -1, -1, 87, -1, -1, -1, -1, -1, + -1, 76, -1, -1, -1, -1, 99, -1, 101, -1, + -1, -1, 87, -1, -1, -1, -1, -1, -1, 112, + -1, -1, -1, -1, 99, -1, 101, -1, -1, -1, + -1, -1, -1, -1, 127, 128, -1, 112, -1, -1, + -1, -1, -1, -1, -1, 138, -1, -1, -1, -1, + -1, 144, 127, 128, -1, -1, -1, -1, -1, -1, + 153, -1, -1, 138, -1, -1, -1, -1, -1, 144, + -1, -1, -1, -1, -1, -1, -1, 170, 153, -1, + -1, 174, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 170, -1, -1, -1, 174, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 216, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, 216, -1, -1, -1, -1, -1, -1, -1, - -1, 243, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 243, + -1, -1, -1, 216, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 216, -1, -1, -1, -1, -1, -1, -1, -1, + 243, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 243, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 321, - 322, 323, -1, -1, -1, -1, -1, 329, -1, -1, - 332, -1, -1, -1, -1, -1, -1, 321, 322, 323, - -1, -1, -1, -1, -1, 329, -1, -1, 332, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 321, 322, + 323, -1, -1, -1, -1, -1, 329, -1, -1, 332, + -1, -1, -1, -1, -1, -1, 321, 322, 323, -1, + -1, -1, -1, -1, 329, -1, -1, 332, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, 363, -1, -1, -1, -1, -1, -1, -1, -1, - 372, -1, -1, -1, -1, -1, -1, -1, -1, 363, - -1, -1, -1, -1, -1, -1, 388, -1, 372, -1, - -1, -1, -1, 395, -1, -1, -1, 399, -1, -1, - -1, -1, -1, -1, 388, -1, -1, -1, -1, 411, - -1, 395, -1, -1, -1, 399, -1, -1, -1, -1, - -1, 423, -1, -1, -1, 427, -1, 411, -1, -1, - -1, -1, -1, -1, -1, -1, -1, -1, -1, 423, - -1, -1, -1, 427, -1, -1, 448, -1, -1, -1, + 363, -1, -1, -1, -1, -1, -1, -1, -1, 372, + -1, -1, -1, -1, -1, -1, -1, -1, 363, -1, + -1, -1, -1, -1, -1, 388, -1, 372, -1, -1, + -1, -1, 395, -1, -1, -1, 399, -1, -1, -1, + -1, -1, -1, 388, -1, -1, -1, -1, 411, -1, + 395, -1, -1, -1, 399, -1, -1, -1, -1, -1, + 423, -1, -1, -1, 427, -1, 411, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 423, -1, + -1, -1, 427, -1, -1, 448, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, 462, + -1, -1, -1, 448, -1, 468, -1, -1, -1, -1, + 473, -1, -1, -1, -1, 478, -1, 462, -1, -1, + -1, -1, -1, 468, -1, -1, -1, 490, 473, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - 462, -1, -1, -1, 448, -1, 468, -1, -1, -1, - -1, 473, -1, -1, -1, -1, 478, -1, 462, -1, - -1, -1, -1, -1, 468, -1, -1, -1, 490, 473, + -1, -1, -1, -1, -1, 490, -1, -1, -1, -1, + -1, 514, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 528, -1, -1, -1, 514, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 490, -1, -1, -1, - -1, -1, 514, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, -1, 528, -1, -1, -1, - 514, -1, -1, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, 528 + -1, -1, -1, 528 }; /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing @@ -20053,12 +20148,12 @@ static const yytype_uint16 yystos[] = 332, 363, 372, 388, 395, 399, 411, 423, 427, 448, 462, 465, 468, 473, 490, 514, 528, 539, 540, 541, 542, 557, 566, 568, 573, 589, 593, 594, 596, 603, - 604, 608, 615, 616, 618, 621, 622, 672, 678, 689, - 700, 701, 714, 715, 716, 717, 719, 721, 722, 726, - 786, 787, 967, 970, 973, 980, 981, 983, 986, 987, - 988, 995, 999, 1005, 1006, 1009, 1014, 1018, 1019, 1020, - 1027, 1030, 1031, 1032, 1035, 1036, 1038, 442, 493, 619, - 109, 205, 379, 390, 427, 480, 109, 194, 300, 1021, + 604, 608, 615, 616, 618, 621, 622, 674, 680, 691, + 702, 703, 716, 717, 718, 719, 721, 723, 724, 728, + 788, 789, 969, 972, 975, 982, 983, 985, 988, 989, + 990, 997, 1001, 1007, 1008, 1011, 1016, 1020, 1021, 1022, + 1029, 1032, 1033, 1034, 1037, 1038, 1040, 442, 493, 619, + 109, 205, 379, 390, 427, 480, 109, 194, 300, 1023, 619, 3, 23, 24, 25, 26, 27, 28, 29, 30, 32, 33, 34, 43, 44, 45, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 61, 62, @@ -20100,10 +20195,10 @@ static const yytype_uint16 yystos[] = 475, 477, 478, 479, 480, 481, 482, 483, 484, 485, 488, 491, 492, 493, 494, 495, 496, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, - 510, 511, 559, 868, 956, 960, 1041, 1042, 1043, 3, - 178, 250, 420, 559, 982, 1041, 295, 619, 56, 174, - 528, 711, 180, 244, 300, 320, 379, 432, 434, 457, - 460, 598, 670, 979, 5, 31, 332, 559, 560, 955, + 510, 511, 559, 870, 958, 962, 1043, 1044, 1045, 3, + 178, 250, 420, 559, 984, 1043, 295, 619, 56, 174, + 528, 713, 180, 244, 300, 320, 379, 432, 434, 457, + 460, 598, 672, 981, 5, 31, 332, 559, 560, 957, 3, 31, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46, 47, 50, 54, 55, 56, 57, 58, 59, 60, 66, 67, 72, 73, 75, 80, 81, 82, 83, @@ -20120,315 +20215,317 @@ static const yytype_uint16 yystos[] = 439, 440, 441, 444, 446, 447, 450, 456, 457, 461, 462, 467, 473, 474, 476, 478, 486, 487, 489, 490, 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, - 507, 565, 1041, 1045, 1047, 25, 82, 98, 148, 158, + 507, 565, 1043, 1047, 1049, 25, 82, 98, 148, 158, 171, 176, 205, 249, 254, 326, 341, 376, 379, 390, - 393, 413, 427, 434, 435, 445, 451, 480, 598, 673, - 674, 677, 619, 955, 33, 101, 138, 478, 528, 542, + 393, 413, 427, 434, 435, 445, 451, 480, 598, 675, + 676, 679, 619, 957, 33, 101, 138, 478, 528, 542, 557, 566, 568, 589, 593, 594, 603, 604, 608, 618, - 622, 672, 678, 689, 700, 701, 714, 967, 970, 973, - 980, 981, 991, 995, 999, 1005, 1009, 1014, 1027, 1030, - 1035, 1036, 1038, 109, 76, 67, 80, 82, 161, 235, + 622, 674, 680, 691, 702, 703, 716, 969, 972, 975, + 982, 983, 993, 997, 1001, 1007, 1011, 1016, 1029, 1032, + 1037, 1038, 1040, 109, 76, 67, 80, 82, 161, 235, 286, 296, 308, 327, 375, 422, 444, 446, 450, 473, - 528, 558, 559, 560, 715, 787, 789, 791, 792, 802, - 809, 810, 868, 870, 871, 109, 5, 559, 561, 1007, - 559, 955, 31, 180, 244, 394, 438, 442, 475, 559, - 1028, 1029, 1034, 619, 31, 133, 738, 739, 180, 244, - 379, 394, 438, 475, 1000, 1001, 1034, 619, 558, 559, - 560, 714, 726, 809, 427, 735, 558, 175, 528, 1011, - 528, 351, 727, 728, 955, 727, 715, 716, 1030, 0, - 531, 123, 215, 256, 464, 149, 220, 301, 456, 741, - 742, 792, 792, 715, 717, 719, 532, 478, 989, 216, - 31, 428, 438, 442, 558, 714, 194, 559, 194, 558, - 955, 194, 558, 194, 809, 194, 558, 280, 361, 561, + 528, 558, 559, 560, 717, 789, 791, 793, 794, 804, + 811, 812, 870, 872, 873, 109, 5, 559, 561, 1009, + 559, 957, 31, 180, 244, 394, 438, 442, 475, 559, + 1030, 1031, 1036, 619, 31, 133, 740, 741, 180, 244, + 379, 394, 438, 475, 1002, 1003, 1036, 619, 558, 559, + 560, 716, 728, 811, 427, 737, 558, 175, 528, 1013, + 528, 351, 729, 730, 957, 729, 717, 718, 1032, 0, + 531, 123, 215, 256, 464, 149, 220, 301, 456, 743, + 744, 794, 794, 717, 719, 721, 532, 478, 991, 216, + 31, 428, 438, 442, 558, 716, 194, 559, 194, 558, + 957, 194, 558, 194, 811, 194, 558, 280, 361, 561, 347, 620, 526, 530, 562, 563, 528, 83, 109, 176, - 205, 249, 379, 390, 427, 451, 480, 985, 109, 714, + 205, 249, 379, 390, 427, 451, 480, 987, 109, 716, 558, 432, 434, 432, 434, 361, 194, 558, 386, 176, - 249, 351, 390, 427, 451, 480, 696, 205, 31, 955, + 249, 351, 390, 427, 451, 480, 698, 205, 31, 957, 194, 565, 257, 445, 108, 427, 427, 480, 383, 386, - 194, 559, 675, 962, 194, 952, 955, 194, 955, 528, - 607, 300, 434, 991, 3, 473, 992, 994, 995, 997, - 998, 1041, 1045, 989, 559, 561, 982, 528, 528, 169, - 528, 715, 810, 528, 528, 558, 528, 528, 174, 528, - 528, 528, 528, 715, 787, 792, 802, 521, 562, 19, - 41, 559, 803, 804, 803, 388, 532, 718, 528, 715, - 809, 810, 38, 43, 102, 175, 211, 227, 238, 274, - 321, 328, 370, 389, 462, 806, 804, 41, 559, 803, - 805, 514, 814, 561, 517, 528, 528, 968, 1029, 1029, - 1029, 511, 226, 1029, 530, 295, 4, 6, 7, 8, + 194, 559, 677, 964, 194, 954, 957, 194, 957, 528, + 607, 300, 434, 993, 3, 473, 994, 996, 997, 999, + 1000, 1043, 1047, 991, 559, 561, 984, 528, 528, 169, + 528, 717, 812, 528, 528, 558, 528, 528, 174, 528, + 528, 528, 528, 717, 789, 794, 804, 521, 562, 19, + 41, 559, 805, 806, 805, 388, 532, 720, 528, 717, + 811, 812, 38, 43, 102, 175, 211, 227, 238, 274, + 321, 328, 370, 389, 462, 808, 806, 41, 559, 805, + 807, 514, 816, 561, 517, 528, 528, 970, 1031, 1031, + 1031, 511, 226, 1031, 530, 295, 4, 6, 7, 8, 9, 10, 40, 55, 57, 58, 66, 72, 73, 84, 113, 116, 118, 137, 154, 162, 167, 184, 185, 218, 219, 221, 231, 250, 273, 275, 280, 285, 288, 297, 348, 374, 403, 438, 439, 447, 461, 474, 512, 519, 520, 521, 526, 528, 533, 534, 535, 536, 559, 561, - 715, 776, 826, 829, 832, 833, 834, 836, 837, 838, - 839, 841, 842, 858, 860, 861, 862, 863, 864, 865, - 866, 867, 868, 869, 871, 872, 887, 888, 899, 921, - 927, 935, 936, 937, 956, 957, 958, 934, 936, 1000, - 1000, 561, 1000, 511, 1000, 174, 440, 517, 620, 562, - 809, 1015, 3, 173, 175, 478, 995, 1010, 1012, 173, - 1013, 559, 858, 905, 906, 727, 532, 528, 964, 529, - 529, 529, 541, 174, 300, 576, 222, 159, 1015, 31, - 133, 736, 736, 60, 736, 164, 169, 241, 292, 747, - 749, 750, 779, 781, 782, 783, 183, 295, 467, 295, - 741, 742, 528, 558, 1007, 428, 1033, 174, 511, 226, + 717, 778, 828, 831, 834, 835, 836, 838, 839, 840, + 841, 843, 844, 860, 862, 863, 864, 865, 866, 867, + 868, 869, 870, 871, 873, 874, 889, 890, 901, 923, + 929, 937, 938, 939, 958, 959, 960, 936, 938, 1002, + 1002, 561, 1002, 511, 1002, 174, 440, 517, 620, 562, + 811, 1017, 3, 173, 175, 478, 997, 1012, 1014, 173, + 1015, 559, 860, 907, 908, 729, 532, 528, 966, 529, + 529, 529, 541, 174, 300, 576, 222, 159, 1017, 31, + 133, 738, 738, 60, 738, 164, 169, 241, 292, 749, + 751, 752, 781, 783, 784, 785, 183, 295, 467, 295, + 743, 744, 528, 558, 1009, 428, 1035, 174, 511, 226, 154, 359, 154, 27, 33, 138, 299, 359, 363, 395, 470, 551, 554, 555, 359, 154, 41, 61, 107, 204, 255, 266, 278, 310, 359, 365, 390, 395, 411, 554, 609, 612, 154, 359, 395, 554, 154, 359, 395, 554, - 154, 1021, 41, 1022, 296, 495, 858, 928, 564, 565, + 154, 1023, 41, 1024, 296, 495, 860, 930, 564, 565, 563, 3, 31, 38, 43, 47, 50, 56, 60, 82, 84, 90, 102, 133, 173, 175, 178, 179, 196, 211, 224, 225, 227, 238, 240, 250, 274, 283, 305, 307, 328, 370, 389, 400, 420, 429, 450, 461, 476, 478, - 529, 742, 858, 908, 909, 959, 965, 1041, 1046, 858, - 427, 558, 559, 529, 528, 659, 379, 598, 670, 280, - 971, 194, 559, 597, 480, 194, 558, 194, 558, 1040, - 194, 558, 194, 558, 194, 558, 90, 976, 154, 494, - 91, 130, 313, 433, 194, 559, 154, 530, 963, 64, - 366, 532, 676, 154, 532, 676, 154, 295, 605, 606, - 858, 965, 361, 529, 532, 4, 162, 295, 447, 519, - 520, 561, 611, 614, 958, 990, 992, 993, 996, 991, - 440, 528, 708, 710, 858, 906, 528, 3, 69, 70, + 529, 744, 860, 910, 911, 961, 967, 1043, 1048, 860, + 427, 558, 559, 529, 528, 661, 379, 598, 672, 280, + 973, 194, 559, 597, 480, 194, 558, 194, 558, 1042, + 194, 558, 194, 558, 194, 558, 90, 978, 154, 494, + 91, 130, 313, 433, 194, 559, 154, 530, 965, 64, + 366, 532, 678, 154, 532, 678, 154, 295, 605, 606, + 860, 967, 361, 529, 532, 4, 162, 295, 447, 519, + 520, 561, 611, 614, 960, 992, 994, 995, 998, 993, + 440, 528, 710, 712, 860, 908, 528, 3, 69, 70, 110, 111, 114, 115, 191, 192, 258, 259, 260, 261, 262, 263, 264, 265, 268, 269, 343, 344, 384, 385, - 484, 485, 508, 509, 561, 844, 845, 846, 847, 848, - 849, 850, 851, 852, 853, 854, 855, 856, 911, 912, - 804, 805, 858, 558, 858, 913, 519, 520, 559, 859, - 860, 888, 899, 915, 528, 858, 905, 916, 858, 59, - 174, 236, 441, 858, 906, 919, 858, 529, 560, 528, - 429, 756, 757, 757, 738, 739, 792, 222, 733, 802, - 757, 47, 761, 757, 227, 38, 227, 389, 806, 227, - 305, 807, 792, 807, 227, 806, 528, 227, 807, 227, - 150, 202, 794, 227, 761, 528, 560, 528, 757, 302, - 858, 1002, 1004, 908, 3, 38, 43, 47, 50, 55, + 484, 485, 508, 509, 561, 846, 847, 848, 849, 850, + 851, 852, 853, 854, 855, 856, 857, 858, 913, 914, + 806, 807, 860, 558, 860, 915, 519, 520, 559, 861, + 862, 890, 901, 917, 528, 860, 907, 918, 860, 59, + 174, 236, 441, 860, 908, 921, 860, 529, 560, 528, + 429, 758, 759, 759, 740, 741, 794, 222, 735, 804, + 759, 47, 763, 759, 227, 38, 227, 389, 808, 227, + 305, 809, 794, 809, 227, 808, 528, 227, 809, 227, + 150, 202, 796, 227, 763, 528, 560, 528, 759, 302, + 860, 1004, 1006, 910, 3, 38, 43, 47, 50, 55, 56, 57, 58, 60, 72, 73, 82, 84, 90, 102, 113, 116, 167, 173, 175, 179, 196, 211, 218, 219, 221, 224, 225, 227, 238, 240, 250, 273, 274, 275, 283, 288, 305, 307, 328, 348, 370, 374, 389, 396, 400, 403, 420, 429, 438, 439, 450, 456, 461, 474, - 478, 820, 822, 823, 825, 827, 829, 831, 833, 834, - 835, 837, 838, 841, 842, 910, 961, 1041, 1044, 41, - 239, 559, 528, 526, 715, 477, 840, 858, 925, 840, - 840, 528, 528, 828, 828, 331, 715, 528, 830, 952, - 536, 72, 73, 840, 858, 828, 528, 528, 492, 514, - 528, 843, 528, 843, 528, 858, 858, 858, 84, 150, - 938, 942, 858, 906, 907, 715, 858, 905, 565, 9, - 560, 889, 890, 891, 19, 530, 562, 929, 562, 528, - 561, 528, 528, 561, 958, 3, 8, 11, 15, 16, + 478, 822, 824, 825, 827, 829, 831, 833, 835, 836, + 837, 839, 840, 843, 844, 912, 963, 1043, 1046, 41, + 239, 559, 528, 526, 717, 477, 842, 860, 927, 842, + 842, 528, 528, 830, 830, 331, 717, 528, 832, 954, + 536, 72, 73, 842, 860, 830, 528, 528, 492, 514, + 528, 845, 528, 845, 528, 860, 860, 860, 84, 150, + 940, 944, 860, 908, 909, 717, 860, 907, 565, 9, + 560, 891, 892, 893, 19, 530, 562, 931, 562, 528, + 561, 528, 528, 561, 960, 3, 8, 11, 15, 16, 17, 18, 20, 21, 22, 37, 41, 47, 54, 81, 179, 196, 201, 224, 225, 240, 280, 283, 297, 300, 400, 512, 515, 516, 517, 519, 520, 521, 522, 523, - 524, 897, 898, 899, 901, 932, 491, 873, 307, 858, - 532, 733, 528, 561, 733, 3, 118, 244, 561, 611, - 842, 1003, 105, 1004, 1004, 41, 559, 529, 532, 989, - 532, 529, 728, 952, 953, 467, 729, 1015, 195, 361, - 222, 1015, 659, 395, 717, 717, 31, 743, 744, 858, - 60, 717, 737, 166, 277, 767, 229, 278, 347, 398, - 464, 4, 9, 31, 762, 858, 519, 520, 763, 764, - 858, 860, 779, 780, 750, 749, 747, 748, 169, 782, - 290, 784, 60, 723, 724, 725, 795, 859, 936, 936, - 747, 779, 906, 964, 174, 479, 1008, 558, 239, 559, + 524, 899, 900, 901, 903, 934, 491, 875, 307, 860, + 532, 735, 528, 561, 735, 3, 118, 244, 561, 611, + 844, 1005, 105, 1006, 1006, 41, 559, 529, 532, 991, + 532, 529, 730, 954, 955, 467, 731, 1017, 195, 361, + 222, 1017, 661, 395, 719, 719, 31, 745, 746, 860, + 60, 719, 739, 166, 277, 769, 229, 278, 347, 398, + 464, 4, 9, 31, 764, 860, 519, 520, 765, 766, + 860, 862, 781, 782, 752, 751, 749, 750, 169, 784, + 290, 786, 60, 725, 726, 727, 797, 861, 938, 938, + 749, 781, 908, 966, 174, 479, 1010, 558, 239, 559, 440, 558, 75, 83, 94, 171, 194, 335, 457, 549, - 550, 559, 639, 666, 83, 94, 567, 94, 567, 528, + 550, 559, 639, 668, 83, 94, 567, 94, 567, 528, 440, 316, 406, 528, 637, 248, 316, 406, 460, 637, - 94, 532, 440, 558, 3, 825, 611, 60, 613, 611, + 94, 532, 440, 558, 3, 827, 611, 60, 613, 611, 611, 107, 255, 266, 60, 440, 490, 514, 610, 271, - 379, 610, 612, 809, 94, 440, 567, 379, 558, 440, - 379, 1021, 561, 559, 528, 1026, 527, 19, 908, 908, - 909, 195, 364, 740, 532, 741, 742, 13, 14, 224, - 224, 440, 440, 559, 658, 663, 490, 709, 558, 386, - 351, 390, 427, 451, 480, 696, 154, 101, 594, 622, - 972, 973, 1036, 280, 201, 599, 558, 280, 595, 609, - 280, 528, 659, 41, 280, 41, 280, 659, 280, 528, - 690, 691, 692, 693, 694, 695, 697, 194, 559, 653, - 977, 565, 154, 174, 617, 675, 564, 530, 962, 952, - 955, 955, 962, 529, 532, 13, 991, 997, 4, 958, - 4, 958, 561, 565, 1024, 1025, 56, 103, 124, 142, - 147, 170, 173, 189, 285, 293, 315, 345, 712, 41, - 529, 858, 529, 174, 532, 529, 324, 914, 529, 859, - 859, 11, 15, 16, 20, 21, 22, 201, 224, 297, - 515, 516, 517, 519, 520, 521, 522, 523, 524, 899, - 859, 529, 811, 812, 870, 169, 174, 917, 918, 532, - 529, 41, 919, 906, 919, 919, 174, 529, 41, 803, - 528, 953, 4, 9, 559, 751, 752, 754, 755, 863, - 936, 934, 180, 244, 427, 432, 434, 460, 558, 734, - 487, 815, 529, 528, 757, 792, 792, 227, 792, 295, - 467, 808, 792, 227, 936, 792, 792, 287, 287, 528, - 792, 757, 560, 816, 817, 528, 560, 816, 532, 529, - 532, 530, 528, 825, 528, 528, 530, 824, 40, 824, - 528, 844, 845, 846, 847, 848, 849, 850, 851, 852, - 853, 854, 855, 856, 857, 529, 532, 828, 568, 573, - 700, 701, 714, 969, 1014, 1030, 906, 907, 528, 486, - 922, 923, 858, 907, 958, 19, 858, 892, 893, 894, - 895, 840, 840, 8, 15, 16, 20, 21, 22, 515, - 516, 517, 519, 520, 521, 522, 523, 524, 559, 897, - 902, 529, 906, 438, 438, 958, 958, 858, 528, 528, - 560, 939, 361, 946, 169, 527, 529, 532, 19, 532, - 537, 858, 521, 563, 906, 958, 858, 857, 857, 822, - 858, 858, 858, 858, 858, 858, 858, 858, 5, 565, - 966, 438, 46, 424, 933, 962, 858, 858, 528, 715, - 864, 920, 927, 133, 162, 280, 285, 290, 447, 458, - 858, 285, 528, 858, 440, 54, 179, 196, 201, 240, - 400, 858, 858, 858, 858, 858, 858, 858, 858, 858, - 858, 31, 39, 405, 896, 526, 530, 931, 183, 165, - 874, 374, 528, 888, 937, 174, 788, 908, 788, 528, - 561, 559, 558, 1010, 558, 1018, 858, 532, 529, 229, - 41, 467, 1017, 558, 570, 467, 528, 559, 575, 585, - 586, 588, 42, 127, 745, 532, 467, 745, 271, 717, - 374, 375, 519, 520, 764, 766, 860, 398, 229, 296, - 319, 319, 532, 523, 4, 765, 958, 765, 374, 375, - 766, 558, 951, 284, 402, 785, 528, 953, 954, 532, - 183, 467, 201, 183, 222, 780, 748, 529, 559, 561, - 559, 561, 359, 559, 359, 554, 528, 194, 550, 955, - 229, 280, 229, 467, 528, 642, 649, 650, 821, 822, - 530, 547, 548, 955, 559, 194, 955, 194, 549, 27, - 138, 395, 546, 553, 565, 633, 647, 955, 60, 60, - 565, 641, 662, 60, 60, 955, 551, 955, 359, 395, - 554, 609, 611, 962, 955, 611, 962, 955, 611, 359, - 395, 554, 955, 955, 549, 955, 359, 395, 554, 955, - 955, 561, 1022, 1025, 520, 858, 928, 741, 741, 741, - 287, 287, 529, 476, 909, 740, 858, 858, 285, 561, - 984, 285, 984, 559, 340, 707, 529, 532, 293, 174, - 440, 703, 971, 597, 480, 558, 558, 1040, 558, 558, - 558, 558, 300, 670, 154, 3, 528, 528, 154, 154, - 240, 559, 639, 651, 654, 657, 667, 669, 490, 492, - 644, 153, 714, 154, 145, 590, 822, 154, 490, 978, - 154, 3, 43, 47, 50, 56, 82, 84, 90, 102, - 173, 175, 178, 179, 196, 211, 224, 225, 227, 238, - 240, 250, 274, 283, 305, 307, 328, 370, 400, 420, - 429, 450, 461, 478, 529, 698, 699, 965, 1041, 532, - 532, 41, 280, 295, 559, 3, 676, 564, 676, 295, - 676, 605, 858, 708, 858, 1023, 529, 532, 41, 706, - 561, 706, 280, 285, 345, 706, 60, 706, 822, 529, - 858, 858, 858, 917, 822, 859, 859, 859, 859, 859, - 859, 133, 280, 290, 859, 859, 859, 859, 859, 859, - 859, 859, 859, 859, 529, 532, 41, 813, 858, 858, - 918, 917, 822, 529, 529, 529, 906, 822, 953, 529, - 319, 375, 523, 528, 528, 733, 432, 434, 432, 434, - 558, 735, 735, 735, 858, 183, 768, 439, 479, 759, - 760, 808, 808, 792, 858, 528, 792, 169, 808, 528, - 560, 799, 808, 822, 529, 532, 816, 529, 1002, 3, - 910, 40, 824, 559, 819, 819, 3, 526, 526, 958, - 440, 440, 440, 440, 822, 464, 529, 527, 906, 858, - 140, 923, 924, 529, 529, 529, 858, 19, 532, 537, - 530, 529, 529, 511, 511, 529, 529, 529, 858, 939, - 940, 941, 530, 528, 858, 943, 359, 950, 952, 858, - 858, 889, 942, 529, 529, 529, 511, 859, 859, 147, - 906, 174, 133, 162, 285, 290, 447, 458, 528, 147, - 902, 858, 424, 933, 858, 920, 858, 440, 528, 715, - 858, 928, 564, 528, 528, 157, 875, 789, 790, 815, - 741, 815, 958, 857, 964, 964, 528, 254, 280, 732, - 790, 487, 1016, 41, 60, 571, 792, 581, 588, 929, - 532, 788, 517, 513, 746, 744, 297, 897, 900, 746, - 4, 958, 766, 296, 464, 763, 532, 247, 953, 723, - 60, 936, 528, 560, 60, 271, 1008, 1008, 440, 440, - 858, 280, 666, 528, 154, 528, 642, 205, 663, 664, - 623, 41, 178, 632, 660, 564, 548, 623, 27, 138, - 363, 365, 395, 543, 544, 545, 555, 556, 154, 676, - 154, 676, 633, 647, 633, 529, 532, 561, 626, 517, - 530, 529, 532, 528, 528, 440, 379, 94, 440, 567, - 379, 440, 440, 440, 379, 1022, 1026, 529, 19, 19, - 527, 740, 740, 740, 909, 529, 528, 702, 3, 414, - 415, 528, 561, 713, 863, 658, 707, 599, 558, 595, - 528, 41, 41, 659, 693, 695, 971, 361, 427, 597, - 565, 601, 602, 663, 558, 558, 1040, 558, 649, 650, - 529, 532, 293, 637, 293, 295, 636, 955, 490, 1039, - 558, 528, 715, 558, 637, 41, 558, 529, 532, 821, - 822, 691, 697, 694, 697, 427, 858, 154, 558, 617, - 962, 1024, 561, 561, 285, 663, 521, 663, 561, 521, - 663, 561, 529, 529, 918, 174, 133, 290, 528, 814, - 811, 528, 529, 529, 529, 559, 752, 815, 735, 735, - 735, 735, 558, 558, 558, 60, 188, 777, 14, 529, - 808, 953, 528, 796, 797, 798, 861, 864, 953, 169, - 81, 818, 817, 529, 529, 526, 822, 529, 532, 529, - 527, 958, 958, 529, 845, 847, 848, 849, 848, 849, - 849, 529, 436, 858, 144, 858, 892, 902, 843, 843, - 529, 532, 529, 560, 858, 943, 944, 945, 41, 528, - 939, 947, 201, 529, 946, 857, 858, 37, 37, 858, - 529, 858, 174, 528, 910, 858, 529, 147, 859, 859, - 147, 147, 858, 858, 527, 19, 528, 930, 742, 487, - 858, 306, 879, 532, 768, 740, 768, 529, 559, 730, - 731, 926, 254, 528, 858, 367, 579, 559, 271, 327, - 118, 309, 528, 569, 714, 808, 529, 532, 575, 1016, - 858, 166, 234, 528, 746, 296, 558, 529, 954, 183, - 715, 716, 936, 954, 955, 559, 955, 529, 154, 664, - 550, 664, 623, 653, 532, 529, 120, 209, 278, 280, - 648, 528, 34, 60, 671, 660, 75, 81, 94, 118, - 120, 209, 280, 285, 335, 353, 457, 467, 628, 629, - 643, 178, 118, 193, 280, 637, 610, 108, 118, 178, - 280, 413, 416, 612, 637, 395, 545, 451, 955, 549, - 553, 3, 38, 43, 47, 50, 56, 60, 82, 84, - 90, 102, 173, 175, 179, 196, 211, 224, 225, 227, - 238, 240, 250, 274, 279, 283, 297, 305, 307, 328, - 370, 389, 396, 400, 420, 429, 450, 456, 461, 478, - 519, 520, 561, 611, 624, 665, 822, 900, 959, 1041, - 1047, 565, 662, 906, 743, 955, 955, 955, 955, 549, - 955, 955, 955, 955, 955, 1026, 928, 928, 529, 529, - 529, 741, 108, 379, 530, 858, 610, 713, 528, 528, - 657, 714, 590, 978, 670, 194, 558, 599, 600, 858, - 529, 532, 529, 595, 528, 41, 646, 644, 559, 654, - 87, 607, 108, 278, 41, 561, 591, 592, 659, 714, - 693, 695, 529, 699, 13, 14, 41, 41, 715, 716, - 653, 467, 975, 676, 663, 859, 174, 528, 910, 816, - 529, 532, 529, 768, 558, 558, 558, 558, 31, 104, - 184, 373, 528, 769, 770, 771, 772, 773, 774, 775, - 858, 858, 489, 876, 858, 529, 860, 903, 904, 201, - 183, 793, 797, 529, 799, 800, 801, 962, 824, 958, - 824, 559, 824, 527, 527, 858, 939, 532, 529, 559, - 947, 948, 949, 41, 858, 860, 950, 858, 858, 858, - 910, 529, 858, 37, 37, 858, 858, 147, 529, 520, - 928, 529, 908, 529, 858, 529, 528, 559, 880, 777, - 529, 777, 561, 529, 532, 969, 935, 473, 426, 466, - 580, 559, 574, 584, 295, 577, 486, 684, 686, 687, - 688, 517, 588, 579, 902, 60, 529, 529, 472, 473, - 720, 623, 550, 529, 529, 490, 656, 121, 197, 207, - 120, 469, 858, 118, 41, 528, 962, 955, 859, 121, - 197, 120, 285, 229, 558, 656, 89, 671, 194, 285, - 611, 858, 671, 285, 519, 520, 614, 559, 821, 676, - 676, 3, 959, 963, 517, 529, 529, 440, 440, 527, - 527, 740, 529, 529, 559, 529, 708, 467, 704, 705, - 602, 663, 529, 1039, 41, 427, 280, 528, 528, 601, - 978, 657, 153, 714, 151, 203, 636, 123, 138, 334, - 1039, 108, 590, 529, 532, 978, 490, 1037, 858, 858, - 427, 295, 559, 974, 528, 859, 910, 529, 529, 9, - 360, 758, 777, 528, 397, 528, 529, 532, 559, 877, - 878, 342, 778, 532, 529, 528, 560, 60, 529, 201, - 529, 800, 527, 822, 943, 532, 529, 559, 527, 194, - 529, 858, 858, 858, 19, 19, 527, 529, 529, 559, - 881, 876, 561, 876, 926, 529, 532, 472, 929, 529, - 532, 92, 579, 253, 280, 688, 579, 858, 529, 954, - 954, 353, 656, 528, 645, 623, 529, 193, 528, 858, - 280, 629, 656, 659, 955, 41, 154, 818, 963, 523, - 624, 955, 955, 529, 610, 125, 529, 529, 644, 714, - 558, 154, 602, 41, 529, 955, 1039, 31, 86, 95, - 119, 193, 206, 413, 416, 640, 640, 375, 375, 561, - 41, 65, 75, 244, 715, 558, 528, 559, 578, 587, - 870, 529, 529, 528, 876, 906, 528, 906, 771, 41, - 532, 858, 467, 753, 860, 936, 953, 804, 528, 804, - 947, 858, 928, 928, 315, 882, 778, 778, 714, 309, - 714, 574, 295, 528, 572, 37, 679, 253, 558, 623, - 565, 652, 655, 417, 482, 630, 631, 528, 625, 858, - 529, 252, 668, 193, 467, 552, 523, 451, 708, 561, - 978, 636, 1037, 528, 558, 529, 714, 644, 607, 714, - 75, 298, 75, 975, 858, 81, 582, 529, 532, 582, - 9, 778, 529, 770, 529, 880, 878, 377, 529, 936, - 527, 527, 527, 60, 741, 753, 753, 580, 94, 587, - 134, 858, 436, 60, 685, 659, 517, 529, 532, 609, - 529, 278, 638, 175, 314, 401, 295, 634, 635, 661, - 625, 858, 451, 41, 528, 1037, 636, 1039, 1037, 298, - 298, 528, 529, 962, 583, 962, 978, 578, 583, 529, - 753, 529, 755, 529, 905, 186, 346, 375, 883, 472, - 955, 529, 281, 464, 123, 134, 146, 215, 464, 682, - 407, 431, 679, 668, 624, 655, 529, 631, 207, 123, - 464, 295, 661, 295, 634, 714, 587, 582, 745, 815, - 745, 54, 105, 453, 858, 884, 885, 884, 884, 529, - 714, 815, 395, 281, 683, 858, 118, 528, 571, 680, - 395, 571, 436, 635, 64, 278, 366, 395, 627, 627, - 1037, 529, 583, 746, 746, 885, 374, 168, 330, 168, - 330, 150, 886, 886, 886, 586, 473, 584, 521, 681, - 473, 521, 586, 682, 623, 26, 118, 285, 978, 745, - 37, 105, 183, 278, 437, 815, 529, 528, 815, 746, - 885, 374, 303, 906, 529 + 379, 610, 612, 811, 94, 440, 567, 379, 558, 440, + 379, 1023, 561, 559, 528, 1028, 527, 19, 910, 910, + 911, 195, 364, 742, 532, 743, 744, 13, 14, 224, + 224, 440, 440, 559, 660, 665, 490, 711, 558, 386, + 351, 390, 427, 451, 480, 698, 154, 101, 594, 622, + 974, 975, 1038, 280, 201, 599, 558, 280, 595, 609, + 280, 528, 661, 41, 280, 41, 280, 661, 280, 528, + 692, 693, 694, 695, 696, 697, 699, 194, 559, 655, + 979, 565, 154, 174, 617, 677, 564, 530, 964, 954, + 957, 957, 964, 529, 532, 13, 993, 999, 4, 960, + 4, 960, 561, 565, 1026, 1027, 56, 103, 124, 142, + 147, 170, 173, 189, 285, 293, 315, 345, 714, 41, + 529, 860, 529, 174, 532, 529, 324, 916, 529, 861, + 861, 11, 15, 16, 20, 21, 22, 201, 224, 297, + 515, 516, 517, 519, 520, 521, 522, 523, 524, 901, + 861, 529, 813, 814, 872, 169, 174, 919, 920, 532, + 529, 41, 921, 908, 921, 921, 174, 529, 41, 805, + 528, 955, 4, 9, 559, 753, 754, 756, 757, 865, + 938, 936, 180, 244, 427, 432, 434, 460, 558, 736, + 487, 817, 529, 528, 759, 794, 794, 227, 794, 295, + 467, 810, 794, 227, 938, 794, 794, 287, 287, 528, + 794, 759, 560, 818, 819, 528, 560, 818, 532, 529, + 532, 530, 528, 827, 528, 528, 530, 826, 40, 826, + 528, 846, 847, 848, 849, 850, 851, 852, 853, 854, + 855, 856, 857, 858, 859, 529, 532, 830, 568, 573, + 702, 703, 716, 971, 1016, 1032, 908, 909, 528, 486, + 924, 925, 860, 909, 960, 19, 860, 894, 895, 896, + 897, 842, 842, 8, 15, 16, 20, 21, 22, 515, + 516, 517, 519, 520, 521, 522, 523, 524, 559, 899, + 904, 529, 908, 438, 438, 960, 960, 860, 528, 528, + 560, 941, 361, 948, 169, 527, 529, 532, 19, 532, + 537, 860, 521, 563, 908, 960, 860, 859, 859, 824, + 860, 860, 860, 860, 860, 860, 860, 860, 5, 565, + 968, 438, 46, 424, 935, 964, 860, 860, 528, 717, + 866, 922, 929, 133, 162, 280, 285, 290, 447, 458, + 860, 285, 528, 860, 440, 54, 179, 196, 201, 240, + 400, 860, 860, 860, 860, 860, 860, 860, 860, 860, + 860, 31, 39, 405, 898, 526, 530, 933, 183, 165, + 876, 374, 528, 890, 939, 174, 790, 910, 790, 528, + 561, 559, 558, 1012, 558, 1020, 860, 532, 529, 229, + 41, 467, 1019, 558, 570, 467, 528, 559, 575, 585, + 586, 588, 42, 127, 747, 532, 467, 747, 271, 719, + 374, 375, 519, 520, 766, 768, 862, 398, 229, 296, + 319, 319, 532, 523, 4, 767, 960, 767, 374, 375, + 768, 558, 953, 284, 402, 787, 528, 955, 956, 532, + 183, 467, 201, 183, 222, 782, 750, 529, 559, 561, + 559, 561, 359, 559, 359, 554, 528, 194, 550, 957, + 229, 280, 229, 467, 528, 642, 651, 652, 823, 824, + 530, 547, 548, 957, 559, 194, 957, 194, 549, 27, + 138, 395, 546, 553, 565, 633, 649, 957, 60, 60, + 561, 565, 641, 664, 60, 60, 957, 551, 957, 359, + 395, 554, 609, 611, 964, 957, 611, 964, 957, 611, + 359, 395, 554, 957, 957, 549, 957, 359, 395, 554, + 957, 957, 561, 1024, 1027, 520, 860, 930, 743, 743, + 743, 287, 287, 529, 476, 911, 742, 860, 860, 285, + 561, 986, 285, 986, 559, 340, 709, 529, 532, 293, + 174, 440, 705, 973, 597, 480, 558, 558, 1042, 558, + 558, 558, 558, 300, 672, 154, 3, 528, 528, 154, + 154, 240, 559, 639, 653, 656, 659, 669, 671, 490, + 492, 646, 153, 716, 154, 145, 590, 824, 154, 490, + 980, 154, 3, 43, 47, 50, 56, 82, 84, 90, + 102, 173, 175, 178, 179, 196, 211, 224, 225, 227, + 238, 240, 250, 274, 283, 305, 307, 328, 370, 400, + 420, 429, 450, 461, 478, 529, 700, 701, 967, 1043, + 532, 532, 41, 280, 295, 559, 3, 678, 564, 678, + 295, 678, 605, 860, 710, 860, 1025, 529, 532, 41, + 708, 561, 708, 280, 285, 345, 708, 60, 708, 824, + 529, 860, 860, 860, 919, 824, 861, 861, 861, 861, + 861, 861, 133, 280, 290, 861, 861, 861, 861, 861, + 861, 861, 861, 861, 861, 529, 532, 41, 815, 860, + 860, 920, 919, 824, 529, 529, 529, 908, 824, 955, + 529, 319, 375, 523, 528, 528, 735, 432, 434, 432, + 434, 558, 737, 737, 737, 860, 183, 770, 439, 479, + 761, 762, 810, 810, 794, 860, 528, 794, 169, 810, + 528, 560, 801, 810, 824, 529, 532, 818, 529, 1004, + 3, 912, 40, 826, 559, 821, 821, 3, 526, 526, + 960, 440, 440, 440, 440, 824, 464, 529, 527, 908, + 860, 140, 925, 926, 529, 529, 529, 860, 19, 532, + 537, 530, 529, 529, 511, 511, 529, 529, 529, 860, + 941, 942, 943, 530, 528, 860, 945, 359, 952, 954, + 860, 860, 891, 944, 529, 529, 529, 511, 861, 861, + 147, 908, 174, 133, 162, 285, 290, 447, 458, 528, + 147, 904, 860, 424, 935, 860, 922, 860, 440, 528, + 717, 860, 930, 564, 528, 528, 157, 877, 791, 792, + 817, 743, 817, 960, 859, 966, 966, 528, 254, 280, + 734, 792, 487, 1018, 41, 60, 571, 794, 581, 588, + 931, 532, 790, 517, 513, 748, 746, 297, 899, 902, + 748, 4, 960, 768, 296, 464, 765, 532, 247, 955, + 725, 60, 938, 528, 560, 60, 271, 1010, 1010, 440, + 440, 860, 280, 668, 528, 154, 528, 642, 205, 665, + 666, 623, 41, 178, 632, 662, 564, 548, 623, 27, + 138, 363, 365, 395, 543, 544, 545, 555, 556, 154, + 678, 154, 678, 633, 649, 633, 529, 532, 561, 626, + 517, 517, 530, 529, 532, 528, 528, 440, 379, 94, + 440, 567, 379, 440, 440, 440, 379, 1024, 1028, 529, + 19, 19, 527, 742, 742, 742, 911, 529, 528, 704, + 3, 414, 415, 528, 561, 715, 865, 660, 709, 599, + 558, 595, 528, 41, 41, 661, 695, 697, 973, 361, + 427, 597, 565, 601, 602, 665, 558, 558, 1042, 558, + 651, 652, 529, 532, 293, 637, 293, 295, 636, 957, + 490, 1041, 558, 528, 717, 558, 637, 41, 558, 529, + 532, 823, 824, 693, 699, 696, 699, 427, 860, 154, + 558, 617, 964, 1026, 561, 561, 285, 665, 521, 665, + 561, 521, 665, 561, 529, 529, 920, 174, 133, 290, + 528, 816, 813, 528, 529, 529, 529, 559, 754, 817, + 737, 737, 737, 737, 558, 558, 558, 60, 188, 779, + 14, 529, 810, 955, 528, 798, 799, 800, 863, 866, + 955, 169, 81, 820, 819, 529, 529, 526, 824, 529, + 532, 529, 527, 960, 960, 529, 847, 849, 850, 851, + 850, 851, 851, 529, 436, 860, 144, 860, 894, 904, + 845, 845, 529, 532, 529, 560, 860, 945, 946, 947, + 41, 528, 941, 949, 201, 529, 948, 859, 860, 37, + 37, 860, 529, 860, 174, 528, 912, 860, 529, 147, + 861, 861, 147, 147, 860, 860, 527, 19, 528, 932, + 744, 487, 860, 306, 881, 532, 770, 742, 770, 529, + 559, 732, 733, 928, 254, 528, 860, 367, 579, 559, + 271, 327, 118, 309, 528, 569, 716, 810, 529, 532, + 575, 1018, 860, 166, 234, 528, 748, 296, 558, 529, + 956, 183, 717, 718, 938, 956, 957, 559, 957, 529, + 154, 666, 550, 666, 623, 655, 532, 529, 120, 209, + 278, 280, 650, 528, 34, 60, 673, 662, 75, 81, + 94, 118, 120, 209, 280, 285, 335, 353, 457, 467, + 628, 629, 643, 178, 118, 193, 280, 637, 610, 108, + 118, 178, 280, 413, 416, 612, 637, 395, 545, 451, + 957, 549, 553, 860, 860, 565, 664, 908, 745, 957, + 957, 957, 957, 549, 957, 957, 957, 957, 957, 1028, + 930, 930, 529, 529, 529, 743, 108, 379, 530, 860, + 610, 715, 528, 528, 659, 716, 590, 980, 672, 194, + 558, 599, 600, 860, 529, 532, 529, 595, 528, 41, + 648, 644, 559, 656, 87, 607, 108, 278, 41, 561, + 591, 592, 661, 716, 695, 697, 529, 701, 13, 14, + 41, 41, 717, 718, 655, 467, 977, 678, 665, 861, + 174, 528, 912, 818, 529, 532, 529, 770, 558, 558, + 558, 558, 31, 104, 184, 373, 528, 771, 772, 773, + 774, 775, 776, 777, 860, 860, 489, 878, 860, 529, + 862, 905, 906, 201, 183, 795, 799, 529, 801, 802, + 803, 964, 826, 960, 826, 559, 826, 527, 527, 860, + 941, 532, 529, 559, 949, 950, 951, 41, 860, 862, + 952, 860, 860, 860, 912, 529, 860, 37, 37, 860, + 860, 147, 529, 520, 930, 529, 910, 529, 860, 529, + 528, 559, 882, 779, 529, 779, 561, 529, 532, 971, + 937, 473, 426, 466, 580, 559, 574, 584, 295, 577, + 486, 686, 688, 689, 690, 517, 588, 579, 904, 60, + 529, 529, 472, 473, 722, 623, 550, 529, 529, 490, + 658, 121, 197, 207, 120, 469, 860, 118, 41, 528, + 964, 957, 861, 121, 197, 120, 285, 229, 558, 658, + 89, 673, 194, 285, 611, 860, 673, 285, 519, 520, + 614, 559, 823, 678, 678, 517, 529, 529, 440, 440, + 527, 527, 742, 529, 529, 559, 529, 710, 467, 706, + 707, 602, 665, 529, 1041, 41, 427, 280, 528, 528, + 601, 980, 659, 153, 716, 151, 203, 316, 406, 645, + 646, 123, 138, 334, 1041, 108, 590, 529, 532, 980, + 490, 1039, 860, 860, 427, 295, 559, 976, 528, 861, + 912, 529, 529, 9, 360, 760, 779, 528, 397, 528, + 529, 532, 559, 879, 880, 342, 780, 532, 529, 528, + 560, 60, 529, 201, 529, 802, 527, 824, 945, 532, + 529, 559, 527, 194, 529, 860, 860, 860, 19, 19, + 527, 529, 529, 559, 883, 878, 561, 878, 928, 529, + 532, 472, 931, 529, 532, 92, 579, 253, 280, 690, + 579, 860, 529, 956, 956, 353, 658, 528, 647, 623, + 529, 193, 528, 860, 280, 629, 658, 661, 957, 41, + 154, 820, 3, 38, 43, 47, 50, 56, 60, 82, + 84, 90, 102, 173, 175, 179, 196, 211, 224, 225, + 227, 238, 240, 250, 274, 279, 283, 297, 305, 307, + 328, 370, 389, 396, 400, 420, 429, 450, 456, 461, + 478, 519, 520, 561, 611, 624, 667, 824, 902, 961, + 1043, 1049, 957, 957, 529, 610, 125, 529, 529, 644, + 716, 558, 154, 602, 41, 529, 957, 1041, 31, 86, + 95, 119, 193, 206, 413, 416, 640, 640, 60, 60, + 636, 375, 375, 561, 41, 65, 75, 244, 717, 558, + 528, 559, 578, 587, 872, 529, 529, 528, 878, 908, + 528, 908, 773, 41, 532, 860, 467, 755, 862, 938, + 955, 806, 528, 806, 949, 860, 930, 930, 315, 884, + 780, 780, 716, 309, 716, 574, 295, 528, 572, 37, + 681, 253, 558, 623, 565, 654, 657, 417, 482, 630, + 631, 528, 625, 860, 529, 252, 670, 193, 467, 552, + 3, 961, 965, 710, 561, 980, 646, 1039, 528, 558, + 529, 716, 644, 607, 528, 528, 716, 75, 298, 75, + 977, 860, 81, 582, 529, 532, 582, 9, 780, 529, + 772, 529, 882, 880, 377, 529, 938, 527, 527, 527, + 60, 743, 755, 755, 580, 94, 587, 134, 860, 436, + 60, 687, 661, 517, 529, 532, 609, 529, 278, 638, + 175, 314, 401, 295, 634, 635, 663, 625, 860, 965, + 523, 41, 636, 528, 1039, 646, 1041, 908, 908, 1039, + 298, 298, 528, 529, 964, 583, 964, 980, 578, 583, + 529, 755, 529, 757, 529, 907, 186, 346, 375, 885, + 472, 957, 529, 281, 464, 123, 134, 146, 215, 464, + 684, 407, 431, 681, 670, 624, 657, 529, 631, 207, + 123, 464, 295, 663, 295, 634, 523, 451, 716, 636, + 529, 529, 587, 582, 747, 817, 747, 54, 105, 453, + 860, 886, 887, 886, 886, 529, 716, 817, 395, 281, + 685, 860, 118, 528, 571, 682, 395, 571, 436, 635, + 64, 278, 366, 395, 627, 627, 451, 1039, 529, 583, + 748, 748, 887, 374, 168, 330, 168, 330, 150, 888, + 888, 888, 586, 473, 584, 521, 683, 473, 521, 586, + 684, 623, 26, 118, 285, 980, 747, 37, 105, 183, + 278, 437, 817, 529, 528, 817, 748, 887, 374, 303, + 908, 529 }; #define yyerrok (yyerrstatus = 0) @@ -21271,14 +21368,14 @@ YYLTYPE yylloc; switch (yyn) { case 2: -#line 523 "third_party/libpg_query/grammar/grammar.y" +#line 525 "third_party/libpg_query/grammar/grammar.y" { pg_yyget_extra(yyscanner)->parsetree = (yyvsp[(1) - (1)].list); ;} break; case 3: -#line 539 "third_party/libpg_query/grammar/grammar.y" +#line 541 "third_party/libpg_query/grammar/grammar.y" { if ((yyvsp[(1) - (3)].list) != NIL) { @@ -21293,7 +21390,7 @@ YYLTYPE yylloc; break; case 4: -#line 551 "third_party/libpg_query/grammar/grammar.y" +#line 553 "third_party/libpg_query/grammar/grammar.y" { if ((yyvsp[(1) - (1)].node) != NULL) (yyval.list) = list_make1(makeRawStmt((yyvsp[(1) - (1)].node), 0)); @@ -21303,7 +21400,7 @@ YYLTYPE yylloc; break; case 48: -#line 603 "third_party/libpg_query/grammar/grammar.y" +#line 605 "third_party/libpg_query/grammar/grammar.y" { (yyval.node) = NULL; ;} break; @@ -21864,7 +21961,7 @@ YYLTYPE yylloc; { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_SetRelOptions; - n->def = (PGNode *)(yyvsp[(2) - (2)].list); + n->options = (yyvsp[(2) - (2)].list); (yyval.node) = (PGNode *)n; ;} break; @@ -21874,7 +21971,7 @@ YYLTYPE yylloc; { PGAlterTableCmd *n = makeNode(PGAlterTableCmd); n->subtype = PG_AT_ResetRelOptions; - n->def = (PGNode *)(yyvsp[(2) - (2)].list); + n->options = (yyvsp[(2) - (2)].list); (yyval.node) = (PGNode *)n; ;} break; @@ -23395,57 +23492,87 @@ YYLTYPE yylloc; #line 9 "third_party/libpg_query/grammar/statements/create.y" { PGCreateStmt *n = makeNode(PGCreateStmt); - (yyvsp[(4) - (9)].range)->relpersistence = (yyvsp[(2) - (9)].ival); - n->relation = (yyvsp[(4) - (9)].range); - n->tableElts = (yyvsp[(6) - (9)].list); + (yyvsp[(4) - (10)].range)->relpersistence = (yyvsp[(2) - (10)].ival); + n->relation = (yyvsp[(4) - (10)].range); + n->tableElts = (yyvsp[(6) - (10)].list); n->ofTypename = NULL; n->constraints = NIL; - n->options = (yyvsp[(8) - (9)].list); - n->oncommit = (yyvsp[(9) - (9)].oncommit); + + PGListCell *lc; + foreach(lc, (yyvsp[(8) - (10)].list)) { + PGDefElem *de = (PGDefElem *) lfirst(lc); + if (strcmp(de->defname, "partitioned_by") == 0) { + n->partition_list = (PGList *)de->arg; + } else if (strcmp(de->defname, "sorted_by") == 0) { + n->sort_list = (PGList *)de->arg; + } + } + n->options = (yyvsp[(9) - (10)].list); + n->oncommit = (yyvsp[(10) - (10)].oncommit); n->onconflict = PG_ERROR_ON_CONFLICT; (yyval.node) = (PGNode *)n; ;} break; case 293: -#line 24 "third_party/libpg_query/grammar/statements/create.y" +#line 34 "third_party/libpg_query/grammar/statements/create.y" { PGCreateStmt *n = makeNode(PGCreateStmt); - (yyvsp[(7) - (12)].range)->relpersistence = (yyvsp[(2) - (12)].ival); - n->relation = (yyvsp[(7) - (12)].range); - n->tableElts = (yyvsp[(9) - (12)].list); + (yyvsp[(7) - (13)].range)->relpersistence = (yyvsp[(2) - (13)].ival); + n->relation = (yyvsp[(7) - (13)].range); + n->tableElts = (yyvsp[(9) - (13)].list); n->ofTypename = NULL; n->constraints = NIL; - n->options = (yyvsp[(11) - (12)].list); - n->oncommit = (yyvsp[(12) - (12)].oncommit); + + PGListCell *lc; + foreach(lc, (yyvsp[(11) - (13)].list)) { + PGDefElem *de = (PGDefElem *) lfirst(lc); + if (strcmp(de->defname, "partitioned_by") == 0) { + n->partition_list = (PGList *)de->arg; + } else if (strcmp(de->defname, "sorted_by") == 0) { + n->sort_list = (PGList *)de->arg; + } + } + n->options = (yyvsp[(12) - (13)].list); + n->oncommit = (yyvsp[(13) - (13)].oncommit); n->onconflict = PG_IGNORE_ON_CONFLICT; (yyval.node) = (PGNode *)n; ;} break; case 294: -#line 39 "third_party/libpg_query/grammar/statements/create.y" +#line 59 "third_party/libpg_query/grammar/statements/create.y" { PGCreateStmt *n = makeNode(PGCreateStmt); - (yyvsp[(6) - (11)].range)->relpersistence = (yyvsp[(4) - (11)].ival); - n->relation = (yyvsp[(6) - (11)].range); - n->tableElts = (yyvsp[(8) - (11)].list); + (yyvsp[(6) - (12)].range)->relpersistence = (yyvsp[(4) - (12)].ival); + n->relation = (yyvsp[(6) - (12)].range); + n->tableElts = (yyvsp[(8) - (12)].list); n->ofTypename = NULL; n->constraints = NIL; - n->options = (yyvsp[(10) - (11)].list); - n->oncommit = (yyvsp[(11) - (11)].oncommit); + + PGListCell *lc; + foreach(lc, (yyvsp[(10) - (12)].list)) { + PGDefElem *de = (PGDefElem *) lfirst(lc); + if (strcmp(de->defname, "partitioned_by") == 0) { + n->partition_list = (PGList *)de->arg; + } else if (strcmp(de->defname, "sorted_by") == 0) { + n->sort_list = (PGList *)de->arg; + } + } + n->options = (yyvsp[(11) - (12)].list); + n->oncommit = (yyvsp[(12) - (12)].oncommit); n->onconflict = PG_REPLACE_ON_CONFLICT; (yyval.node) = (PGNode *)n; ;} break; case 295: -#line 56 "third_party/libpg_query/grammar/statements/create.y" +#line 86 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = 0; ;} break; case 296: -#line 58 "third_party/libpg_query/grammar/statements/create.y" +#line 88 "third_party/libpg_query/grammar/statements/create.y" { /* * We must complain about conflicting options. @@ -23472,77 +23599,77 @@ YYLTYPE yylloc; break; case 297: -#line 84 "third_party/libpg_query/grammar/statements/create.y" +#line 114 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].typnam); ;} break; case 298: -#line 85 "third_party/libpg_query/grammar/statements/create.y" +#line 115 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} break; case 299: -#line 86 "third_party/libpg_query/grammar/statements/create.y" +#line 116 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].list); ;} break; case 300: -#line 87 "third_party/libpg_query/grammar/statements/create.y" +#line 117 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].value); ;} break; case 301: -#line 88 "third_party/libpg_query/grammar/statements/create.y" +#line 118 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *)makeString((yyvsp[(1) - (1)].str)); ;} break; case 302: -#line 89 "third_party/libpg_query/grammar/statements/create.y" +#line 119 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *)makeString(pstrdup((yyvsp[(1) - (1)].keyword))); ;} break; case 303: -#line 93 "third_party/libpg_query/grammar/statements/create.y" +#line 123 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; case 304: -#line 94 "third_party/libpg_query/grammar/statements/create.y" +#line 124 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = NIL; ;} break; case 305: -#line 99 "third_party/libpg_query/grammar/statements/create.y" +#line 128 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; case 306: -#line 104 "third_party/libpg_query/grammar/statements/create.y" +#line 133 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_ACTION_NOACTION; ;} break; case 307: -#line 105 "third_party/libpg_query/grammar/statements/create.y" +#line 134 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_ACTION_RESTRICT; ;} break; case 308: -#line 106 "third_party/libpg_query/grammar/statements/create.y" +#line 135 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_ACTION_CASCADE; ;} break; case 309: -#line 107 "third_party/libpg_query/grammar/statements/create.y" +#line 136 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_ACTION_SETNULL; ;} break; case 310: -#line 108 "third_party/libpg_query/grammar/statements/create.y" +#line 137 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_ACTION_SETDEFAULT; ;} break; case 311: -#line 114 "third_party/libpg_query/grammar/statements/create.y" +#line 143 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node)); n->conname = (yyvsp[(2) - (3)].str); @@ -23552,17 +23679,17 @@ YYLTYPE yylloc; break; case 312: -#line 120 "third_party/libpg_query/grammar/statements/create.y" +#line 149 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 313: -#line 121 "third_party/libpg_query/grammar/statements/create.y" +#line 150 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 314: -#line 123 "third_party/libpg_query/grammar/statements/create.y" +#line 152 "third_party/libpg_query/grammar/statements/create.y" { /* * Note: the PGCollateClause is momentarily included in @@ -23578,7 +23705,7 @@ YYLTYPE yylloc; break; case 315: -#line 140 "third_party/libpg_query/grammar/statements/create.y" +#line 169 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_NOTNULL; @@ -23588,7 +23715,7 @@ YYLTYPE yylloc; break; case 316: -#line 147 "third_party/libpg_query/grammar/statements/create.y" +#line 176 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_NULL; @@ -23598,7 +23725,7 @@ YYLTYPE yylloc; break; case 317: -#line 154 "third_party/libpg_query/grammar/statements/create.y" +#line 183 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_UNIQUE; @@ -23611,7 +23738,7 @@ YYLTYPE yylloc; break; case 318: -#line 164 "third_party/libpg_query/grammar/statements/create.y" +#line 193 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_PRIMARY; @@ -23624,7 +23751,7 @@ YYLTYPE yylloc; break; case 319: -#line 174 "third_party/libpg_query/grammar/statements/create.y" +#line 203 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_CHECK; @@ -23639,7 +23766,7 @@ YYLTYPE yylloc; break; case 320: -#line 186 "third_party/libpg_query/grammar/statements/create.y" +#line 215 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_COMPRESSION; @@ -23650,7 +23777,7 @@ YYLTYPE yylloc; break; case 321: -#line 194 "third_party/libpg_query/grammar/statements/create.y" +#line 223 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_DEFAULT; @@ -23662,7 +23789,7 @@ YYLTYPE yylloc; break; case 322: -#line 203 "third_party/libpg_query/grammar/statements/create.y" +#line 232 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_FOREIGN; @@ -23680,27 +23807,27 @@ YYLTYPE yylloc; break; case 323: -#line 220 "third_party/libpg_query/grammar/statements/create.y" +#line 249 "third_party/libpg_query/grammar/statements/create.y" { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;} break; case 324: -#line 221 "third_party/libpg_query/grammar/statements/create.y" +#line 250 "third_party/libpg_query/grammar/statements/create.y" { (yyval.constr) = PG_CONSTR_GENERATED_STORED; ;} break; case 325: -#line 225 "third_party/libpg_query/grammar/statements/create.y" +#line 254 "third_party/libpg_query/grammar/statements/create.y" { (yyval.constr) = (yyvsp[(1) - (1)].constr); ;} break; case 326: -#line 226 "third_party/libpg_query/grammar/statements/create.y" +#line 255 "third_party/libpg_query/grammar/statements/create.y" { (yyval.constr) = PG_CONSTR_GENERATED_VIRTUAL; ;} break; case 327: -#line 231 "third_party/libpg_query/grammar/statements/create.y" +#line 260 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_IDENTITY; @@ -23712,7 +23839,7 @@ YYLTYPE yylloc; break; case 328: -#line 240 "third_party/libpg_query/grammar/statements/create.y" +#line 269 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = (yyvsp[(7) - (7)].constr); @@ -23738,7 +23865,7 @@ YYLTYPE yylloc; break; case 329: -#line 263 "third_party/libpg_query/grammar/statements/create.y" +#line 292 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = (yyvsp[(5) - (5)].constr); @@ -23751,79 +23878,79 @@ YYLTYPE yylloc; break; case 330: -#line 277 "third_party/libpg_query/grammar/statements/create.y" +#line 306 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; case 331: -#line 283 "third_party/libpg_query/grammar/statements/create.y" +#line 312 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; case 332: -#line 289 "third_party/libpg_query/grammar/statements/create.y" +#line 318 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = ((yyvsp[(1) - (1)].ival) << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;} break; case 333: -#line 291 "third_party/libpg_query/grammar/statements/create.y" +#line 320 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | ((yyvsp[(1) - (1)].ival) & 0xFF); ;} break; case 334: -#line 293 "third_party/libpg_query/grammar/statements/create.y" +#line 322 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = ((yyvsp[(1) - (2)].ival) << 8) | ((yyvsp[(2) - (2)].ival) & 0xFF); ;} break; case 335: -#line 295 "third_party/libpg_query/grammar/statements/create.y" +#line 324 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = ((yyvsp[(2) - (2)].ival) << 8) | ((yyvsp[(1) - (2)].ival) & 0xFF); ;} break; case 336: -#line 297 "third_party/libpg_query/grammar/statements/create.y" +#line 326 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = (PG_FKCONSTR_ACTION_NOACTION << 8) | (PG_FKCONSTR_ACTION_NOACTION & 0xFF); ;} break; case 337: -#line 300 "third_party/libpg_query/grammar/statements/create.y" +#line 329 "third_party/libpg_query/grammar/statements/create.y" { (yyval.oncommit) = ONCOMMIT_DROP; ;} break; case 338: -#line 301 "third_party/libpg_query/grammar/statements/create.y" +#line 330 "third_party/libpg_query/grammar/statements/create.y" { (yyval.oncommit) = PG_ONCOMMIT_DELETE_ROWS; ;} break; case 339: -#line 302 "third_party/libpg_query/grammar/statements/create.y" +#line 331 "third_party/libpg_query/grammar/statements/create.y" { (yyval.oncommit) = PG_ONCOMMIT_PRESERVE_ROWS; ;} break; case 340: -#line 303 "third_party/libpg_query/grammar/statements/create.y" +#line 332 "third_party/libpg_query/grammar/statements/create.y" { (yyval.oncommit) = PG_ONCOMMIT_NOOP; ;} break; case 341: -#line 308 "third_party/libpg_query/grammar/statements/create.y" +#line 337 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; case 342: -#line 312 "third_party/libpg_query/grammar/statements/create.y" +#line 340 "third_party/libpg_query/grammar/statements/create.y" { (yyval.boolean) = true; ;} break; case 343: -#line 313 "third_party/libpg_query/grammar/statements/create.y" +#line 341 "third_party/libpg_query/grammar/statements/create.y" { (yyval.boolean) = false; ;} break; case 344: -#line 319 "third_party/libpg_query/grammar/statements/create.y" +#line 347 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = castNode(PGConstraint, (yyvsp[(3) - (3)].node)); n->conname = (yyvsp[(2) - (3)].str); @@ -23833,67 +23960,67 @@ YYLTYPE yylloc; break; case 345: -#line 325 "third_party/libpg_query/grammar/statements/create.y" +#line 353 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; case 346: -#line 330 "third_party/libpg_query/grammar/statements/create.y" +#line 358 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_COMMENTS; ;} break; case 347: -#line 331 "third_party/libpg_query/grammar/statements/create.y" +#line 359 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_CONSTRAINTS; ;} break; case 348: -#line 332 "third_party/libpg_query/grammar/statements/create.y" +#line 360 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_DEFAULTS; ;} break; case 349: -#line 333 "third_party/libpg_query/grammar/statements/create.y" +#line 361 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_IDENTITY; ;} break; case 350: -#line 334 "third_party/libpg_query/grammar/statements/create.y" +#line 362 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_INDEXES; ;} break; case 351: -#line 335 "third_party/libpg_query/grammar/statements/create.y" +#line 363 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_STATISTICS; ;} break; case 352: -#line 336 "third_party/libpg_query/grammar/statements/create.y" +#line 364 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_STORAGE; ;} break; case 353: -#line 337 "third_party/libpg_query/grammar/statements/create.y" +#line 365 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_CREATE_TABLE_LIKE_ALL; ;} break; case 354: -#line 343 "third_party/libpg_query/grammar/statements/create.y" +#line 371 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; case 355: -#line 344 "third_party/libpg_query/grammar/statements/create.y" +#line 372 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; case 356: -#line 348 "third_party/libpg_query/grammar/statements/create.y" +#line 375 "third_party/libpg_query/grammar/statements/create.y" { (yyval.str) = (yyvsp[(3) - (3)].str); ;} break; case 357: -#line 354 "third_party/libpg_query/grammar/statements/create.y" +#line 381 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_DEFERRABLE; @@ -23903,7 +24030,7 @@ YYLTYPE yylloc; break; case 358: -#line 361 "third_party/libpg_query/grammar/statements/create.y" +#line 388 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_NOT_DEFERRABLE; @@ -23913,7 +24040,7 @@ YYLTYPE yylloc; break; case 359: -#line 368 "third_party/libpg_query/grammar/statements/create.y" +#line 395 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_DEFERRED; @@ -23923,7 +24050,7 @@ YYLTYPE yylloc; break; case 360: -#line 375 "third_party/libpg_query/grammar/statements/create.y" +#line 402 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_ATTR_IMMEDIATE; @@ -23933,82 +24060,106 @@ YYLTYPE yylloc; break; case 361: -#line 386 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[(2) - (2)].list); ;} +#line 412 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; case 362: -#line 387 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[(1) - (2)]))); ;} +#line 413 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = NIL; ;} break; case 363: -#line 388 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[(1) - (2)]))); ;} +#line 418 "third_party/libpg_query/grammar/statements/create.y" + { + (yyval.defelt) = makeDefElem("partitioned_by", (PGNode *)(yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; case 364: -#line 389 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = NIL; ;} +#line 422 "third_party/libpg_query/grammar/statements/create.y" + { + (yyval.defelt) = makeDefElem("sorted_by", (PGNode *)(yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); + ;} break; case 365: -#line 393 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.list) = (yyvsp[(2) - (3)].list); ;} +#line 428 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; case 366: -#line 398 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} +#line 429 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(true), (yylsp[(1) - (2)]))); ;} break; case 367: -#line 399 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;} +#line 430 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = list_make1(makeDefElem("oids", (PGNode *) makeInteger(false), (yylsp[(1) - (2)]))); ;} break; case 368: -#line 400 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = 0; ;} +#line 431 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = NIL; ;} break; case 369: -#line 405 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.str) = (yyvsp[(1) - (1)].str); ;} +#line 434 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; case 370: -#line 410 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NOT_DEFERRABLE; ;} +#line 439 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; case 371: -#line 411 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_DEFERRABLE; ;} +#line 440 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = (yyvsp[(1) - (3)].ival) & ~(yyvsp[(3) - (3)].ival); ;} break; case 372: -#line 412 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; ;} +#line 441 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = 0; ;} break; case 373: -#line 413 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_INITIALLY_DEFERRED; ;} +#line 446 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; case 374: -#line 414 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NOT_VALID; ;} +#line 451 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = CAS_NOT_DEFERRABLE; ;} break; case 375: -#line 415 "third_party/libpg_query/grammar/statements/create.y" - { (yyval.ival) = CAS_NO_INHERIT; ;} +#line 452 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = CAS_DEFERRABLE; ;} break; case 376: -#line 421 "third_party/libpg_query/grammar/statements/create.y" +#line 453 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = CAS_INITIALLY_IMMEDIATE; ;} + break; + + case 377: +#line 454 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = CAS_INITIALLY_DEFERRED; ;} + break; + + case 378: +#line 455 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = CAS_NOT_VALID; ;} + break; + + case 379: +#line 456 "third_party/libpg_query/grammar/statements/create.y" + { (yyval.ival) = CAS_NO_INHERIT; ;} + break; + + case 380: +#line 462 "third_party/libpg_query/grammar/statements/create.y" { PGColumnDef *n = makeNode(PGColumnDef); n->category = COL_STANDARD; @@ -24027,8 +24178,8 @@ YYLTYPE yylloc; ;} break; - case 377: -#line 441 "third_party/libpg_query/grammar/statements/create.y" + case 381: +#line 482 "third_party/libpg_query/grammar/statements/create.y" { PGColumnDef *n = makeNode(PGColumnDef); n->category = COL_GENERATED; @@ -24054,8 +24205,8 @@ YYLTYPE yylloc; ;} break; - case 378: -#line 467 "third_party/libpg_query/grammar/statements/create.y" + case 382: +#line 508 "third_party/libpg_query/grammar/statements/create.y" { PGColumnDef *n = (PGColumnDef *) (yyvsp[(2) - (2)].node); n->colname = (yyvsp[(1) - (2)].str); @@ -24064,8 +24215,8 @@ YYLTYPE yylloc; ;} break; - case 379: -#line 475 "third_party/libpg_query/grammar/statements/create.y" + case 383: +#line 516 "third_party/libpg_query/grammar/statements/create.y" { PGColumnDef *n = (PGColumnDef *) (yyvsp[(2) - (2)].node); n->colname = (yyvsp[(1) - (2)].str); @@ -24074,163 +24225,177 @@ YYLTYPE yylloc; ;} break; - case 380: -#line 484 "third_party/libpg_query/grammar/statements/create.y" + case 384: +#line 525 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 381: -#line 485 "third_party/libpg_query/grammar/statements/create.y" + case 385: +#line 526 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 382: -#line 489 "third_party/libpg_query/grammar/statements/create.y" + case 386: +#line 530 "third_party/libpg_query/grammar/statements/create.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 383: -#line 493 "third_party/libpg_query/grammar/statements/create.y" + case 387: +#line 534 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 384: -#line 494 "third_party/libpg_query/grammar/statements/create.y" + case 388: +#line 535 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 385: -#line 495 "third_party/libpg_query/grammar/statements/create.y" + case 389: +#line 536 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 386: -#line 500 "third_party/libpg_query/grammar/statements/create.y" + case 390: +#line 541 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)])); ;} break; - case 387: -#line 504 "third_party/libpg_query/grammar/statements/create.y" + case 391: +#line 545 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); ;} break; - case 388: -#line 511 "third_party/libpg_query/grammar/statements/create.y" + case 392: +#line 552 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 389: -#line 512 "third_party/libpg_query/grammar/statements/create.y" + case 393: +#line 553 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = NIL; ;} break; - case 390: -#line 517 "third_party/libpg_query/grammar/statements/create.y" + case 394: +#line 558 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 391: -#line 518 "third_party/libpg_query/grammar/statements/create.y" + case 395: +#line 559 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 392: -#line 519 "third_party/libpg_query/grammar/statements/create.y" + case 396: +#line 560 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = NIL; ;} break; - case 393: -#line 524 "third_party/libpg_query/grammar/statements/create.y" + case 397: +#line 565 "third_party/libpg_query/grammar/statements/create.y" { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 394: -#line 531 "third_party/libpg_query/grammar/statements/create.y" + case 398: +#line 572 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 395: -#line 532 "third_party/libpg_query/grammar/statements/create.y" + case 399: +#line 573 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = NIL; ;} break; - case 396: -#line 537 "third_party/libpg_query/grammar/statements/create.y" + case 400: +#line 578 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 397: -#line 538 "third_party/libpg_query/grammar/statements/create.y" + case 401: +#line 579 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = NIL; ;} break; - case 398: -#line 542 "third_party/libpg_query/grammar/statements/create.y" + case 402: +#line 583 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = (yyvsp[(3) - (3)].ival); ;} break; - case 399: -#line 548 "third_party/libpg_query/grammar/statements/create.y" + case 403: +#line 589 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)])); ;} break; - case 400: -#line 552 "third_party/libpg_query/grammar/statements/create.y" + case 404: +#line 593 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); ;} break; - case 401: -#line 556 "third_party/libpg_query/grammar/statements/create.y" + case 405: +#line 597 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (5)].str), (yyvsp[(3) - (5)].str), (PGNode *) (yyvsp[(5) - (5)].node), PG_DEFELEM_UNSPEC, (yylsp[(1) - (5)])); ;} break; - case 402: -#line 561 "third_party/libpg_query/grammar/statements/create.y" + case 406: +#line 602 "third_party/libpg_query/grammar/statements/create.y" { (yyval.defelt) = makeDefElemExtended((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str), NULL, PG_DEFELEM_UNSPEC, (yylsp[(1) - (3)])); ;} break; - case 403: -#line 568 "third_party/libpg_query/grammar/statements/create.y" + case 407: +#line 606 "third_party/libpg_query/grammar/statements/create.y" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (3)].str), (PGNode *) (yyvsp[(3) - (3)].node), (yylsp[(1) - (3)])); + ;} + break; + + case 408: +#line 610 "third_party/libpg_query/grammar/statements/create.y" + { + (yyval.defelt) = makeDefElem((yyvsp[(1) - (1)].str), NULL, (yylsp[(1) - (1)])); + ;} + break; + + case 409: +#line 616 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 404: -#line 569 "third_party/libpg_query/grammar/statements/create.y" + case 410: +#line 617 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 405: -#line 573 "third_party/libpg_query/grammar/statements/create.y" + case 411: +#line 621 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 406: -#line 574 "third_party/libpg_query/grammar/statements/create.y" + case 412: +#line 622 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 407: -#line 578 "third_party/libpg_query/grammar/statements/create.y" + case 413: +#line 626 "third_party/libpg_query/grammar/statements/create.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 408: -#line 580 "third_party/libpg_query/grammar/statements/create.y" + case 414: +#line 628 "third_party/libpg_query/grammar/statements/create.y" { (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(1) - (4)].str)), (yyvsp[(2) - (4)].list))); (yyval.typnam)->pct_type = true; @@ -24238,8 +24403,8 @@ YYLTYPE yylloc; ;} break; - case 409: -#line 586 "third_party/libpg_query/grammar/statements/create.y" + case 415: +#line 634 "third_party/libpg_query/grammar/statements/create.y" { (yyval.typnam) = makeTypeNameFromNameList(lcons(makeString((yyvsp[(2) - (5)].str)), (yyvsp[(3) - (5)].list))); (yyval.typnam)->pct_type = true; @@ -24248,8 +24413,8 @@ YYLTYPE yylloc; ;} break; - case 410: -#line 597 "third_party/libpg_query/grammar/statements/create.y" + case 416: +#line 645 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_CHECK; @@ -24264,8 +24429,8 @@ YYLTYPE yylloc; ;} break; - case 411: -#line 611 "third_party/libpg_query/grammar/statements/create.y" + case 417: +#line 659 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_UNIQUE; @@ -24280,8 +24445,8 @@ YYLTYPE yylloc; ;} break; - case 412: -#line 624 "third_party/libpg_query/grammar/statements/create.y" + case 418: +#line 672 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_UNIQUE; @@ -24297,8 +24462,8 @@ YYLTYPE yylloc; ;} break; - case 413: -#line 639 "third_party/libpg_query/grammar/statements/create.y" + case 419: +#line 687 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_PRIMARY; @@ -24313,8 +24478,8 @@ YYLTYPE yylloc; ;} break; - case 414: -#line 652 "third_party/libpg_query/grammar/statements/create.y" + case 420: +#line 700 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_PRIMARY; @@ -24330,8 +24495,8 @@ YYLTYPE yylloc; ;} break; - case 415: -#line 667 "third_party/libpg_query/grammar/statements/create.y" + case 421: +#line 715 "third_party/libpg_query/grammar/statements/create.y" { PGConstraint *n = makeNode(PGConstraint); n->contype = PG_CONSTR_FOREIGN; @@ -24351,29 +24516,29 @@ YYLTYPE yylloc; ;} break; - case 416: -#line 689 "third_party/libpg_query/grammar/statements/create.y" + case 422: +#line 737 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 417: -#line 693 "third_party/libpg_query/grammar/statements/create.y" + case 423: +#line 741 "third_party/libpg_query/grammar/statements/create.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 418: -#line 700 "third_party/libpg_query/grammar/statements/create.y" + case 424: +#line 748 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_MATCH_FULL; ;} break; - case 419: -#line 704 "third_party/libpg_query/grammar/statements/create.y" + case 425: +#line 752 "third_party/libpg_query/grammar/statements/create.y" { ereport(ERROR, (errcode(PG_ERRCODE_FEATURE_NOT_SUPPORTED), @@ -24383,22 +24548,22 @@ YYLTYPE yylloc; ;} break; - case 420: -#line 712 "third_party/libpg_query/grammar/statements/create.y" + case 426: +#line 760 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE; ;} break; - case 421: -#line 716 "third_party/libpg_query/grammar/statements/create.y" + case 427: +#line 764 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_FKCONSTR_MATCH_SIMPLE; ;} break; - case 422: -#line 724 "third_party/libpg_query/grammar/statements/create.y" + case 428: +#line 772 "third_party/libpg_query/grammar/statements/create.y" { PGTableLikeClause *n = makeNode(PGTableLikeClause); n->relation = (yyvsp[(2) - (3)].range); @@ -24407,28 +24572,28 @@ YYLTYPE yylloc; ;} break; - case 423: -#line 733 "third_party/libpg_query/grammar/statements/create.y" + case 429: +#line 781 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 424: -#line 734 "third_party/libpg_query/grammar/statements/create.y" + case 430: +#line 782 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 425: -#line 735 "third_party/libpg_query/grammar/statements/create.y" + case 431: +#line 783 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 426: -#line 736 "third_party/libpg_query/grammar/statements/create.y" + case 432: +#line 784 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_RELPERSISTENCE_TEMP; ;} break; - case 427: -#line 738 "third_party/libpg_query/grammar/statements/create.y" + case 433: +#line 786 "third_party/libpg_query/grammar/statements/create.y" { ereport(PGWARNING, (errmsg("GLOBAL is deprecated in temporary table creation"), @@ -24437,8 +24602,8 @@ YYLTYPE yylloc; ;} break; - case 428: -#line 745 "third_party/libpg_query/grammar/statements/create.y" + case 434: +#line 793 "third_party/libpg_query/grammar/statements/create.y" { ereport(PGWARNING, (errmsg("GLOBAL is deprecated in temporary table creation"), @@ -24447,27 +24612,27 @@ YYLTYPE yylloc; ;} break; - case 429: -#line 751 "third_party/libpg_query/grammar/statements/create.y" + case 435: +#line 799 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_RELPERSISTENCE_UNLOGGED; ;} break; - case 430: -#line 752 "third_party/libpg_query/grammar/statements/create.y" + case 436: +#line 800 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = RELPERSISTENCE_PERMANENT; ;} break; - case 431: -#line 757 "third_party/libpg_query/grammar/statements/create.y" + case 437: +#line 804 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = PG_ATTRIBUTE_IDENTITY_ALWAYS; ;} break; - case 432: -#line 758 "third_party/libpg_query/grammar/statements/create.y" + case 438: +#line 805 "third_party/libpg_query/grammar/statements/create.y" { (yyval.ival) = ATTRIBUTE_IDENTITY_BY_DEFAULT; ;} break; - case 433: + case 439: #line 10 "third_party/libpg_query/grammar/statements/drop.y" { PGDropStmt *n = makeNode(PGDropStmt); @@ -24480,7 +24645,7 @@ YYLTYPE yylloc; ;} break; - case 434: + case 440: #line 20 "third_party/libpg_query/grammar/statements/drop.y" { PGDropStmt *n = makeNode(PGDropStmt); @@ -24493,7 +24658,7 @@ YYLTYPE yylloc; ;} break; - case 435: + case 441: #line 30 "third_party/libpg_query/grammar/statements/drop.y" { PGDropStmt *n = makeNode(PGDropStmt); @@ -24506,7 +24671,7 @@ YYLTYPE yylloc; ;} break; - case 436: + case 442: #line 40 "third_party/libpg_query/grammar/statements/drop.y" { PGDropStmt *n = makeNode(PGDropStmt); @@ -24519,7 +24684,7 @@ YYLTYPE yylloc; ;} break; - case 437: + case 443: #line 50 "third_party/libpg_query/grammar/statements/drop.y" { PGDropStmt *n = makeNode(PGDropStmt); @@ -24532,7 +24697,7 @@ YYLTYPE yylloc; ;} break; - case 438: + case 444: #line 60 "third_party/libpg_query/grammar/statements/drop.y" { PGDropStmt *n = makeNode(PGDropStmt); @@ -24545,167 +24710,167 @@ YYLTYPE yylloc; ;} break; - case 439: + case 445: #line 73 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TABLE; ;} break; - case 440: + case 446: #line 74 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;} break; - case 441: + case 447: #line 75 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 442: + case 448: #line 76 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 443: + case 449: #line 77 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;} break; - case 444: + case 450: #line 78 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_VIEW; ;} break; - case 445: + case 451: #line 79 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_MATVIEW; ;} break; - case 446: + case 452: #line 80 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_INDEX; ;} break; - case 447: + case 453: #line 81 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_FOREIGN_TABLE; ;} break; - case 448: + case 454: #line 82 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_COLLATION; ;} break; - case 449: + case 455: #line 83 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_CONVERSION; ;} break; - case 450: + case 456: #line 84 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_SCHEMA; ;} break; - case 451: + case 457: #line 85 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_STATISTIC_EXT; ;} break; - case 452: + case 458: #line 86 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TSPARSER; ;} break; - case 453: + case 459: #line 87 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TSDICTIONARY; ;} break; - case 454: + case 460: #line 88 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TSTEMPLATE; ;} break; - case 455: + case 461: #line 89 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TSCONFIGURATION; ;} break; - case 456: + case 462: #line 90 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TYPE; ;} break; - case 457: + case 463: #line 95 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_ACCESS_METHOD; ;} break; - case 458: + case 464: #line 96 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_EVENT_TRIGGER; ;} break; - case 459: + case 465: #line 97 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_EXTENSION; ;} break; - case 460: + case 466: #line 98 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_FDW; ;} break; - case 461: + case 467: #line 99 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_PUBLICATION; ;} break; - case 462: + case 468: #line 100 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_FOREIGN_SERVER; ;} break; - case 463: + case 469: #line 105 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 464: + case 470: #line 106 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 465: + case 471: #line 111 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.dbehavior) = PG_DROP_CASCADE; ;} break; - case 466: + case 472: #line 112 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.dbehavior) = PG_DROP_RESTRICT; ;} break; - case 467: + case 473: #line 113 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.dbehavior) = PG_DROP_RESTRICT; /* default */ ;} break; - case 468: + case 474: #line 118 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_POLICY; ;} break; - case 469: + case 475: #line 119 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_RULE; ;} break; - case 470: + case 476: #line 120 "third_party/libpg_query/grammar/statements/drop.y" { (yyval.objtype) = PG_OBJECT_TRIGGER; ;} break; - case 471: + case 477: #line 13 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMergeIntoStmt *n = makeNode(PGMergeIntoStmt); @@ -24722,27 +24887,27 @@ YYLTYPE yylloc; ;} break; - case 472: + case 478: #line 29 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 473: + case 479: #line 30 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.node) = NULL; ;} break; - case 474: + case 480: #line 34 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 475: + case 481: #line 35 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.list) = NULL; ;} break; - case 478: + case 484: #line 44 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24753,7 +24918,7 @@ YYLTYPE yylloc; ;} break; - case 479: + case 485: #line 52 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24763,7 +24928,7 @@ YYLTYPE yylloc; ;} break; - case 480: + case 486: #line 59 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24773,7 +24938,7 @@ YYLTYPE yylloc; ;} break; - case 481: + case 487: #line 66 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24782,7 +24947,7 @@ YYLTYPE yylloc; ;} break; - case 482: + case 488: #line 72 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24794,7 +24959,7 @@ YYLTYPE yylloc; ;} break; - case 483: + case 489: #line 81 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24804,7 +24969,7 @@ YYLTYPE yylloc; ;} break; - case 484: + case 490: #line 88 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24815,7 +24980,7 @@ YYLTYPE yylloc; ;} break; - case 485: + case 491: #line 96 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24824,7 +24989,7 @@ YYLTYPE yylloc; ;} break; - case 486: + case 492: #line 102 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = makeNode(PGMatchAction); @@ -24834,17 +24999,17 @@ YYLTYPE yylloc; ;} break; - case 487: + case 493: #line 111 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 488: + case 494: #line 112 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.node) = NULL; ;} break; - case 489: + case 495: #line 117 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = (PGMatchAction *) (yyvsp[(5) - (5)].node); @@ -24854,22 +25019,22 @@ YYLTYPE yylloc; ;} break; - case 490: + case 496: #line 126 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.mergeaction) = MERGE_ACTION_WHEN_NOT_MATCHED_BY_SOURCE; ;} break; - case 491: + case 497: #line 127 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.mergeaction) = MERGE_ACTION_WHEN_NOT_MATCHED_BY_TARGET; ;} break; - case 492: + case 498: #line 128 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.mergeaction) = MERGE_ACTION_WHEN_NOT_MATCHED_BY_TARGET; ;} break; - case 493: + case 499: #line 133 "third_party/libpg_query/grammar/statements/merge_into.y" { PGMatchAction *n = (PGMatchAction *) (yyvsp[(7) - (7)].node); @@ -24879,17 +25044,17 @@ YYLTYPE yylloc; ;} break; - case 496: + case 502: #line 146 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 497: + case 503: #line 147 "third_party/libpg_query/grammar/statements/merge_into.y" { (yyval.list) = list_concat(list_make1((yyvsp[(1) - (2)].node)), (yyvsp[(2) - (2)].list)); ;} break; - case 498: + case 504: #line 8 "third_party/libpg_query/grammar/statements/create_function.y" { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); @@ -24901,7 +25066,7 @@ YYLTYPE yylloc; ;} break; - case 499: + case 505: #line 17 "third_party/libpg_query/grammar/statements/create_function.y" { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); @@ -24913,7 +25078,7 @@ YYLTYPE yylloc; ;} break; - case 500: + case 506: #line 26 "third_party/libpg_query/grammar/statements/create_function.y" { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); @@ -24925,7 +25090,7 @@ YYLTYPE yylloc; ;} break; - case 501: + case 507: #line 35 "third_party/libpg_query/grammar/statements/create_function.y" { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); @@ -24937,7 +25102,7 @@ YYLTYPE yylloc; ;} break; - case 502: + case 508: #line 44 "third_party/libpg_query/grammar/statements/create_function.y" { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); @@ -24949,7 +25114,7 @@ YYLTYPE yylloc; ;} break; - case 503: + case 509: #line 53 "third_party/libpg_query/grammar/statements/create_function.y" { PGCreateFunctionStmt *n = makeNode(PGCreateFunctionStmt); @@ -24961,7 +25126,7 @@ YYLTYPE yylloc; ;} break; - case 504: + case 510: #line 65 "third_party/libpg_query/grammar/statements/create_function.y" { PGFunctionDefinition *n = makeNode(PGFunctionDefinition); @@ -24971,7 +25136,7 @@ YYLTYPE yylloc; ;} break; - case 505: + case 511: #line 75 "third_party/libpg_query/grammar/statements/create_function.y" { PGFunctionDefinition *n = makeNode(PGFunctionDefinition); @@ -24981,28 +25146,28 @@ YYLTYPE yylloc; ;} break; - case 506: + case 512: #line 85 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 507: + case 513: #line 89 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 508: + case 514: #line 96 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 510: + case 516: #line 104 "third_party/libpg_query/grammar/statements/create_function.y" { PGFunctionDefinition *n = makeNode(PGFunctionDefinition); @@ -25012,56 +25177,56 @@ YYLTYPE yylloc; ;} break; - case 511: + case 517: #line 114 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 512: + case 518: #line 118 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 515: + case 521: #line 131 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = NIL; ;} break; - case 516: + case 522: #line 135 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = (yyvsp[(2) - (4)].list); ;} break; - case 517: + case 523: #line 139 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 518: + case 524: #line 146 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 519: + case 525: #line 150 "third_party/libpg_query/grammar/statements/create_function.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 520: + case 526: #line 157 "third_party/libpg_query/grammar/statements/create_function.y" { PGFunctionParameter *n = makeNode(PGFunctionParameter); @@ -25072,7 +25237,7 @@ YYLTYPE yylloc; ;} break; - case 521: + case 527: #line 165 "third_party/libpg_query/grammar/statements/create_function.y" { PGFunctionParameter *n = makeNode(PGFunctionParameter); @@ -25083,7 +25248,7 @@ YYLTYPE yylloc; ;} break; - case 522: + case 528: #line 173 "third_party/libpg_query/grammar/statements/create_function.y" { PGFunctionParameter *n = makeNode(PGFunctionParameter); @@ -25094,7 +25259,7 @@ YYLTYPE yylloc; ;} break; - case 523: + case 529: #line 12 "third_party/libpg_query/grammar/statements/update.y" { PGUpdateStmt *n = makeNode(PGUpdateStmt); @@ -25108,7 +25273,7 @@ YYLTYPE yylloc; ;} break; - case 524: + case 530: #line 3 "third_party/libpg_query/grammar/statements/copy.y" { PGCopyStmt *n = makeNode(PGCopyStmt); @@ -25139,7 +25304,7 @@ YYLTYPE yylloc; ;} break; - case 525: + case 531: #line 31 "third_party/libpg_query/grammar/statements/copy.y" { PGCopyStmt *n = makeNode(PGCopyStmt); @@ -25161,7 +25326,7 @@ YYLTYPE yylloc; ;} break; - case 526: + case 532: #line 50 "third_party/libpg_query/grammar/statements/copy.y" { PGCopyDatabaseStmt *n = makeNode(PGCopyDatabaseStmt); @@ -25172,287 +25337,287 @@ YYLTYPE yylloc; ;} break; - case 527: + case 533: #line 61 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.conststr) = NULL; ;} break; - case 528: + case 534: #line 62 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.conststr) = "schema"; ;} break; - case 529: + case 535: #line 63 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.conststr) = "data"; ;} break; - case 530: + case 536: #line 67 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.boolean) = true; ;} break; - case 531: + case 537: #line 68 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.boolean) = false; ;} break; - case 532: + case 538: #line 74 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeString((yyvsp[(3) - (3)].str)), (yylsp[(2) - (3)])); ;} break; - case 533: + case 539: #line 77 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = NULL; ;} break; - case 534: + case 540: #line 94 "third_party/libpg_query/grammar/statements/copy.y" {;} break; - case 535: + case 541: #line 95 "third_party/libpg_query/grammar/statements/copy.y" {;} break; - case 536: + case 542: #line 99 "third_party/libpg_query/grammar/statements/copy.y" {;} break; - case 537: + case 543: #line 100 "third_party/libpg_query/grammar/statements/copy.y" {;} break; - case 538: + case 544: #line 105 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.boolean) = true; ;} break; - case 539: + case 545: #line 106 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.boolean) = false; ;} break; - case 540: + case 546: #line 110 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 541: + case 547: #line 111 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 542: + case 548: #line 116 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("oids", NULL, (yylsp[(1) - (2)])); ;} break; - case 543: + case 549: #line 119 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = NULL; ;} break; - case 544: + case 550: #line 124 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].defelt)); ;} break; - case 545: + case 551: #line 125 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.list) = NIL; ;} break; - case 546: + case 552: #line 131 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("format", (PGNode *)makeStringConst("binary", (yylsp[(1) - (1)])), (yylsp[(1) - (1)])); ;} break; - case 547: + case 553: #line 134 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = NULL; ;} break; - case 548: + case 554: #line 140 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("format", (PGNode *)makeStringConst("binary", (yylsp[(1) - (1)])), (yylsp[(1) - (1)])); ;} break; - case 549: + case 555: #line 144 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("oids", NULL, (yylsp[(1) - (1)])); ;} break; - case 550: + case 556: #line 148 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("freeze", NULL, (yylsp[(1) - (1)])); ;} break; - case 551: + case 557: #line 152 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("delimiter", (PGNode *)makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)])), (yylsp[(1) - (3)])); ;} break; - case 552: + case 558: #line 156 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("null", (PGNode *)makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)])), (yylsp[(1) - (3)])); ;} break; - case 553: + case 559: #line 160 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("format", (PGNode *)makeStringConst("csv", (yylsp[(1) - (1)])), (yylsp[(1) - (1)])); ;} break; - case 554: + case 560: #line 164 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("header", NULL, (yylsp[(1) - (1)])); ;} break; - case 555: + case 561: #line 168 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("quote", (PGNode *)makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)])), (yylsp[(1) - (3)])); ;} break; - case 556: + case 562: #line 172 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("escape", (PGNode *)makeStringConst((yyvsp[(3) - (3)].str), (yylsp[(3) - (3)])), (yylsp[(1) - (3)])); ;} break; - case 557: + case 563: #line 176 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("force_quote", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); ;} break; - case 558: + case 564: #line 180 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("force_quote", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)])); ;} break; - case 559: + case 565: #line 184 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("partition_by", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); ;} break; - case 560: + case 566: #line 188 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("partition_by", (PGNode *)makeNode(PGAStar), (yylsp[(1) - (3)])); ;} break; - case 561: + case 567: #line 192 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("force_not_null", (PGNode *)(yyvsp[(4) - (4)].list), (yylsp[(1) - (4)])); ;} break; - case 562: + case 568: #line 196 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("force_null", (PGNode *)(yyvsp[(3) - (3)].list), (yylsp[(1) - (3)])); ;} break; - case 563: + case 569: #line 200 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.defelt) = makeDefElem("encoding", (PGNode *)makeStringConst((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)])), (yylsp[(1) - (2)])); ;} break; - case 564: + case 570: #line 211 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 565: + case 571: #line 212 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = makeStringConst("/dev/stdin", (yylsp[(1) - (1)])); ;} break; - case 566: + case 572: #line 213 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = makeStringConst("/dev/stdout", (yylsp[(1) - (1)])); ;} break; - case 567: + case 573: #line 214 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = makeStringConst(psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)), (yylsp[(1) - (3)])); ;} break; - case 568: + case 574: #line 215 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 569: + case 575: #line 216 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 570: + case 576: #line 217 "third_party/libpg_query/grammar/statements/copy.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 573: + case 579: #line 52 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 574: + case 580: #line 53 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 575: + case 581: #line 55 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 576: + case 582: #line 72 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 577: + case 583: #line 74 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list), NIL, @@ -25462,7 +25627,7 @@ YYLTYPE yylloc; ;} break; - case 578: + case 584: #line 81 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(3) - (4)].list), @@ -25473,7 +25638,7 @@ YYLTYPE yylloc; ;} break; - case 579: + case 585: #line 89 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].list), (yyvsp[(4) - (4)].list), @@ -25484,7 +25649,7 @@ YYLTYPE yylloc; ;} break; - case 580: + case 586: #line 97 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (2)].node), NULL, NIL, @@ -25495,7 +25660,7 @@ YYLTYPE yylloc; ;} break; - case 581: + case 587: #line 105 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].list), NIL, @@ -25506,7 +25671,7 @@ YYLTYPE yylloc; ;} break; - case 582: + case 588: #line 113 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(4) - (5)].list), @@ -25517,7 +25682,7 @@ YYLTYPE yylloc; ;} break; - case 583: + case 589: #line 121 "third_party/libpg_query/grammar/statements/select.y" { insertSelectOptions((PGSelectStmt *) (yyvsp[(2) - (5)].node), (yyvsp[(3) - (5)].list), (yyvsp[(5) - (5)].list), @@ -25528,24 +25693,24 @@ YYLTYPE yylloc; ;} break; - case 584: + case 590: #line 131 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 585: + case 591: #line 132 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 586: + case 592: #line 160 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 587: + case 593: #line 164 "third_party/libpg_query/grammar/statements/select.y" { PGAStar *star = makeNode(PGAStar); @@ -25553,7 +25718,7 @@ YYLTYPE yylloc; ;} break; - case 588: + case 594: #line 175 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *n = makeNode(PGSelectStmt); @@ -25570,7 +25735,7 @@ YYLTYPE yylloc; ;} break; - case 589: + case 595: #line 191 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *n = makeNode(PGSelectStmt); @@ -25588,7 +25753,7 @@ YYLTYPE yylloc; ;} break; - case 590: + case 596: #line 208 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *n = makeNode(PGSelectStmt); @@ -25606,7 +25771,7 @@ YYLTYPE yylloc; ;} break; - case 591: + case 597: #line 226 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *n = makeNode(PGSelectStmt); @@ -25625,12 +25790,12 @@ YYLTYPE yylloc; ;} break; - case 592: + case 598: #line 241 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 593: + case 599: #line 243 "third_party/libpg_query/grammar/statements/select.y" { /* same as SELECT * FROM relation_expr */ @@ -25652,35 +25817,35 @@ YYLTYPE yylloc; ;} break; - case 594: + case 600: #line 262 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSetOp(PG_SETOP_UNION_BY_NAME, (yyvsp[(3) - (5)].boolean), (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node)); ;} break; - case 595: + case 601: #line 266 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSetOp(PG_SETOP_UNION, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); ;} break; - case 596: + case 602: #line 270 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSetOp(PG_SETOP_INTERSECT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); ;} break; - case 597: + case 603: #line 274 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSetOp(PG_SETOP_EXCEPT, (yyvsp[(3) - (4)].boolean), (yyvsp[(1) - (4)].node), (yyvsp[(4) - (4)].node)); ;} break; - case 598: + case 604: #line 278 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25693,7 +25858,7 @@ YYLTYPE yylloc; ;} break; - case 599: + case 605: #line 288 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25707,7 +25872,7 @@ YYLTYPE yylloc; ;} break; - case 600: + case 606: #line 299 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25720,7 +25885,7 @@ YYLTYPE yylloc; ;} break; - case 601: + case 607: #line 309 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25732,7 +25897,7 @@ YYLTYPE yylloc; ;} break; - case 602: + case 608: #line 318 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25746,7 +25911,7 @@ YYLTYPE yylloc; ;} break; - case 603: + case 609: #line 329 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25760,7 +25925,7 @@ YYLTYPE yylloc; ;} break; - case 604: + case 610: #line 340 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25775,7 +25940,7 @@ YYLTYPE yylloc; ;} break; - case 605: + case 611: #line 352 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25793,7 +25958,7 @@ YYLTYPE yylloc; ;} break; - case 606: + case 612: #line 367 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *res = makeNode(PGSelectStmt); @@ -25811,7 +25976,7 @@ YYLTYPE yylloc; ;} break; - case 613: + case 619: #line 397 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -25820,7 +25985,7 @@ YYLTYPE yylloc; ;} break; - case 614: + case 620: #line 403 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -25830,32 +25995,32 @@ YYLTYPE yylloc; ;} break; - case 615: + case 621: #line 409 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 616: + case 622: #line 413 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 617: + case 623: #line 414 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 618: + case 624: #line 418 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 619: + case 625: #line 419 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 620: + case 626: #line 434 "third_party/libpg_query/grammar/statements/select.y" { (yyval.with) = makeNode(PGWithClause); @@ -25865,7 +26030,7 @@ YYLTYPE yylloc; ;} break; - case 621: + case 627: #line 441 "third_party/libpg_query/grammar/statements/select.y" { (yyval.with) = makeNode(PGWithClause); @@ -25875,7 +26040,7 @@ YYLTYPE yylloc; ;} break; - case 622: + case 628: #line 448 "third_party/libpg_query/grammar/statements/select.y" { (yyval.with) = makeNode(PGWithClause); @@ -25885,17 +26050,17 @@ YYLTYPE yylloc; ;} break; - case 623: + case 629: #line 457 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 624: + case 630: #line 458 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 625: + case 631: #line 462 "third_party/libpg_query/grammar/statements/select.y" { PGCommonTableExpr *n = makeNode(PGCommonTableExpr); @@ -25909,52 +26074,52 @@ YYLTYPE yylloc; ;} break; - case 626: + case 632: #line 475 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 627: + case 633: #line 476 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(NIL); ;} break; - case 628: + case 634: #line 480 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 629: + case 635: #line 481 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 630: + case 636: #line 485 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 631: + case 637: #line 486 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 632: + case 638: #line 490 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ctematerialize) = PGCTEMaterializeAlways; ;} break; - case 633: + case 639: #line 491 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ctematerialize) = PGCTEMaterializeNever; ;} break; - case 634: + case 640: #line 492 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ctematerialize) = PGCTEMaterializeDefault; ;} break; - case 635: + case 641: #line 497 "third_party/libpg_query/grammar/statements/select.y" { (yyval.into) = makeNode(PGIntoClause); @@ -25967,12 +26132,12 @@ YYLTYPE yylloc; ;} break; - case 636: + case 642: #line 507 "third_party/libpg_query/grammar/statements/select.y" { (yyval.into) = NULL; ;} break; - case 637: + case 643: #line 516 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(3) - (3)].range); @@ -25980,7 +26145,7 @@ YYLTYPE yylloc; ;} break; - case 638: + case 644: #line 521 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(3) - (3)].range); @@ -25988,7 +26153,7 @@ YYLTYPE yylloc; ;} break; - case 639: + case 645: #line 526 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(4) - (4)].range); @@ -25996,7 +26161,7 @@ YYLTYPE yylloc; ;} break; - case 640: + case 646: #line 531 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(4) - (4)].range); @@ -26004,7 +26169,7 @@ YYLTYPE yylloc; ;} break; - case 641: + case 647: #line 536 "third_party/libpg_query/grammar/statements/select.y" { ereport(PGWARNING, @@ -26015,7 +26180,7 @@ YYLTYPE yylloc; ;} break; - case 642: + case 648: #line 544 "third_party/libpg_query/grammar/statements/select.y" { ereport(PGWARNING, @@ -26026,7 +26191,7 @@ YYLTYPE yylloc; ;} break; - case 643: + case 649: #line 552 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(3) - (3)].range); @@ -26034,7 +26199,7 @@ YYLTYPE yylloc; ;} break; - case 644: + case 650: #line 557 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(2) - (2)].range); @@ -26042,7 +26207,7 @@ YYLTYPE yylloc; ;} break; - case 645: + case 651: #line 562 "third_party/libpg_query/grammar/statements/select.y" { (yyval.range) = (yyvsp[(1) - (1)].range); @@ -26050,87 +26215,87 @@ YYLTYPE yylloc; ;} break; - case 646: + case 652: #line 568 "third_party/libpg_query/grammar/statements/select.y" {;} break; - case 647: + case 653: #line 569 "third_party/libpg_query/grammar/statements/select.y" {;} break; - case 648: + case 654: #line 573 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; - case 649: + case 655: #line 574 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 650: + case 656: #line 575 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 651: + case 657: #line 579 "third_party/libpg_query/grammar/statements/select.y" { ;} break; - case 652: + case 658: #line 586 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(NIL); ;} break; - case 653: + case 659: #line 587 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 654: + case 660: #line 591 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL;;} break; - case 655: + case 661: #line 592 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 656: + case 662: #line 596 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ignorenulls) = PG_IGNORE_NULLS;;} break; - case 657: + case 663: #line 597 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ignorenulls) = PG_RESPECT_NULLS;;} break; - case 658: + case 664: #line 598 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ignorenulls) = PG_DEFAULT_NULLS; ;} break; - case 659: + case 665: #line 602 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 660: + case 666: #line 603 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 661: + case 667: #line 607 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 662: + case 668: #line 609 "third_party/libpg_query/grammar/statements/select.y" { PGSortBy *sort = makeNode(PGSortBy); @@ -26146,17 +26311,17 @@ YYLTYPE yylloc; ;} break; - case 663: + case 669: #line 624 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].sortby)); ;} break; - case 664: + case 670: #line 625 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].sortby)); ;} break; - case 665: + case 671: #line 629 "third_party/libpg_query/grammar/statements/select.y" { (yyval.sortby) = makeNode(PGSortBy); @@ -26168,7 +26333,7 @@ YYLTYPE yylloc; ;} break; - case 666: + case 672: #line 638 "third_party/libpg_query/grammar/statements/select.y" { (yyval.sortby) = makeNode(PGSortBy); @@ -26180,72 +26345,72 @@ YYLTYPE yylloc; ;} break; - case 667: + case 673: #line 648 "third_party/libpg_query/grammar/statements/select.y" { (yyval.sortorder) = PG_SORTBY_ASC; ;} break; - case 668: + case 674: #line 649 "third_party/libpg_query/grammar/statements/select.y" { (yyval.sortorder) = PG_SORTBY_DESC; ;} break; - case 669: + case 675: #line 650 "third_party/libpg_query/grammar/statements/select.y" { (yyval.sortorder) = PG_SORTBY_DEFAULT; ;} break; - case 670: + case 676: #line 653 "third_party/libpg_query/grammar/statements/select.y" { (yyval.nullorder) = PG_SORTBY_NULLS_FIRST; ;} break; - case 671: + case 677: #line 654 "third_party/libpg_query/grammar/statements/select.y" { (yyval.nullorder) = PG_SORTBY_NULLS_LAST; ;} break; - case 672: + case 678: #line 655 "third_party/libpg_query/grammar/statements/select.y" { (yyval.nullorder) = PG_SORTBY_NULLS_DEFAULT; ;} break; - case 673: + case 679: #line 659 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3((yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node), NULL); ;} break; - case 674: + case 680: #line 660 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node), (yyvsp[(1) - (2)].node)); ;} break; - case 675: + case 681: #line 661 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3(NULL, (yyvsp[(1) - (1)].node), NULL); ;} break; - case 676: + case 682: #line 662 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3((yyvsp[(1) - (1)].node), NULL, (yyvsp[(1) - (1)].node)); ;} break; - case 677: + case 683: #line 666 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 678: + case 684: #line 667 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3(NULL,NULL,NULL); ;} break; - case 679: + case 685: #line 672 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 680: + case 686: #line 674 "third_party/libpg_query/grammar/statements/select.y" { /* Disabled because it was too confusing, bjm 2002-02-18 */ @@ -26257,91 +26422,91 @@ YYLTYPE yylloc; ;} break; - case 681: + case 687: #line 690 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(3) - (5)].node); ;} break; - case 682: + case 688: #line 692 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntConst(1, -1); ;} break; - case 683: + case 689: #line 697 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 684: + case 690: #line 700 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 685: + case 691: #line 705 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 686: + case 692: #line 709 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); ;} break; - case 688: + case 694: #line 720 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSampleSize((yyvsp[(1) - (2)].node), true); ;} break; - case 689: + case 695: #line 724 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSampleSize((yyvsp[(1) - (2)].node), true); ;} break; - case 690: + case 696: #line 728 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSampleSize((yyvsp[(1) - (1)].node), false); ;} break; - case 691: + case 697: #line 732 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSampleSize((yyvsp[(1) - (2)].node), false); ;} break; - case 692: + case 698: #line 739 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(3) - (3)].node); ;} break; - case 693: + case 699: #line 743 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 694: + case 700: #line 750 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 695: + case 701: #line 751 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = NULL; ;} break; - case 696: + case 702: #line 756 "third_party/libpg_query/grammar/statements/select.y" { int seed = (yyvsp[(5) - (5)].ival); @@ -26349,21 +26514,21 @@ YYLTYPE yylloc; ;} break; - case 697: + case 703: #line 761 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSampleOptions((yyvsp[(1) - (1)].node), NULL, NULL, (yylsp[(1) - (1)])); ;} break; - case 698: + case 704: #line 765 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeSampleOptions((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].str), NULL, (yylsp[(1) - (4)])); ;} break; - case 699: + case 705: #line 769 "third_party/libpg_query/grammar/statements/select.y" { int seed = (yyvsp[(5) - (6)].ival); @@ -26371,44 +26536,44 @@ YYLTYPE yylloc; ;} break; - case 700: + case 706: #line 777 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 701: + case 707: #line 783 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 702: + case 708: #line 784 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 703: + case 709: #line 789 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = (yyvsp[(3) - (4)].ival); ;} break; - case 704: + case 710: #line 790 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = -1; ;} break; - case 705: + case 711: #line 795 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "TIMESTAMP"; ;} break; - case 706: + case 712: #line 796 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "VERSION"; ;} break; - case 707: + case 713: #line 801 "third_party/libpg_query/grammar/statements/select.y" { PGAtClause *n = makeNode(PGAtClause); @@ -26418,22 +26583,22 @@ YYLTYPE yylloc; ;} break; - case 708: + case 714: #line 810 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(3) - (4)].node); ;} break; - case 709: + case 715: #line 811 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 710: + case 716: #line 816 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 711: + case 717: #line 818 "third_party/libpg_query/grammar/statements/select.y" { /* LIMIT ALL is represented as a NULL constant */ @@ -26441,77 +26606,77 @@ YYLTYPE yylloc; ;} break; - case 712: + case 718: #line 823 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeLimitPercent((yyvsp[(1) - (2)].node)); ;} break; - case 713: + case 719: #line 825 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeLimitPercent(makeFloatConst((yyvsp[(1) - (2)].str),(yylsp[(1) - (2)]))); ;} break; - case 714: + case 720: #line 827 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeLimitPercent(makeIntConst((yyvsp[(1) - (2)].ival),(yylsp[(1) - (2)]))); ;} break; - case 715: + case 721: #line 831 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 716: + case 722: #line 851 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 717: + case 723: #line 853 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 718: + case 724: #line 855 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 719: + case 725: #line 859 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival),(yylsp[(1) - (1)])); ;} break; - case 720: + case 726: #line 860 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str),(yylsp[(1) - (1)])); ;} break; - case 721: + case 727: #line 864 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; - case 722: + case 728: #line 865 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; - case 723: + case 729: #line 868 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; - case 724: + case 730: #line 869 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; - case 725: + case 731: #line 894 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 726: + case 732: #line 896 "third_party/libpg_query/grammar/statements/select.y" { PGNode *node = (PGNode *) makeGroupingSet(GROUPING_SET_ALL, NIL, (yylsp[(3) - (3)])); @@ -26519,145 +26684,145 @@ YYLTYPE yylloc; ;} break; - case 727: + case 733: #line 900 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 728: + case 734: #line 904 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 729: + case 735: #line 905 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list),(yyvsp[(3) - (3)].node)); ;} break; - case 730: + case 736: #line 909 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 731: + case 737: #line 910 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 732: + case 738: #line 914 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 733: + case 739: #line 915 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 734: + case 740: #line 916 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 735: + case 741: #line 917 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 736: + case 742: #line 918 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 737: + case 743: #line 923 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_EMPTY, NIL, (yylsp[(1) - (2)])); ;} break; - case 738: + case 744: #line 936 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_ROLLUP, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); ;} break; - case 739: + case 745: #line 943 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_CUBE, (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); ;} break; - case 740: + case 746: #line 950 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeGroupingSet(GROUPING_SET_SETS, (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); ;} break; - case 741: + case 747: #line 956 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 742: + case 748: #line 957 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 743: + case 749: #line 961 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 744: + case 750: #line 962 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 745: + case 751: #line 966 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 746: + case 752: #line 967 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 747: + case 753: #line 971 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 748: + case 754: #line 972 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 749: + case 755: #line 976 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 750: + case 756: #line 977 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 751: + case 757: #line 981 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 752: + case 758: #line 982 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 753: + case 759: #line 987 "third_party/libpg_query/grammar/statements/select.y" { PGLockingClause *n = makeNode(PGLockingClause); @@ -26668,52 +26833,52 @@ YYLTYPE yylloc; ;} break; - case 754: + case 760: #line 997 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockstrength) = LCS_FORUPDATE; ;} break; - case 755: + case 761: #line 998 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockstrength) = PG_LCS_FORNOKEYUPDATE; ;} break; - case 756: + case 762: #line 999 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockstrength) = PG_LCS_FORSHARE; ;} break; - case 757: + case 763: #line 1000 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockstrength) = PG_LCS_FORKEYSHARE; ;} break; - case 758: + case 764: #line 1004 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 759: + case 765: #line 1005 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 760: + case 766: #line 1010 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockwaitpolicy) = LockWaitError; ;} break; - case 761: + case 767: #line 1011 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockwaitpolicy) = PGLockWaitSkip; ;} break; - case 762: + case 768: #line 1012 "third_party/libpg_query/grammar/statements/select.y" { (yyval.lockwaitpolicy) = PGLockWaitBlock; ;} break; - case 763: + case 769: #line 1022 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *n = makeNode(PGSelectStmt); @@ -26722,7 +26887,7 @@ YYLTYPE yylloc; ;} break; - case 764: + case 770: #line 1028 "third_party/libpg_query/grammar/statements/select.y" { PGSelectStmt *n = (PGSelectStmt *) (yyvsp[(1) - (5)].node); @@ -26731,47 +26896,47 @@ YYLTYPE yylloc; ;} break; - case 765: + case 771: #line 1036 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 766: + case 772: #line 1037 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (2)].node); ;} break; - case 767: + case 773: #line 1050 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 768: + case 774: #line 1051 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 769: + case 775: #line 1055 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 770: + case 776: #line 1056 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 771: + case 777: #line 1060 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 772: + case 778: #line 1061 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 773: + case 779: #line 1066 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = makeNode(PGAlias); @@ -26779,7 +26944,7 @@ YYLTYPE yylloc; ;} break; - case 774: + case 780: #line 1077 "third_party/libpg_query/grammar/statements/select.y" { (yyvsp[(1) - (4)].range)->at_clause = (yyvsp[(3) - (4)].node); @@ -26789,7 +26954,7 @@ YYLTYPE yylloc; ;} break; - case 775: + case 781: #line 1084 "third_party/libpg_query/grammar/statements/select.y" { (yyvsp[(2) - (4)].range)->at_clause = (yyvsp[(3) - (4)].node); @@ -26799,7 +26964,7 @@ YYLTYPE yylloc; ;} break; - case 776: + case 782: #line 1091 "third_party/libpg_query/grammar/statements/select.y" { PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(1) - (3)].node); @@ -26810,7 +26975,7 @@ YYLTYPE yylloc; ;} break; - case 777: + case 783: #line 1099 "third_party/libpg_query/grammar/statements/select.y" { PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(2) - (3)].node); @@ -26820,7 +26985,7 @@ YYLTYPE yylloc; ;} break; - case 778: + case 784: #line 1107 "third_party/libpg_query/grammar/statements/select.y" { PGRangeSubselect *n = makeNode(PGRangeSubselect); @@ -26832,7 +26997,7 @@ YYLTYPE yylloc; ;} break; - case 779: + case 785: #line 1117 "third_party/libpg_query/grammar/statements/select.y" { PGRangeFunction *n = (PGRangeFunction *) (yyvsp[(2) - (3)].node); @@ -26843,7 +27008,7 @@ YYLTYPE yylloc; ;} break; - case 780: + case 786: #line 1125 "third_party/libpg_query/grammar/statements/select.y" { PGRangeSubselect *n = makeNode(PGRangeSubselect); @@ -26855,7 +27020,7 @@ YYLTYPE yylloc; ;} break; - case 781: + case 787: #line 1134 "third_party/libpg_query/grammar/statements/select.y" { PGRangeSubselect *n = makeNode(PGRangeSubselect); @@ -26867,7 +27032,7 @@ YYLTYPE yylloc; ;} break; - case 782: + case 788: #line 1143 "third_party/libpg_query/grammar/statements/select.y" { PGRangeSubselect *n = makeNode(PGRangeSubselect); @@ -26879,14 +27044,14 @@ YYLTYPE yylloc; ;} break; - case 783: + case 789: #line 1152 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].jexpr); ;} break; - case 784: + case 790: #line 1156 "third_party/libpg_query/grammar/statements/select.y" { (yyvsp[(2) - (4)].jexpr)->alias = (yyvsp[(4) - (4)].alias); @@ -26894,7 +27059,7 @@ YYLTYPE yylloc; ;} break; - case 785: + case 791: #line 1161 "third_party/libpg_query/grammar/statements/select.y" { (yyvsp[(3) - (4)].jexpr)->alias = (yyvsp[(1) - (4)].alias); @@ -26902,7 +27067,7 @@ YYLTYPE yylloc; ;} break; - case 786: + case 792: #line 1166 "third_party/libpg_query/grammar/statements/select.y" { PGPivotExpr *n = makeNode(PGPivotExpr); @@ -26916,7 +27081,7 @@ YYLTYPE yylloc; ;} break; - case 787: + case 793: #line 1177 "third_party/libpg_query/grammar/statements/select.y" { PGPivotExpr *n = makeNode(PGPivotExpr); @@ -26930,32 +27095,32 @@ YYLTYPE yylloc; ;} break; - case 788: + case 794: #line 1190 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 789: + case 795: #line 1191 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 790: + case 796: #line 1194 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; - case 791: + case 797: #line 1195 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 792: + case 798: #line 1196 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 793: + case 799: #line 1200 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -26965,7 +27130,7 @@ YYLTYPE yylloc; ;} break; - case 794: + case 800: #line 1208 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -26975,22 +27140,22 @@ YYLTYPE yylloc; ;} break; - case 795: + case 801: #line 1217 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 796: + case 802: #line 1218 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 797: + case 803: #line 1219 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 798: + case 804: #line 1223 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -27000,7 +27165,7 @@ YYLTYPE yylloc; ;} break; - case 799: + case 805: #line 1231 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -27010,31 +27175,31 @@ YYLTYPE yylloc; ;} break; - case 800: + case 806: #line 1240 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 801: + case 807: #line 1244 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 802: + case 808: #line 1250 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 803: + case 809: #line 1251 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 804: + case 810: #line 1256 "third_party/libpg_query/grammar/statements/select.y" { PGPivot *n = makeNode(PGPivot); @@ -27044,28 +27209,28 @@ YYLTYPE yylloc; ;} break; - case 805: + case 811: #line 1265 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 806: + case 812: #line 1269 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 807: + case 813: #line 1294 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jexpr) = (yyvsp[(2) - (3)].jexpr); ;} break; - case 808: + case 814: #line 1298 "third_party/libpg_query/grammar/statements/select.y" { /* CROSS JOIN is same as unqualified inner join */ @@ -27081,7 +27246,7 @@ YYLTYPE yylloc; ;} break; - case 809: + case 815: #line 1311 "third_party/libpg_query/grammar/statements/select.y" { PGJoinExpr *n = makeNode(PGJoinExpr); @@ -27098,7 +27263,7 @@ YYLTYPE yylloc; ;} break; - case 810: + case 816: #line 1325 "third_party/libpg_query/grammar/statements/select.y" { /* letting join_type reduce to empty doesn't work */ @@ -27116,7 +27281,7 @@ YYLTYPE yylloc; ;} break; - case 811: + case 817: #line 1340 "third_party/libpg_query/grammar/statements/select.y" { PGJoinExpr *n = makeNode(PGJoinExpr); @@ -27131,7 +27296,7 @@ YYLTYPE yylloc; ;} break; - case 812: + case 818: #line 1352 "third_party/libpg_query/grammar/statements/select.y" { /* letting join_type reduce to empty doesn't work */ @@ -27147,7 +27312,7 @@ YYLTYPE yylloc; ;} break; - case 813: + case 819: #line 1365 "third_party/libpg_query/grammar/statements/select.y" { PGJoinExpr *n = makeNode(PGJoinExpr); @@ -27164,7 +27329,7 @@ YYLTYPE yylloc; ;} break; - case 814: + case 820: #line 1379 "third_party/libpg_query/grammar/statements/select.y" { PGJoinExpr *n = makeNode(PGJoinExpr); @@ -27181,7 +27346,7 @@ YYLTYPE yylloc; ;} break; - case 815: + case 821: #line 1393 "third_party/libpg_query/grammar/statements/select.y" { /* POSITIONAL JOIN is a coordinated scan */ @@ -27197,7 +27362,7 @@ YYLTYPE yylloc; ;} break; - case 816: + case 822: #line 1406 "third_party/libpg_query/grammar/statements/select.y" { /* ANTI JOIN is a filter */ @@ -27215,7 +27380,7 @@ YYLTYPE yylloc; ;} break; - case 817: + case 823: #line 1421 "third_party/libpg_query/grammar/statements/select.y" { /* SEMI JOIN is also a filter */ @@ -27234,7 +27399,7 @@ YYLTYPE yylloc; ;} break; - case 818: + case 824: #line 1440 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = makeNode(PGAlias); @@ -27243,7 +27408,7 @@ YYLTYPE yylloc; ;} break; - case 819: + case 825: #line 1446 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = makeNode(PGAlias); @@ -27251,7 +27416,7 @@ YYLTYPE yylloc; ;} break; - case 820: + case 826: #line 1451 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = makeNode(PGAlias); @@ -27260,7 +27425,7 @@ YYLTYPE yylloc; ;} break; - case 821: + case 827: #line 1457 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = makeNode(PGAlias); @@ -27268,31 +27433,31 @@ YYLTYPE yylloc; ;} break; - case 822: + case 828: #line 1463 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = (yyvsp[(1) - (1)].alias); ;} break; - case 823: + case 829: #line 1464 "third_party/libpg_query/grammar/statements/select.y" { (yyval.alias) = NULL; ;} break; - case 824: + case 830: #line 1473 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (1)].alias), NIL); ;} break; - case 825: + case 831: #line 1477 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2(NULL, (yyvsp[(3) - (4)].list)); ;} break; - case 826: + case 832: #line 1481 "third_party/libpg_query/grammar/statements/select.y" { PGAlias *a = makeNode(PGAlias); @@ -27301,7 +27466,7 @@ YYLTYPE yylloc; ;} break; - case 827: + case 833: #line 1487 "third_party/libpg_query/grammar/statements/select.y" { PGAlias *a = makeNode(PGAlias); @@ -27310,64 +27475,64 @@ YYLTYPE yylloc; ;} break; - case 828: + case 834: #line 1493 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2(NULL, NIL); ;} break; - case 829: + case 835: #line 1498 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jtype) = PG_JOIN_FULL; ;} break; - case 830: + case 836: #line 1499 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jtype) = PG_JOIN_LEFT; ;} break; - case 831: + case 837: #line 1500 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jtype) = PG_JOIN_RIGHT; ;} break; - case 832: + case 838: #line 1501 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jtype) = PG_JOIN_SEMI; ;} break; - case 833: + case 839: #line 1502 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jtype) = PG_JOIN_ANTI; ;} break; - case 834: + case 840: #line 1503 "third_party/libpg_query/grammar/statements/select.y" { (yyval.jtype) = PG_JOIN_INNER; ;} break; - case 835: + case 841: #line 1507 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 836: + case 842: #line 1508 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 837: + case 843: #line 1520 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) (yyvsp[(3) - (4)].list); ;} break; - case 838: + case 844: #line 1521 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 839: + case 845: #line 1527 "third_party/libpg_query/grammar/statements/select.y" { /* inheritance query, implicitly */ @@ -27377,7 +27542,7 @@ YYLTYPE yylloc; ;} break; - case 840: + case 846: #line 1534 "third_party/libpg_query/grammar/statements/select.y" { /* inheritance query, explicitly */ @@ -27387,7 +27552,7 @@ YYLTYPE yylloc; ;} break; - case 841: + case 847: #line 1541 "third_party/libpg_query/grammar/statements/select.y" { /* no inheritance */ @@ -27397,7 +27562,7 @@ YYLTYPE yylloc; ;} break; - case 842: + case 848: #line 1548 "third_party/libpg_query/grammar/statements/select.y" { /* no inheritance, SQL99-style syntax */ @@ -27407,7 +27572,7 @@ YYLTYPE yylloc; ;} break; - case 843: + case 849: #line 1580 "third_party/libpg_query/grammar/statements/select.y" { PGRangeFunction *n = makeNode(PGRangeFunction); @@ -27421,7 +27586,7 @@ YYLTYPE yylloc; ;} break; - case 844: + case 850: #line 1591 "third_party/libpg_query/grammar/statements/select.y" { PGRangeFunction *n = makeNode(PGRangeFunction); @@ -27435,66 +27600,66 @@ YYLTYPE yylloc; ;} break; - case 845: + case 851: #line 1604 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].list)); ;} break; - case 846: + case 852: #line 1608 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 847: + case 853: #line 1609 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 848: + case 854: #line 1612 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 849: + case 855: #line 1613 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 850: + case 856: #line 1616 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; - case 851: + case 857: #line 1617 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 852: + case 858: #line 1622 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 853: + case 859: #line 1623 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 854: + case 860: #line 1629 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 855: + case 861: #line 1633 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 856: + case 862: #line 1639 "third_party/libpg_query/grammar/statements/select.y" { PGColumnDef *n = makeNode(PGColumnDef); @@ -27515,7 +27680,7 @@ YYLTYPE yylloc; ;} break; - case 857: + case 863: #line 1660 "third_party/libpg_query/grammar/statements/select.y" { PGCollateClause *n = makeNode(PGCollateClause); @@ -27526,36 +27691,36 @@ YYLTYPE yylloc; ;} break; - case 858: + case 864: #line 1667 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 859: + case 865: #line 1681 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(list_make2(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].typnam))); ;} break; - case 860: + case 866: #line 1684 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (4)].list), list_make2(makeString((yyvsp[(3) - (4)].str)), (yyvsp[(4) - (4)].typnam))); ;} break; - case 863: + case 869: #line 1691 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 864: + case 870: #line 1692 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = NULL; ;} break; - case 865: + case 871: #line 1695 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (2)].typnam); @@ -27563,7 +27728,7 @@ YYLTYPE yylloc; ;} break; - case 866: + case 872: #line 1700 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(2) - (3)].typnam); @@ -27572,7 +27737,7 @@ YYLTYPE yylloc; ;} break; - case 867: + case 873: #line 1707 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (5)].typnam); @@ -27580,7 +27745,7 @@ YYLTYPE yylloc; ;} break; - case 868: + case 874: #line 1712 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(2) - (6)].typnam); @@ -27589,7 +27754,7 @@ YYLTYPE yylloc; ;} break; - case 869: + case 875: #line 1718 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (2)].typnam); @@ -27597,7 +27762,7 @@ YYLTYPE yylloc; ;} break; - case 870: + case 876: #line 1723 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(2) - (3)].typnam); @@ -27606,7 +27771,7 @@ YYLTYPE yylloc; ;} break; - case 871: + case 877: #line 1729 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = makeTypeNameFromNameList((yyvsp[(1) - (2)].list)); @@ -27614,7 +27779,7 @@ YYLTYPE yylloc; ;} break; - case 872: + case 878: #line 1734 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("struct"); @@ -27624,7 +27789,7 @@ YYLTYPE yylloc; ;} break; - case 873: + case 879: #line 1741 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("map"); @@ -27634,7 +27799,7 @@ YYLTYPE yylloc; ;} break; - case 874: + case 880: #line 1748 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("union"); @@ -27644,57 +27809,57 @@ YYLTYPE yylloc; ;} break; - case 875: + case 881: #line 1757 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2(makeString((yyvsp[(1) - (3)].str)), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 876: + case 882: #line 1758 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 877: + case 883: #line 1763 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeInteger(-1)); ;} break; - case 878: + case 884: #line 1765 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (4)].list), makeInteger((yyvsp[(3) - (4)].ival))); ;} break; - case 879: + case 885: #line 1767 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 880: + case 886: #line 1771 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 881: + case 887: #line 1772 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 882: + case 888: #line 1773 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 883: + case 889: #line 1774 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 884: + case 890: #line 1775 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 885: + case 891: #line 1777 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (2)].typnam); @@ -27702,7 +27867,7 @@ YYLTYPE yylloc; ;} break; - case 886: + case 892: #line 1782 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (4)].typnam); @@ -27711,27 +27876,27 @@ YYLTYPE yylloc; ;} break; - case 887: + case 893: #line 1801 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 888: + case 894: #line 1802 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 889: + case 895: #line 1803 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 890: + case 896: #line 1804 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 891: + case 897: #line 1816 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = makeTypeName((yyvsp[(1) - (2)].str)); @@ -27740,17 +27905,17 @@ YYLTYPE yylloc; ;} break; - case 892: + case 898: #line 1829 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 893: + case 899: #line 1830 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 894: + case 900: #line 1837 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("int4"); @@ -27758,7 +27923,7 @@ YYLTYPE yylloc; ;} break; - case 895: + case 901: #line 1842 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("int4"); @@ -27766,7 +27931,7 @@ YYLTYPE yylloc; ;} break; - case 896: + case 902: #line 1847 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("int2"); @@ -27774,7 +27939,7 @@ YYLTYPE yylloc; ;} break; - case 897: + case 903: #line 1852 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("int8"); @@ -27782,7 +27947,7 @@ YYLTYPE yylloc; ;} break; - case 898: + case 904: #line 1857 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("float4"); @@ -27790,7 +27955,7 @@ YYLTYPE yylloc; ;} break; - case 899: + case 905: #line 1862 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(2) - (2)].typnam); @@ -27798,7 +27963,7 @@ YYLTYPE yylloc; ;} break; - case 900: + case 906: #line 1867 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("float8"); @@ -27806,7 +27971,7 @@ YYLTYPE yylloc; ;} break; - case 901: + case 907: #line 1872 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("numeric"); @@ -27815,7 +27980,7 @@ YYLTYPE yylloc; ;} break; - case 902: + case 908: #line 1878 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("numeric"); @@ -27824,7 +27989,7 @@ YYLTYPE yylloc; ;} break; - case 903: + case 909: #line 1884 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("numeric"); @@ -27833,7 +27998,7 @@ YYLTYPE yylloc; ;} break; - case 904: + case 910: #line 1890 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("bool"); @@ -27841,7 +28006,7 @@ YYLTYPE yylloc; ;} break; - case 905: + case 911: #line 1897 "third_party/libpg_query/grammar/statements/select.y" { /* @@ -27865,35 +28030,35 @@ YYLTYPE yylloc; ;} break; - case 906: + case 912: #line 1918 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("float4"); ;} break; - case 907: + case 913: #line 1928 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 908: + case 914: #line 1932 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 909: + case 915: #line 1940 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 910: + case 916: #line 1944 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); @@ -27901,7 +28066,7 @@ YYLTYPE yylloc; ;} break; - case 911: + case 917: #line 1952 "third_party/libpg_query/grammar/statements/select.y" { const char *typname; @@ -27913,7 +28078,7 @@ YYLTYPE yylloc; ;} break; - case 912: + case 918: #line 1964 "third_party/libpg_query/grammar/statements/select.y" { /* bit defaults to bit(1), varbit to no limit */ @@ -27930,28 +28095,28 @@ YYLTYPE yylloc; ;} break; - case 913: + case 919: #line 1985 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 914: + case 920: #line 1989 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 915: + case 921: #line 1995 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = (yyvsp[(1) - (1)].typnam); ;} break; - case 916: + case 922: #line 1999 "third_party/libpg_query/grammar/statements/select.y" { /* Length was not specified so allow to be unrestricted. @@ -27965,7 +28130,7 @@ YYLTYPE yylloc; ;} break; - case 917: + case 923: #line 2012 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName((yyvsp[(1) - (4)].conststr)); @@ -27974,7 +28139,7 @@ YYLTYPE yylloc; ;} break; - case 918: + case 924: #line 2020 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName((yyvsp[(1) - (1)].conststr)); @@ -27985,47 +28150,47 @@ YYLTYPE yylloc; ;} break; - case 919: + case 925: #line 2030 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 920: + case 926: #line 2032 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 921: + case 927: #line 2034 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "varchar"; ;} break; - case 922: + case 928: #line 2036 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} break; - case 923: + case 929: #line 2038 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = (yyvsp[(3) - (3)].boolean) ? "varchar": "bpchar"; ;} break; - case 924: + case 930: #line 2040 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = (yyvsp[(2) - (2)].boolean) ? "varchar": "bpchar"; ;} break; - case 925: + case 931: #line 2044 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; - case 926: + case 932: #line 2045 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 927: + case 933: #line 2053 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(5) - (5)].boolean)) @@ -28037,7 +28202,7 @@ YYLTYPE yylloc; ;} break; - case 928: + case 934: #line 2062 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(2) - (2)].boolean)) @@ -28048,7 +28213,7 @@ YYLTYPE yylloc; ;} break; - case 929: + case 935: #line 2070 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(5) - (5)].boolean)) @@ -28060,7 +28225,7 @@ YYLTYPE yylloc; ;} break; - case 930: + case 936: #line 2079 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(2) - (2)].boolean)) @@ -28071,7 +28236,7 @@ YYLTYPE yylloc; ;} break; - case 931: + case 937: #line 2090 "third_party/libpg_query/grammar/statements/select.y" { (yyval.typnam) = SystemTypeName("interval"); @@ -28079,87 +28244,87 @@ YYLTYPE yylloc; ;} break; - case 932: + case 938: #line 2097 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; - case 933: + case 939: #line 2098 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 934: + case 940: #line 2099 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 961: + case 967: #line 2143 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR), (yylsp[(1) - (1)]))); ;} break; - case 962: + case 968: #line 2145 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MONTH), (yylsp[(1) - (1)]))); ;} break; - case 963: + case 969: #line 2147 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY), (yylsp[(1) - (1)]))); ;} break; - case 964: + case 970: #line 2149 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR), (yylsp[(1) - (1)]))); ;} break; - case 965: + case 971: #line 2151 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE), (yylsp[(1) - (1)]))); ;} break; - case 966: + case 972: #line 2153 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(SECOND), (yylsp[(1) - (1)]))); ;} break; - case 967: + case 973: #line 2155 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLISECOND), (yylsp[(1) - (1)]))); ;} break; - case 968: + case 974: #line 2157 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MICROSECOND), (yylsp[(1) - (1)]))); ;} break; - case 969: + case 975: #line 2159 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(WEEK), (yylsp[(1) - (1)]))); ;} break; - case 970: + case 976: #line 2161 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(QUARTER), (yylsp[(1) - (1)]))); ;} break; - case 971: + case 977: #line 2163 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DECADE), (yylsp[(1) - (1)]))); ;} break; - case 972: + case 978: #line 2165 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(CENTURY), (yylsp[(1) - (1)]))); ;} break; - case 973: + case 979: #line 2167 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MILLENNIUM), (yylsp[(1) - (1)]))); ;} break; - case 974: + case 980: #line 2169 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(YEAR) | @@ -28167,7 +28332,7 @@ YYLTYPE yylloc; ;} break; - case 975: + case 981: #line 2174 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | @@ -28175,7 +28340,7 @@ YYLTYPE yylloc; ;} break; - case 976: + case 982: #line 2179 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | @@ -28184,7 +28349,7 @@ YYLTYPE yylloc; ;} break; - case 977: + case 983: #line 2185 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(DAY) | @@ -28194,7 +28359,7 @@ YYLTYPE yylloc; ;} break; - case 978: + case 984: #line 2192 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) | @@ -28202,7 +28367,7 @@ YYLTYPE yylloc; ;} break; - case 979: + case 985: #line 2197 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(HOUR) | @@ -28211,7 +28376,7 @@ YYLTYPE yylloc; ;} break; - case 980: + case 986: #line 2203 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeIntConst(INTERVAL_MASK(MINUTE) | @@ -28219,22 +28384,22 @@ YYLTYPE yylloc; ;} break; - case 981: + case 987: #line 2208 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 982: + case 988: #line 2239 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 983: + case 989: #line 2242 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;} break; - case 984: + case 990: #line 2244 "third_party/libpg_query/grammar/statements/select.y" { PGCollateClause *n = makeNode(PGCollateClause); @@ -28245,7 +28410,7 @@ YYLTYPE yylloc; ;} break; - case 985: + case 991: #line 2252 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("timezone"), @@ -28254,122 +28419,122 @@ YYLTYPE yylloc; ;} break; - case 986: + case 992: #line 2267 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 987: + case 993: #line 2269 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 988: + case 994: #line 2271 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 989: + case 995: #line 2273 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 990: + case 996: #line 2275 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 991: + case 997: #line 2277 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 992: + case 998: #line 2279 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 993: + case 999: #line 2281 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 994: + case 1000: #line 2283 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 995: + case 1001: #line 2285 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 996: + case 1002: #line 2287 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 997: + case 1003: #line 2289 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 998: + case 1004: #line 2291 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 999: + case 1005: #line 2293 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1000: + case 1006: #line 2295 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1001: + case 1007: #line 2297 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1002: + case 1008: #line 2300 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1003: + case 1009: #line 2302 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1004: + case 1010: #line 2304 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} break; - case 1005: + case 1011: #line 2307 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeAndExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1006: + case 1012: #line 2309 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeOrExpr((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1007: + case 1013: #line 2311 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1008: + case 1014: #line 2313 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeNotExpr((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1009: + case 1015: #line 2315 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_GLOB, "~~~", @@ -28377,7 +28542,7 @@ YYLTYPE yylloc; ;} break; - case 1010: + case 1016: #line 2320 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "~~", @@ -28385,7 +28550,7 @@ YYLTYPE yylloc; ;} break; - case 1011: + case 1017: #line 2325 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("like_escape"), @@ -28395,7 +28560,7 @@ YYLTYPE yylloc; ;} break; - case 1012: + case 1018: #line 2332 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_LIKE, "!~~", @@ -28403,7 +28568,7 @@ YYLTYPE yylloc; ;} break; - case 1013: + case 1019: #line 2337 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("not_like_escape"), @@ -28413,7 +28578,7 @@ YYLTYPE yylloc; ;} break; - case 1014: + case 1020: #line 2344 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "~~*", @@ -28421,7 +28586,7 @@ YYLTYPE yylloc; ;} break; - case 1015: + case 1021: #line 2349 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("ilike_escape"), @@ -28431,7 +28596,7 @@ YYLTYPE yylloc; ;} break; - case 1016: + case 1022: #line 2356 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_ILIKE, "!~~*", @@ -28439,7 +28604,7 @@ YYLTYPE yylloc; ;} break; - case 1017: + case 1023: #line 2361 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("not_ilike_escape"), @@ -28449,7 +28614,7 @@ YYLTYPE yylloc; ;} break; - case 1018: + case 1024: #line 2369 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), @@ -28460,7 +28625,7 @@ YYLTYPE yylloc; ;} break; - case 1019: + case 1025: #line 2377 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), @@ -28471,7 +28636,7 @@ YYLTYPE yylloc; ;} break; - case 1020: + case 1026: #line 2385 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), @@ -28482,7 +28647,7 @@ YYLTYPE yylloc; ;} break; - case 1021: + case 1027: #line 2393 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("similar_escape"), @@ -28493,7 +28658,7 @@ YYLTYPE yylloc; ;} break; - case 1022: + case 1028: #line 2411 "third_party/libpg_query/grammar/statements/select.y" { PGNullTest *n = makeNode(PGNullTest); @@ -28504,7 +28669,7 @@ YYLTYPE yylloc; ;} break; - case 1023: + case 1029: #line 2419 "third_party/libpg_query/grammar/statements/select.y" { PGNullTest *n = makeNode(PGNullTest); @@ -28515,7 +28680,7 @@ YYLTYPE yylloc; ;} break; - case 1024: + case 1030: #line 2427 "third_party/libpg_query/grammar/statements/select.y" { PGNullTest *n = makeNode(PGNullTest); @@ -28526,7 +28691,7 @@ YYLTYPE yylloc; ;} break; - case 1025: + case 1031: #line 2435 "third_party/libpg_query/grammar/statements/select.y" { PGNullTest *n = makeNode(PGNullTest); @@ -28537,7 +28702,7 @@ YYLTYPE yylloc; ;} break; - case 1026: + case 1032: #line 2443 "third_party/libpg_query/grammar/statements/select.y" { PGNullTest *n = makeNode(PGNullTest); @@ -28548,7 +28713,7 @@ YYLTYPE yylloc; ;} break; - case 1027: + case 1033: #line 2451 "third_party/libpg_query/grammar/statements/select.y" { PGLambdaFunction *n = makeNode(PGLambdaFunction); @@ -28559,7 +28724,7 @@ YYLTYPE yylloc; ;} break; - case 1028: + case 1034: #line 2459 "third_party/libpg_query/grammar/statements/select.y" { PGSingleArrowFunction *n = makeNode(PGSingleArrowFunction); @@ -28570,14 +28735,14 @@ YYLTYPE yylloc; ;} break; - case 1029: + case 1035: #line 2467 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "->>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1030: + case 1036: #line 2471 "third_party/libpg_query/grammar/statements/select.y" { if (list_length((yyvsp[(1) - (3)].list)) != 2) @@ -28596,7 +28761,7 @@ YYLTYPE yylloc; ;} break; - case 1031: + case 1037: #line 2487 "third_party/libpg_query/grammar/statements/select.y" { PGBooleanTest *b = makeNode(PGBooleanTest); @@ -28607,7 +28772,7 @@ YYLTYPE yylloc; ;} break; - case 1032: + case 1038: #line 2495 "third_party/libpg_query/grammar/statements/select.y" { PGBooleanTest *b = makeNode(PGBooleanTest); @@ -28618,7 +28783,7 @@ YYLTYPE yylloc; ;} break; - case 1033: + case 1039: #line 2503 "third_party/libpg_query/grammar/statements/select.y" { PGBooleanTest *b = makeNode(PGBooleanTest); @@ -28629,7 +28794,7 @@ YYLTYPE yylloc; ;} break; - case 1034: + case 1040: #line 2511 "third_party/libpg_query/grammar/statements/select.y" { PGBooleanTest *b = makeNode(PGBooleanTest); @@ -28640,7 +28805,7 @@ YYLTYPE yylloc; ;} break; - case 1035: + case 1041: #line 2519 "third_party/libpg_query/grammar/statements/select.y" { PGBooleanTest *b = makeNode(PGBooleanTest); @@ -28651,7 +28816,7 @@ YYLTYPE yylloc; ;} break; - case 1036: + case 1042: #line 2527 "third_party/libpg_query/grammar/statements/select.y" { PGBooleanTest *b = makeNode(PGBooleanTest); @@ -28662,35 +28827,35 @@ YYLTYPE yylloc; ;} break; - case 1037: + case 1043: #line 2535 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); ;} break; - case 1038: + case 1044: #line 2539 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)])); ;} break; - case 1039: + case 1045: #line 2543 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); ;} break; - case 1040: + case 1046: #line 2547 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); ;} break; - case 1041: + case 1047: #line 2551 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN, @@ -28701,7 +28866,7 @@ YYLTYPE yylloc; ;} break; - case 1042: + case 1048: #line 2559 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN, @@ -28712,7 +28877,7 @@ YYLTYPE yylloc; ;} break; - case 1043: + case 1049: #line 2567 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_BETWEEN_SYM, @@ -28723,7 +28888,7 @@ YYLTYPE yylloc; ;} break; - case 1044: + case 1050: #line 2575 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_BETWEEN_SYM, @@ -28734,7 +28899,7 @@ YYLTYPE yylloc; ;} break; - case 1045: + case 1051: #line 2583 "third_party/libpg_query/grammar/statements/select.y" { /* in_expr returns a PGSubLink or a list of a_exprs */ @@ -28757,7 +28922,7 @@ YYLTYPE yylloc; ;} break; - case 1046: + case 1052: #line 2603 "third_party/libpg_query/grammar/statements/select.y" { /* in_expr returns a PGSubLink or a list of a_exprs */ @@ -28782,7 +28947,7 @@ YYLTYPE yylloc; ;} break; - case 1047: + case 1053: #line 2625 "third_party/libpg_query/grammar/statements/select.y" { PGSubLink *n = makeNode(PGSubLink); @@ -28796,7 +28961,7 @@ YYLTYPE yylloc; ;} break; - case 1048: + case 1054: #line 2636 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(3) - (6)].subquerytype) == PG_ANY_SUBLINK) @@ -28806,7 +28971,7 @@ YYLTYPE yylloc; ;} break; - case 1049: + case 1055: #line 2643 "third_party/libpg_query/grammar/statements/select.y" { /* @@ -28823,7 +28988,7 @@ YYLTYPE yylloc; ;} break; - case 1050: + case 1056: #line 2657 "third_party/libpg_query/grammar/statements/select.y" { PGAStar *star = makeNode(PGAStar); @@ -28834,7 +28999,7 @@ YYLTYPE yylloc; ;} break; - case 1051: + case 1057: #line 2665 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("unpack"), list_make1((yyvsp[(3) - (4)].node)), (yylsp[(1) - (4)])); @@ -28842,7 +29007,7 @@ YYLTYPE yylloc; ;} break; - case 1052: + case 1058: #line 2670 "third_party/libpg_query/grammar/statements/select.y" { PGAStar *star = makeNode(PGAStar); @@ -28855,7 +29020,7 @@ YYLTYPE yylloc; ;} break; - case 1053: + case 1059: #line 2680 "third_party/libpg_query/grammar/statements/select.y" { PGAStar *star = makeNode(PGAStar); @@ -28867,7 +29032,7 @@ YYLTYPE yylloc; ;} break; - case 1054: + case 1060: #line 2689 "third_party/libpg_query/grammar/statements/select.y" { PGAStar *star = makeNode(PGAStar); @@ -28880,140 +29045,140 @@ YYLTYPE yylloc; ;} break; - case 1055: + case 1061: #line 2710 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1056: + case 1062: #line 2712 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeTypeCast((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].typnam), 0, (yylsp[(2) - (3)])); ;} break; - case 1057: + case 1063: #line 2714 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1058: + case 1064: #line 2716 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = doNegate((yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1059: + case 1065: #line 2718 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "+", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1060: + case 1066: #line 2720 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "-", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1061: + case 1067: #line 2722 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "*", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1062: + case 1068: #line 2724 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "/", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1063: + case 1069: #line 2726 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "//", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1064: + case 1070: #line 2728 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "%", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1065: + case 1071: #line 2730 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "^", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1066: + case 1072: #line 2732 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "**", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1067: + case 1073: #line 2734 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1068: + case 1074: #line 2736 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1069: + case 1075: #line 2738 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1070: + case 1076: #line 2740 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1071: + case 1077: #line 2742 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, ">=", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1072: + case 1078: #line 2744 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OP, "<>", (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1073: + case 1079: #line 2746 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (3)].list), (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), (yylsp[(2) - (3)])); ;} break; - case 1074: + case 1080: #line 2748 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(1) - (2)].list), NULL, (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1075: + case 1081: #line 2750 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeAExpr(PG_AEXPR_OP, (yyvsp[(2) - (2)].list), (yyvsp[(1) - (2)].node), NULL, (yylsp[(2) - (2)])); ;} break; - case 1076: + case 1082: #line 2752 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_DISTINCT, "=", (yyvsp[(1) - (5)].node), (yyvsp[(5) - (5)].node), (yylsp[(2) - (5)])); ;} break; - case 1077: + case 1083: #line 2756 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NOT_DISTINCT, "=", (yyvsp[(1) - (6)].node), (yyvsp[(6) - (6)].node), (yylsp[(2) - (6)])); ;} break; - case 1078: + case 1084: #line 2760 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "=", (yyvsp[(1) - (6)].node), (PGNode *) (yyvsp[(5) - (6)].list), (yylsp[(2) - (6)])); ;} break; - case 1079: + case 1085: #line 2764 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_OF, "<>", (yyvsp[(1) - (7)].node), (PGNode *) (yyvsp[(6) - (7)].list), (yylsp[(2) - (7)])); ;} break; - case 1081: + case 1087: #line 2779 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(2) - (2)].list)) @@ -29028,17 +29193,17 @@ YYLTYPE yylloc; ;} break; - case 1082: + case 1088: #line 2792 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1083: + case 1089: #line 2793 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1084: + case 1090: #line 2795 "third_party/libpg_query/grammar/statements/select.y" { PGSubLink *n = makeNode(PGSubLink); @@ -29052,7 +29217,7 @@ YYLTYPE yylloc; ;} break; - case 1085: + case 1091: #line 2806 "third_party/libpg_query/grammar/statements/select.y" { /* @@ -29079,7 +29244,7 @@ YYLTYPE yylloc; ;} break; - case 1086: + case 1092: #line 2830 "third_party/libpg_query/grammar/statements/select.y" { PGSubLink *n = makeNode(PGSubLink); @@ -29093,7 +29258,7 @@ YYLTYPE yylloc; ;} break; - case 1087: + case 1093: #line 2841 "third_party/libpg_query/grammar/statements/select.y" { PGGroupingFunc *g = makeNode(PGGroupingFunc); @@ -29103,21 +29268,21 @@ YYLTYPE yylloc; ;} break; - case 1088: + case 1094: #line 2851 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (3)].node); ;} break; - case 1089: + case 1095: #line 2855 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1090: + case 1096: #line 2858 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("row"), (yyvsp[(1) - (1)].list), (yylsp[(1) - (1)])); @@ -29125,14 +29290,14 @@ YYLTYPE yylloc; ;} break; - case 1091: + case 1097: #line 2866 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeParamRef(0, (yylsp[(1) - (1)])); ;} break; - case 1092: + case 1098: #line 2870 "third_party/libpg_query/grammar/statements/select.y" { PGParamRef *p = makeNode(PGParamRef); @@ -29142,14 +29307,14 @@ YYLTYPE yylloc; ;} break; - case 1093: + case 1099: #line 2877 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeNamedParamRef((yyvsp[(2) - (2)].str), (yylsp[(1) - (2)])); ;} break; - case 1101: + case 1107: #line 2891 "third_party/libpg_query/grammar/statements/select.y" { PGSubLink *n = makeNode(PGSubLink); @@ -29163,7 +29328,7 @@ YYLTYPE yylloc; ;} break; - case 1102: + case 1108: #line 2901 "third_party/libpg_query/grammar/statements/select.y" { PGList *func_name = list_make1(makeString("construct_array")); @@ -29172,7 +29337,7 @@ YYLTYPE yylloc; ;} break; - case 1103: + case 1109: #line 2907 "third_party/libpg_query/grammar/statements/select.y" { PGPositionalReference *n = makeNode(PGPositionalReference); @@ -29182,7 +29347,7 @@ YYLTYPE yylloc; ;} break; - case 1104: + case 1110: #line 2915 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall(SystemFuncName("list_value"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)])); @@ -29190,7 +29355,7 @@ YYLTYPE yylloc; ;} break; - case 1105: + case 1111: #line 2922 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *f = makeFuncCall(SystemFuncName("struct_pack"), (yyvsp[(2) - (3)].list), (yylsp[(2) - (3)])); @@ -29198,7 +29363,7 @@ YYLTYPE yylloc; ;} break; - case 1106: + case 1112: #line 2929 "third_party/libpg_query/grammar/statements/select.y" { PGList *key_list = NULL; @@ -29218,14 +29383,14 @@ YYLTYPE yylloc; ;} break; - case 1107: + case 1113: #line 2949 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall((yyvsp[(1) - (3)].list), NIL, (yylsp[(1) - (3)])); ;} break; - case 1108: + case 1114: #line 2953 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (5)].list), NIL, (yylsp[(1) - (5)])); @@ -29235,7 +29400,7 @@ YYLTYPE yylloc; ;} break; - case 1109: + case 1115: #line 2960 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (6)].list), (yyvsp[(3) - (6)].list), (yylsp[(1) - (6)])); @@ -29245,7 +29410,7 @@ YYLTYPE yylloc; ;} break; - case 1110: + case 1116: #line 2967 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), list_make1((yyvsp[(4) - (7)].node)), (yylsp[(1) - (7)])); @@ -29256,7 +29421,7 @@ YYLTYPE yylloc; ;} break; - case 1111: + case 1117: #line 2975 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (9)].list), lappend((yyvsp[(3) - (9)].list), (yyvsp[(6) - (9)].node)), (yylsp[(1) - (9)])); @@ -29267,7 +29432,7 @@ YYLTYPE yylloc; ;} break; - case 1112: + case 1118: #line 2983 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)])); @@ -29281,7 +29446,7 @@ YYLTYPE yylloc; ;} break; - case 1113: + case 1119: #line 2994 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = makeFuncCall((yyvsp[(1) - (7)].list), (yyvsp[(4) - (7)].list), (yylsp[(1) - (7)])); @@ -29292,7 +29457,7 @@ YYLTYPE yylloc; ;} break; - case 1114: + case 1120: #line 3014 "third_party/libpg_query/grammar/statements/select.y" { PGFuncCall *n = (PGFuncCall *) (yyvsp[(1) - (5)].node); @@ -29331,22 +29496,22 @@ YYLTYPE yylloc; ;} break; - case 1115: + case 1121: #line 3050 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1116: + case 1122: #line 3060 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1117: + case 1123: #line 3061 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1118: + case 1124: #line 3069 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("pg_collation_for"), @@ -29355,24 +29520,24 @@ YYLTYPE yylloc; ;} break; - case 1119: + case 1125: #line 3075 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 0, (yylsp[(1) - (6)])); ;} break; - case 1120: + case 1126: #line 3077 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeTypeCast((yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].typnam), 1, (yylsp[(1) - (6)])); ;} break; - case 1121: + case 1127: #line 3079 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("date_part"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); ;} break; - case 1122: + case 1128: #line 3083 "third_party/libpg_query/grammar/statements/select.y" { /* overlay(A PLACING B FROM C FOR D) is converted to @@ -29384,7 +29549,7 @@ YYLTYPE yylloc; ;} break; - case 1123: + case 1129: #line 3092 "third_party/libpg_query/grammar/statements/select.y" { /* position(A in B) is converted to position_inverse(A, B) */ @@ -29392,7 +29557,7 @@ YYLTYPE yylloc; ;} break; - case 1124: + case 1130: #line 3097 "third_party/libpg_query/grammar/statements/select.y" { /* substring(A from B for C) is converted to @@ -29402,7 +29567,7 @@ YYLTYPE yylloc; ;} break; - case 1125: + case 1131: #line 3104 "third_party/libpg_query/grammar/statements/select.y" { /* TREAT(expr AS target) converts expr of a particular type to target, @@ -29420,7 +29585,7 @@ YYLTYPE yylloc; ;} break; - case 1126: + case 1132: #line 3119 "third_party/libpg_query/grammar/statements/select.y" { /* various trim expressions are defined in SQL @@ -29430,35 +29595,35 @@ YYLTYPE yylloc; ;} break; - case 1127: + case 1133: #line 3126 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("ltrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); ;} break; - case 1128: + case 1134: #line 3130 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("rtrim"), (yyvsp[(4) - (5)].list), (yylsp[(1) - (5)])); ;} break; - case 1129: + case 1135: #line 3134 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeFuncCall(SystemFuncName("trim"), (yyvsp[(3) - (4)].list), (yylsp[(1) - (4)])); ;} break; - case 1130: + case 1136: #line 3138 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *) makeSimpleAExpr(PG_AEXPR_NULLIF, "=", (yyvsp[(3) - (6)].node), (yyvsp[(5) - (6)].node), (yylsp[(1) - (6)])); ;} break; - case 1131: + case 1137: #line 3142 "third_party/libpg_query/grammar/statements/select.y" { PGCoalesceExpr *c = makeNode(PGCoalesceExpr); @@ -29468,7 +29633,7 @@ YYLTYPE yylloc; ;} break; - case 1132: + case 1138: #line 3152 "third_party/libpg_query/grammar/statements/select.y" { PGLambdaFunction *lambda = makeNode(PGLambdaFunction); @@ -29480,7 +29645,7 @@ YYLTYPE yylloc; ;} break; - case 1133: + case 1139: #line 3161 "third_party/libpg_query/grammar/statements/select.y" { PGLambdaFunction *lambda = makeNode(PGLambdaFunction); @@ -29498,62 +29663,62 @@ YYLTYPE yylloc; ;} break; - case 1134: + case 1140: #line 3182 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(4) - (5)].list); ;} break; - case 1135: + case 1141: #line 3183 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1136: + case 1142: #line 3187 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(4) - (5)].node); ;} break; - case 1137: + case 1143: #line 3188 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(3) - (4)].node); ;} break; - case 1138: + case 1144: #line 3189 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 1139: + case 1145: #line 3193 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = true; ;} break; - case 1140: + case 1146: #line 3194 "third_party/libpg_query/grammar/statements/select.y" { (yyval.boolean) = false; ;} break; - case 1141: + case 1147: #line 3201 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1142: + case 1148: #line 3202 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1143: + case 1149: #line 3206 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].windef)); ;} break; - case 1144: + case 1150: #line 3208 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].windef)); ;} break; - case 1145: + case 1151: #line 3213 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(3) - (3)].windef); @@ -29562,12 +29727,12 @@ YYLTYPE yylloc; ;} break; - case 1146: + case 1152: #line 3221 "third_party/libpg_query/grammar/statements/select.y" { (yyval.windef) = (yyvsp[(2) - (2)].windef); ;} break; - case 1147: + case 1153: #line 3223 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29583,12 +29748,12 @@ YYLTYPE yylloc; ;} break; - case 1148: + case 1154: #line 3236 "third_party/libpg_query/grammar/statements/select.y" { (yyval.windef) = NULL; ;} break; - case 1149: + case 1155: #line 3241 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29605,27 +29770,27 @@ YYLTYPE yylloc; ;} break; - case 1150: + case 1156: #line 3266 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1151: + case 1157: #line 3267 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = NULL; ;} break; - case 1152: + case 1158: #line 3270 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (3)].list); ;} break; - case 1153: + case 1159: #line 3271 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1154: + case 1160: #line 3280 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(2) - (3)].windef); @@ -29636,7 +29801,7 @@ YYLTYPE yylloc; ;} break; - case 1155: + case 1161: #line 3288 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(2) - (3)].windef); @@ -29647,7 +29812,7 @@ YYLTYPE yylloc; ;} break; - case 1156: + case 1162: #line 3296 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(2) - (3)].windef); @@ -29658,7 +29823,7 @@ YYLTYPE yylloc; ;} break; - case 1157: + case 1163: #line 3304 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29670,7 +29835,7 @@ YYLTYPE yylloc; ;} break; - case 1158: + case 1164: #line 3315 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = (yyvsp[(1) - (1)].windef); @@ -29691,7 +29856,7 @@ YYLTYPE yylloc; ;} break; - case 1159: + case 1165: #line 3333 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n1 = (yyvsp[(2) - (4)].windef); @@ -29732,7 +29897,7 @@ YYLTYPE yylloc; ;} break; - case 1160: + case 1166: #line 3379 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29744,7 +29909,7 @@ YYLTYPE yylloc; ;} break; - case 1161: + case 1167: #line 3388 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29756,7 +29921,7 @@ YYLTYPE yylloc; ;} break; - case 1162: + case 1168: #line 3397 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29768,7 +29933,7 @@ YYLTYPE yylloc; ;} break; - case 1163: + case 1169: #line 3406 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29780,7 +29945,7 @@ YYLTYPE yylloc; ;} break; - case 1164: + case 1170: #line 3415 "third_party/libpg_query/grammar/statements/select.y" { PGWindowDef *n = makeNode(PGWindowDef); @@ -29792,52 +29957,52 @@ YYLTYPE yylloc; ;} break; - case 1165: + case 1171: #line 3426 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = FRAMEOPTION_EXCLUDE_CURRENT_ROW; ;} break; - case 1166: + case 1172: #line 3427 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = FRAMEOPTION_EXCLUDE_GROUP; ;} break; - case 1167: + case 1173: #line 3428 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = FRAMEOPTION_EXCLUDE_TIES; ;} break; - case 1168: + case 1174: #line 3429 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; - case 1169: + case 1175: #line 3430 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = 0; ;} break; - case 1170: + case 1176: #line 3444 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1171: + case 1177: #line 3445 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1172: + case 1178: #line 3448 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list);;} break; - case 1173: + case 1179: #line 3449 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(2) - (5)].list), (yyvsp[(4) - (5)].node)); ;} break; - case 1174: + case 1180: #line 3453 "third_party/libpg_query/grammar/statements/select.y" { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); @@ -29849,320 +30014,320 @@ YYLTYPE yylloc; ;} break; - case 1175: + case 1181: #line 3463 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1176: + case 1182: #line 3464 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1177: + case 1183: #line 3468 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1178: + case 1184: #line 3469 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1179: + case 1185: #line 3474 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; - case 1180: + case 1186: #line 3480 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1181: + case 1187: #line 3481 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1182: + case 1188: #line 3486 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1183: + case 1189: #line 3487 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1184: + case 1190: #line 3492 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1185: + case 1191: #line 3493 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 1186: + case 1192: #line 3496 "third_party/libpg_query/grammar/statements/select.y" { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; - case 1187: + case 1193: #line 3497 "third_party/libpg_query/grammar/statements/select.y" { (yyval.subquerytype) = PG_ANY_SUBLINK; ;} break; - case 1188: + case 1194: #line 3498 "third_party/libpg_query/grammar/statements/select.y" { (yyval.subquerytype) = PG_ALL_SUBLINK; ;} break; - case 1189: + case 1195: #line 3501 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1190: + case 1196: #line 3502 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) (yyvsp[(1) - (1)].conststr); ;} break; - case 1191: + case 1197: #line 3505 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "+"; ;} break; - case 1192: + case 1198: #line 3506 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "-"; ;} break; - case 1193: + case 1199: #line 3507 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "*"; ;} break; - case 1194: + case 1200: #line 3508 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "/"; ;} break; - case 1195: + case 1201: #line 3509 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "//"; ;} break; - case 1196: + case 1202: #line 3510 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "%"; ;} break; - case 1197: + case 1203: #line 3511 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "^"; ;} break; - case 1198: + case 1204: #line 3512 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "**"; ;} break; - case 1199: + case 1205: #line 3513 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "<"; ;} break; - case 1200: + case 1206: #line 3514 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = ">"; ;} break; - case 1201: + case 1207: #line 3515 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "="; ;} break; - case 1202: + case 1208: #line 3516 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "<="; ;} break; - case 1203: + case 1209: #line 3517 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = ">="; ;} break; - case 1204: + case 1210: #line 3518 "third_party/libpg_query/grammar/statements/select.y" { (yyval.conststr) = "<>"; ;} break; - case 1205: + case 1211: #line 3522 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1206: + case 1212: #line 3524 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1207: + case 1213: #line 3529 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1208: + case 1214: #line 3531 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1209: + case 1215: #line 3536 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1210: + case 1216: #line 3538 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1211: + case 1217: #line 3540 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("~~")); ;} break; - case 1212: + case 1218: #line 3542 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("!~~")); ;} break; - case 1213: + case 1219: #line 3544 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("~~~")); ;} break; - case 1214: + case 1220: #line 3546 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("!~~~")); ;} break; - case 1215: + case 1221: #line 3548 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("~~*")); ;} break; - case 1216: + case 1222: #line 3550 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString("!~~*")); ;} break; - case 1217: + case 1223: #line 3564 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1218: + case 1224: #line 3566 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lcons(makeString((yyvsp[(1) - (3)].str)), (yyvsp[(3) - (3)].list)); ;} break; - case 1219: + case 1225: #line 3571 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1220: + case 1226: #line 3575 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1221: + case 1227: #line 3582 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1222: + case 1228: #line 3587 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1223: + case 1229: #line 3593 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1224: + case 1230: #line 3597 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1225: + case 1231: #line 3604 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1226: + case 1232: #line 3609 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1227: + case 1233: #line 3616 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1228: + case 1234: #line 3620 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 1229: + case 1235: #line 3629 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1230: + case 1236: #line 3633 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1231: + case 1237: #line 3639 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1232: + case 1238: #line 3643 "third_party/libpg_query/grammar/statements/select.y" { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); @@ -30174,7 +30339,7 @@ YYLTYPE yylloc; ;} break; - case 1233: + case 1239: #line 3652 "third_party/libpg_query/grammar/statements/select.y" { PGNamedArgExpr *na = makeNode(PGNamedArgExpr); @@ -30186,140 +30351,140 @@ YYLTYPE yylloc; ;} break; - case 1234: + case 1240: #line 3662 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].typnam)); ;} break; - case 1235: + case 1241: #line 3663 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].typnam)); ;} break; - case 1236: + case 1242: #line 3668 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2(makeStringConst((yyvsp[(1) - (3)].str), (yylsp[(1) - (3)])), (yyvsp[(3) - (3)].node)); ;} break; - case 1237: + case 1243: #line 3671 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1238: + case 1244: #line 3678 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1239: + case 1245: #line 3679 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "year"; ;} break; - case 1240: + case 1246: #line 3680 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "month"; ;} break; - case 1241: + case 1247: #line 3681 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "day"; ;} break; - case 1242: + case 1248: #line 3682 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "hour"; ;} break; - case 1243: + case 1249: #line 3683 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "minute"; ;} break; - case 1244: + case 1250: #line 3684 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "second"; ;} break; - case 1245: + case 1251: #line 3685 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "millisecond"; ;} break; - case 1246: + case 1252: #line 3686 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "microsecond"; ;} break; - case 1247: + case 1253: #line 3687 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "week"; ;} break; - case 1248: + case 1254: #line 3688 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "quarter"; ;} break; - case 1249: + case 1255: #line 3689 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "decade"; ;} break; - case 1250: + case 1256: #line 3690 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "century"; ;} break; - case 1251: + case 1257: #line 3691 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (char*) "millennium"; ;} break; - case 1252: + case 1258: #line 3692 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1253: + case 1259: #line 3703 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make4((yyvsp[(1) - (4)].node), (yyvsp[(2) - (4)].node), (yyvsp[(3) - (4)].node), (yyvsp[(4) - (4)].node)); ;} break; - case 1254: + case 1260: #line 3707 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; - case 1255: + case 1261: #line 3714 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1256: + case 1262: #line 3720 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; - case 1257: + case 1263: #line 3721 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1258: + case 1264: #line 3738 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make3((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].node)); ;} break; - case 1259: + case 1265: #line 3742 "third_party/libpg_query/grammar/statements/select.y" { /* not legal per SQL99, but might as well allow it */ @@ -30327,14 +30492,14 @@ YYLTYPE yylloc; ;} break; - case 1260: + case 1266: #line 3747 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node)); ;} break; - case 1261: + case 1267: #line 3751 "third_party/libpg_query/grammar/statements/select.y" { /* @@ -30352,44 +30517,44 @@ YYLTYPE yylloc; ;} break; - case 1262: + case 1268: #line 3766 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1263: + case 1269: #line 3770 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1264: + case 1270: #line 3774 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1265: + case 1271: #line 3777 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1266: + case 1272: #line 3780 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(3) - (3)].list), (yyvsp[(1) - (3)].node)); ;} break; - case 1267: + case 1273: #line 3781 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1268: + case 1274: #line 3782 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1269: + case 1275: #line 3786 "third_party/libpg_query/grammar/statements/select.y" { PGSubLink *n = makeNode(PGSubLink); @@ -30399,17 +30564,17 @@ YYLTYPE yylloc; ;} break; - case 1270: + case 1276: #line 3792 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *)(yyvsp[(2) - (3)].list); ;} break; - case 1272: + case 1278: #line 3794 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (PGNode *)(yyvsp[(1) - (1)].node); ;} break; - case 1273: + case 1279: #line 3805 "third_party/libpg_query/grammar/statements/select.y" { PGCaseExpr *c = makeNode(PGCaseExpr); @@ -30422,17 +30587,17 @@ YYLTYPE yylloc; ;} break; - case 1274: + case 1280: #line 3818 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1275: + case 1281: #line 3819 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1276: + case 1282: #line 3824 "third_party/libpg_query/grammar/statements/select.y" { PGCaseWhen *w = makeNode(PGCaseWhen); @@ -30443,48 +30608,48 @@ YYLTYPE yylloc; ;} break; - case 1277: + case 1283: #line 3834 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1278: + case 1284: #line 3835 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 1279: + case 1285: #line 3838 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1280: + case 1286: #line 3839 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 1281: + case 1287: #line 3848 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); ;} break; - case 1282: + case 1288: #line 3854 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeColumnRef((yyvsp[(1) - (1)].str), NIL, (yylsp[(1) - (1)]), yyscanner); ;} break; - case 1283: + case 1289: #line 3858 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeColumnRef((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].list), (yylsp[(1) - (2)]), yyscanner); ;} break; - case 1284: + case 1290: #line 3865 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30495,7 +30660,7 @@ YYLTYPE yylloc; ;} break; - case 1285: + case 1291: #line 3873 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30506,7 +30671,7 @@ YYLTYPE yylloc; ;} break; - case 1286: + case 1292: #line 3880 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30518,7 +30683,7 @@ YYLTYPE yylloc; ;} break; - case 1287: + case 1293: #line 3888 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30529,42 +30694,42 @@ YYLTYPE yylloc; ;} break; - case 1288: + case 1294: #line 3898 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1289: + case 1295: #line 3899 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = NULL; ;} break; - case 1290: + case 1296: #line 3904 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1291: + case 1297: #line 3905 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1292: + case 1298: #line 3909 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 1293: + case 1299: #line 3910 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(NULL); ;} break; - case 1294: + case 1300: #line 3911 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1295: + case 1301: #line 3916 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(3) - (3)].list)) { @@ -30576,7 +30741,7 @@ YYLTYPE yylloc; ;} break; - case 1296: + case 1302: #line 3925 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30587,7 +30752,7 @@ YYLTYPE yylloc; ;} break; - case 1297: + case 1303: #line 3933 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30598,7 +30763,7 @@ YYLTYPE yylloc; ;} break; - case 1298: + case 1304: #line 3940 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30610,7 +30775,7 @@ YYLTYPE yylloc; ;} break; - case 1299: + case 1305: #line 3949 "third_party/libpg_query/grammar/statements/select.y" { PGAIndices *ai = makeNode(PGAIndices); @@ -30621,47 +30786,47 @@ YYLTYPE yylloc; ;} break; - case 1300: + case 1306: #line 3964 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1301: + case 1307: #line 3965 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (2)].list), (yyvsp[(2) - (2)].node)); ;} break; - case 1304: + case 1310: #line 3981 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1305: + case 1311: #line 3982 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1306: + case 1312: #line 3986 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].target)); ;} break; - case 1307: + case 1313: #line 3987 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].target)); ;} break; - case 1308: + case 1314: #line 3991 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1309: + case 1315: #line 3992 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1310: + case 1316: #line 3996 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); @@ -30672,7 +30837,7 @@ YYLTYPE yylloc; ;} break; - case 1311: + case 1317: #line 4012 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); @@ -30683,7 +30848,7 @@ YYLTYPE yylloc; ;} break; - case 1312: + case 1318: #line 4020 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); @@ -30694,7 +30859,7 @@ YYLTYPE yylloc; ;} break; - case 1313: + case 1319: #line 4028 "third_party/libpg_query/grammar/statements/select.y" { (yyval.target) = makeNode(PGResTarget); @@ -30705,191 +30870,191 @@ YYLTYPE yylloc; ;} break; - case 1314: + case 1320: #line 4037 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1315: + case 1321: #line 4038 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; - case 1316: + case 1322: #line 4043 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].str)); ;} break; - case 1317: + case 1323: #line 4047 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].str)); ;} break; - case 1318: + case 1324: #line 4053 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1319: + case 1325: #line 4055 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1320: + case 1326: #line 4059 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1321: + case 1327: #line 4060 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1322: + case 1328: #line 4064 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1323: + case 1329: #line 4065 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 1324: + case 1330: #line 4068 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].node), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1325: + case 1331: #line 4072 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1326: + case 1332: #line 4073 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1327: + case 1333: #line 4077 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1328: + case 1334: #line 4078 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1329: + case 1335: #line 4081 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1330: + case 1336: #line 4082 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; - case 1331: + case 1337: #line 4083 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 1332: + case 1338: #line 4086 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make2((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].str)); ;} break; - case 1333: + case 1339: #line 4090 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].list)); ;} break; - case 1334: + case 1340: #line 4091 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].list)); ;} break; - case 1335: + case 1341: #line 4095 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1336: + case 1342: #line 4096 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1337: + case 1343: #line 4098 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(3) - (4)].list); ;} break; - case 1338: + case 1344: #line 4099 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(2) - (2)].list)); ;} break; - case 1339: + case 1345: #line 4100 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NULL; ;} break; - case 1340: + case 1346: #line 4110 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].range)); ;} break; - case 1341: + case 1347: #line 4111 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].range)); ;} break; - case 1342: + case 1348: #line 4116 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1343: + case 1349: #line 4118 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1344: + case 1350: #line 4123 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1345: + case 1351: #line 4124 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (2)].list); ;} break; - case 1346: + case 1352: #line 4128 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(1) - (1)].list); ;} break; - case 1347: + case 1353: #line 4129 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1348: + case 1354: #line 4132 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1349: + case 1355: #line 4144 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1350: + case 1356: #line 4147 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = check_func_name(lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)), @@ -30897,21 +31062,21 @@ YYLTYPE yylloc; ;} break; - case 1351: + case 1357: #line 4158 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntConst((yyvsp[(1) - (1)].ival), (yylsp[(1) - (1)])); ;} break; - case 1352: + case 1358: #line 4162 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeFloatConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1353: + case 1359: #line 4166 "third_party/libpg_query/grammar/statements/select.y" { if ((yyvsp[(2) - (2)].list)) @@ -30926,14 +31091,14 @@ YYLTYPE yylloc; ;} break; - case 1354: + case 1360: #line 4178 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeBitStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1355: + case 1361: #line 4182 "third_party/libpg_query/grammar/statements/select.y" { /* This is a bit constant per SQL99: @@ -30945,7 +31110,7 @@ YYLTYPE yylloc; ;} break; - case 1356: + case 1362: #line 4191 "third_party/libpg_query/grammar/statements/select.y" { /* generic type 'literal' syntax */ @@ -30955,7 +31120,7 @@ YYLTYPE yylloc; ;} break; - case 1357: + case 1363: #line 4198 "third_party/libpg_query/grammar/statements/select.y" { /* generic syntax with a type modifier */ @@ -30996,146 +31161,146 @@ YYLTYPE yylloc; ;} break; - case 1358: + case 1364: #line 4236 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeStringConstCast((yyvsp[(2) - (2)].str), (yylsp[(2) - (2)]), (yyvsp[(1) - (2)].typnam)); ;} break; - case 1359: + case 1365: #line 4240 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntervalNode((yyvsp[(3) - (5)].node), (yylsp[(3) - (5)]), (yyvsp[(5) - (5)].list)); ;} break; - case 1360: + case 1366: #line 4244 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].ival), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); ;} break; - case 1361: + case 1367: #line 4248 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeIntervalNode((yyvsp[(2) - (3)].str), (yylsp[(2) - (3)]), (yyvsp[(3) - (3)].list)); ;} break; - case 1362: + case 1368: #line 4252 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeBoolAConst(true, (yylsp[(1) - (1)])); ;} break; - case 1363: + case 1369: #line 4256 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeBoolAConst(false, (yylsp[(1) - (1)])); ;} break; - case 1364: + case 1370: #line 4260 "third_party/libpg_query/grammar/statements/select.y" { (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); ;} break; - case 1365: + case 1371: #line 4265 "third_party/libpg_query/grammar/statements/select.y" { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 1366: + case 1372: #line 4282 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1367: + case 1373: #line 4283 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1368: + case 1374: #line 4284 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1369: + case 1375: #line 4287 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1370: + case 1376: #line 4288 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1371: + case 1377: #line 4289 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1372: + case 1378: #line 4292 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1373: + case 1379: #line 4293 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1374: + case 1380: #line 4294 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1375: + case 1381: #line 4297 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(1) - (1)].str))); ;} break; - case 1376: + case 1382: #line 4298 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lcons(makeString((yyvsp[(1) - (2)].str)), (yyvsp[(2) - (2)].list)); ;} break; - case 1377: + case 1383: #line 4302 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = list_make1(makeString((yyvsp[(2) - (2)].str))); ;} break; - case 1378: + case 1384: #line 4304 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), makeString((yyvsp[(3) - (3)].str))); ;} break; - case 1379: + case 1385: #line 4308 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1380: + case 1386: #line 4309 "third_party/libpg_query/grammar/statements/select.y" { (yyval.list) = NIL; ;} break; - case 1382: + case 1388: #line 4316 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1383: + case 1389: #line 4317 "third_party/libpg_query/grammar/statements/select.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1384: + case 1390: #line 8 "third_party/libpg_query/grammar/statements/prepare.y" { PGPrepareStmt *n = makeNode(PGPrepareStmt); @@ -31146,17 +31311,17 @@ YYLTYPE yylloc; ;} break; - case 1385: + case 1391: #line 18 "third_party/libpg_query/grammar/statements/prepare.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1386: + case 1392: #line 19 "third_party/libpg_query/grammar/statements/prepare.y" { (yyval.list) = NIL; ;} break; - case 1393: + case 1399: #line 8 "third_party/libpg_query/grammar/statements/create_schema.y" { PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt); @@ -31178,7 +31343,7 @@ YYLTYPE yylloc; ;} break; - case 1394: + case 1400: #line 27 "third_party/libpg_query/grammar/statements/create_schema.y" { PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt); @@ -31205,7 +31370,7 @@ YYLTYPE yylloc; ;} break; - case 1395: + case 1401: #line 51 "third_party/libpg_query/grammar/statements/create_schema.y" { PGCreateSchemaStmt *n = makeNode(PGCreateSchemaStmt); @@ -31227,7 +31392,7 @@ YYLTYPE yylloc; ;} break; - case 1396: + case 1402: #line 74 "third_party/libpg_query/grammar/statements/create_schema.y" { if ((yyloc) < 0) /* see comments for YYLLOC_DEFAULT */ @@ -31236,12 +31401,12 @@ YYLTYPE yylloc; ;} break; - case 1397: + case 1403: #line 80 "third_party/libpg_query/grammar/statements/create_schema.y" { (yyval.list) = NIL; ;} break; - case 1402: + case 1408: #line 11 "third_party/libpg_query/grammar/statements/index.y" { PGIndexStmt *n = makeNode(PGIndexStmt); @@ -31267,7 +31432,7 @@ YYLTYPE yylloc; ;} break; - case 1403: + case 1409: #line 36 "third_party/libpg_query/grammar/statements/index.y" { PGIndexStmt *n = makeNode(PGIndexStmt); @@ -31293,62 +31458,62 @@ YYLTYPE yylloc; ;} break; - case 1404: + case 1410: #line 62 "third_party/libpg_query/grammar/statements/index.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1405: + case 1411: #line 66 "third_party/libpg_query/grammar/statements/index.y" { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1406: + case 1412: #line 67 "third_party/libpg_query/grammar/statements/index.y" { (yyval.str) = (char*) DEFAULT_INDEX_TYPE; ;} break; - case 1407: + case 1413: #line 72 "third_party/libpg_query/grammar/statements/index.y" { (yyval.boolean) = true; ;} break; - case 1408: + case 1414: #line 73 "third_party/libpg_query/grammar/statements/index.y" { (yyval.boolean) = false; ;} break; - case 1409: + case 1415: #line 78 "third_party/libpg_query/grammar/statements/index.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1410: + case 1416: #line 79 "third_party/libpg_query/grammar/statements/index.y" { (yyval.str) = NULL; ;} break; - case 1411: + case 1417: #line 83 "third_party/libpg_query/grammar/statements/index.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1412: + case 1418: #line 84 "third_party/libpg_query/grammar/statements/index.y" { (yyval.list) = NIL; ;} break; - case 1413: + case 1419: #line 89 "third_party/libpg_query/grammar/statements/index.y" { (yyval.boolean) = true; ;} break; - case 1414: + case 1420: #line 90 "third_party/libpg_query/grammar/statements/index.y" { (yyval.boolean) = false; ;} break; - case 1415: + case 1421: #line 8 "third_party/libpg_query/grammar/statements/alter_schema.y" { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); @@ -31360,7 +31525,7 @@ YYLTYPE yylloc; ;} break; - case 1416: + case 1422: #line 17 "third_party/libpg_query/grammar/statements/alter_schema.y" { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); @@ -31372,7 +31537,7 @@ YYLTYPE yylloc; ;} break; - case 1417: + case 1423: #line 26 "third_party/libpg_query/grammar/statements/alter_schema.y" { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); @@ -31384,7 +31549,7 @@ YYLTYPE yylloc; ;} break; - case 1418: + case 1424: #line 35 "third_party/libpg_query/grammar/statements/alter_schema.y" { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); @@ -31396,7 +31561,7 @@ YYLTYPE yylloc; ;} break; - case 1419: + case 1425: #line 44 "third_party/libpg_query/grammar/statements/alter_schema.y" { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); @@ -31408,7 +31573,7 @@ YYLTYPE yylloc; ;} break; - case 1420: + case 1426: #line 53 "third_party/libpg_query/grammar/statements/alter_schema.y" { PGAlterObjectSchemaStmt *n = makeNode(PGAlterObjectSchemaStmt); @@ -31420,7 +31585,7 @@ YYLTYPE yylloc; ;} break; - case 1421: + case 1427: #line 6 "third_party/libpg_query/grammar/statements/checkpoint.y" { PGCheckPointStmt *n = makeNode(PGCheckPointStmt); @@ -31430,7 +31595,7 @@ YYLTYPE yylloc; ;} break; - case 1422: + case 1428: #line 13 "third_party/libpg_query/grammar/statements/checkpoint.y" { PGCheckPointStmt *n = makeNode(PGCheckPointStmt); @@ -31440,17 +31605,17 @@ YYLTYPE yylloc; ;} break; - case 1423: + case 1429: #line 22 "third_party/libpg_query/grammar/statements/checkpoint.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1424: + case 1430: #line 23 "third_party/libpg_query/grammar/statements/checkpoint.y" { (yyval.str) = NULL; ;} break; - case 1425: + case 1431: #line 8 "third_party/libpg_query/grammar/statements/comment_on.y" { PGCommentOnStmt *n = makeNode(PGCommentOnStmt); @@ -31461,7 +31626,7 @@ YYLTYPE yylloc; ;} break; - case 1426: + case 1432: #line 16 "third_party/libpg_query/grammar/statements/comment_on.y" { PGCommentOnStmt *n = makeNode(PGCommentOnStmt); @@ -31472,67 +31637,67 @@ YYLTYPE yylloc; ;} break; - case 1427: + case 1433: #line 26 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1428: + case 1434: #line 27 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.node) = makeNullAConst((yylsp[(1) - (1)])); ;} break; - case 1429: + case 1435: #line 30 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_TABLE; ;} break; - case 1430: + case 1436: #line 31 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_SEQUENCE; ;} break; - case 1431: + case 1437: #line 32 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 1432: + case 1438: #line 33 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_FUNCTION; ;} break; - case 1433: + case 1439: #line 34 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_TABLE_MACRO; ;} break; - case 1434: + case 1440: #line 35 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_VIEW; ;} break; - case 1435: + case 1441: #line 36 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_DATABASE; ;} break; - case 1436: + case 1442: #line 37 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_INDEX; ;} break; - case 1437: + case 1443: #line 38 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_SCHEMA; ;} break; - case 1438: + case 1444: #line 39 "third_party/libpg_query/grammar/statements/comment_on.y" { (yyval.objtype) = PG_OBJECT_TYPE; ;} break; - case 1439: + case 1445: #line 8 "third_party/libpg_query/grammar/statements/export.y" { PGExportStmt *n = makeNode(PGExportStmt); @@ -31546,7 +31711,7 @@ YYLTYPE yylloc; ;} break; - case 1440: + case 1446: #line 20 "third_party/libpg_query/grammar/statements/export.y" { PGExportStmt *n = makeNode(PGExportStmt); @@ -31560,7 +31725,7 @@ YYLTYPE yylloc; ;} break; - case 1441: + case 1447: #line 34 "third_party/libpg_query/grammar/statements/export.y" { PGImportStmt *n = makeNode(PGImportStmt); @@ -31569,7 +31734,7 @@ YYLTYPE yylloc; ;} break; - case 1442: + case 1448: #line 10 "third_party/libpg_query/grammar/statements/explain.y" { PGExplainStmt *n = makeNode(PGExplainStmt); @@ -31579,7 +31744,7 @@ YYLTYPE yylloc; ;} break; - case 1443: + case 1449: #line 17 "third_party/libpg_query/grammar/statements/explain.y" { PGExplainStmt *n = makeNode(PGExplainStmt); @@ -31592,7 +31757,7 @@ YYLTYPE yylloc; ;} break; - case 1444: + case 1450: #line 27 "third_party/libpg_query/grammar/statements/explain.y" { PGExplainStmt *n = makeNode(PGExplainStmt); @@ -31602,7 +31767,7 @@ YYLTYPE yylloc; ;} break; - case 1445: + case 1451: #line 34 "third_party/libpg_query/grammar/statements/explain.y" { PGExplainStmt *n = makeNode(PGExplainStmt); @@ -31612,118 +31777,118 @@ YYLTYPE yylloc; ;} break; - case 1446: + case 1452: #line 44 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.boolean) = true; ;} break; - case 1447: + case 1453: #line 45 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.boolean) = false; ;} break; - case 1448: + case 1454: #line 50 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.node) = (PGNode *) makeString((yyvsp[(1) - (1)].str)); ;} break; - case 1449: + case 1455: #line 51 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].value); ;} break; - case 1450: + case 1456: #line 52 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.node) = NULL; ;} break; - case 1483: + case 1489: #line 92 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1484: + case 1490: #line 93 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1485: + case 1491: #line 94 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = pstrdup((yyvsp[(1) - (1)].keyword)); ;} break; - case 1486: + case 1492: #line 99 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1487: + case 1493: #line 100 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1488: + case 1494: #line 106 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 1489: + case 1495: #line 110 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 1490: + case 1496: #line 117 "third_party/libpg_query/grammar/statements/explain.y" {;} break; - case 1491: + case 1497: #line 118 "third_party/libpg_query/grammar/statements/explain.y" {;} break; - case 1492: + case 1498: #line 123 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (char*) "true"; ;} break; - case 1493: + case 1499: #line 124 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (char*) "false"; ;} break; - case 1494: + case 1500: #line 125 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (char*) "on"; ;} break; - case 1495: + case 1501: #line 131 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1496: + case 1502: #line 137 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1497: + case 1503: #line 144 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1498: + case 1504: #line 145 "third_party/libpg_query/grammar/statements/explain.y" { (yyval.str) = (char*) "analyze"; ;} break; - case 1499: + case 1505: #line 11 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = (yyvsp[(2) - (2)].vsetstmt); @@ -31732,7 +31897,7 @@ YYLTYPE yylloc; ;} break; - case 1500: + case 1506: #line 17 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); @@ -31741,7 +31906,7 @@ YYLTYPE yylloc; ;} break; - case 1501: + case 1507: #line 23 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); @@ -31750,7 +31915,7 @@ YYLTYPE yylloc; ;} break; - case 1502: + case 1508: #line 29 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); @@ -31759,7 +31924,7 @@ YYLTYPE yylloc; ;} break; - case 1503: + case 1509: #line 35 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = (yyvsp[(3) - (3)].vsetstmt); @@ -31768,12 +31933,12 @@ YYLTYPE yylloc; ;} break; - case 1504: + case 1510: #line 44 "third_party/libpg_query/grammar/statements/variable_set.y" {(yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt);;} break; - case 1505: + case 1511: #line 46 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -31783,7 +31948,7 @@ YYLTYPE yylloc; ;} break; - case 1506: + case 1512: #line 54 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -31797,7 +31962,7 @@ YYLTYPE yylloc; ;} break; - case 1507: + case 1513: #line 65 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -31808,7 +31973,7 @@ YYLTYPE yylloc; ;} break; - case 1508: + case 1514: #line 77 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -31819,7 +31984,7 @@ YYLTYPE yylloc; ;} break; - case 1509: + case 1515: #line 85 "third_party/libpg_query/grammar/statements/variable_set.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -31830,26 +31995,26 @@ YYLTYPE yylloc; ;} break; - case 1510: + case 1516: #line 96 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.node) = (yyvsp[(1) - (1)].node); ;} break; - case 1511: + case 1517: #line 102 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1512: + case 1518: #line 106 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.node) = makeStringConst((yyvsp[(1) - (1)].str), (yylsp[(1) - (1)])); ;} break; - case 1513: + case 1519: #line 110 "third_party/libpg_query/grammar/statements/variable_set.y" { PGTypeName *t = (yyvsp[(1) - (3)].typnam); @@ -31867,7 +32032,7 @@ YYLTYPE yylloc; ;} break; - case 1514: + case 1520: #line 125 "third_party/libpg_query/grammar/statements/variable_set.y" { PGTypeName *t = (yyvsp[(1) - (5)].typnam); @@ -31877,32 +32042,32 @@ YYLTYPE yylloc; ;} break; - case 1515: + case 1521: #line 131 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.node) = makeAConst((yyvsp[(1) - (1)].value), (yylsp[(1) - (1)])); ;} break; - case 1516: + case 1522: #line 132 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.node) = NULL; ;} break; - case 1517: + case 1523: #line 133 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.node) = NULL; ;} break; - case 1518: + case 1524: #line 137 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].node)); ;} break; - case 1519: + case 1525: #line 138 "third_party/libpg_query/grammar/statements/variable_set.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].node)); ;} break; - case 1520: + case 1526: #line 8 "third_party/libpg_query/grammar/statements/load.y" { PGLoadStmt *n = makeNode(PGLoadStmt); @@ -31915,7 +32080,7 @@ YYLTYPE yylloc; ;} break; - case 1521: + case 1527: #line 17 "third_party/libpg_query/grammar/statements/load.y" { PGLoadStmt *n = makeNode(PGLoadStmt); @@ -31928,7 +32093,7 @@ YYLTYPE yylloc; ;} break; - case 1522: + case 1528: #line 26 "third_party/libpg_query/grammar/statements/load.y" { PGLoadStmt *n = makeNode(PGLoadStmt); @@ -31941,7 +32106,7 @@ YYLTYPE yylloc; ;} break; - case 1523: + case 1529: #line 35 "third_party/libpg_query/grammar/statements/load.y" { PGLoadStmt *n = makeNode(PGLoadStmt); @@ -31954,42 +32119,42 @@ YYLTYPE yylloc; ;} break; - case 1524: + case 1530: #line 46 "third_party/libpg_query/grammar/statements/load.y" { (yyval.loadinstalltype) = PG_LOAD_TYPE_INSTALL; ;} break; - case 1525: + case 1531: #line 47 "third_party/libpg_query/grammar/statements/load.y" { (yyval.loadinstalltype) = PG_LOAD_TYPE_FORCE_INSTALL; ;} break; - case 1526: + case 1532: #line 49 "third_party/libpg_query/grammar/statements/load.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1527: + case 1533: #line 50 "third_party/libpg_query/grammar/statements/load.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1528: + case 1534: #line 53 "third_party/libpg_query/grammar/statements/load.y" { (yyval.str) = NULL; ;} break; - case 1529: + case 1535: #line 54 "third_party/libpg_query/grammar/statements/load.y" { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1530: + case 1536: #line 55 "third_party/libpg_query/grammar/statements/load.y" { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1531: + case 1537: #line 9 "third_party/libpg_query/grammar/statements/vacuum.y" { PGVacuumStmt *n = makeNode(PGVacuumStmt); @@ -32006,7 +32171,7 @@ YYLTYPE yylloc; ;} break; - case 1532: + case 1538: #line 23 "third_party/libpg_query/grammar/statements/vacuum.y" { PGVacuumStmt *n = makeNode(PGVacuumStmt); @@ -32023,7 +32188,7 @@ YYLTYPE yylloc; ;} break; - case 1533: + case 1539: #line 37 "third_party/libpg_query/grammar/statements/vacuum.y" { PGVacuumStmt *n = (PGVacuumStmt *) (yyvsp[(5) - (5)].node); @@ -32038,7 +32203,7 @@ YYLTYPE yylloc; ;} break; - case 1534: + case 1540: #line 49 "third_party/libpg_query/grammar/statements/vacuum.y" { PGVacuumStmt *n = makeNode(PGVacuumStmt); @@ -32049,7 +32214,7 @@ YYLTYPE yylloc; ;} break; - case 1535: + case 1541: #line 57 "third_party/libpg_query/grammar/statements/vacuum.y" { PGVacuumStmt *n = makeNode(PGVacuumStmt); @@ -32062,27 +32227,27 @@ YYLTYPE yylloc; ;} break; - case 1536: + case 1542: #line 70 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.ival) = PG_VACOPT_ANALYZE; ;} break; - case 1537: + case 1543: #line 71 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.ival) = PG_VACOPT_VERBOSE; ;} break; - case 1538: + case 1544: #line 72 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.ival) = PG_VACOPT_FREEZE; ;} break; - case 1539: + case 1545: #line 73 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.ival) = PG_VACOPT_FULL; ;} break; - case 1540: + case 1546: #line 75 "third_party/libpg_query/grammar/statements/vacuum.y" { if (strcmp((yyvsp[(1) - (1)].str), "disable_page_skipping") == 0) @@ -32095,37 +32260,37 @@ YYLTYPE yylloc; ;} break; - case 1541: + case 1547: #line 87 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.boolean) = true; ;} break; - case 1542: + case 1548: #line 88 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.boolean) = false; ;} break; - case 1543: + case 1549: #line 93 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.ival) = (yyvsp[(1) - (1)].ival); ;} break; - case 1544: + case 1550: #line 94 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.ival) = (yyvsp[(1) - (3)].ival) | (yyvsp[(3) - (3)].ival); ;} break; - case 1545: + case 1551: #line 98 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.boolean) = true; ;} break; - case 1546: + case 1552: #line 99 "third_party/libpg_query/grammar/statements/vacuum.y" { (yyval.boolean) = false; ;} break; - case 1547: + case 1553: #line 9 "third_party/libpg_query/grammar/statements/delete.y" { PGDeleteStmt *n = makeNode(PGDeleteStmt); @@ -32138,7 +32303,7 @@ YYLTYPE yylloc; ;} break; - case 1548: + case 1554: #line 19 "third_party/libpg_query/grammar/statements/delete.y" { PGDeleteStmt *n = makeNode(PGDeleteStmt); @@ -32151,14 +32316,14 @@ YYLTYPE yylloc; ;} break; - case 1549: + case 1555: #line 32 "third_party/libpg_query/grammar/statements/delete.y" { (yyval.range) = (yyvsp[(1) - (1)].range); ;} break; - case 1550: + case 1556: #line 36 "third_party/libpg_query/grammar/statements/delete.y" { PGAlias *alias = makeNode(PGAlias); @@ -32168,7 +32333,7 @@ YYLTYPE yylloc; ;} break; - case 1551: + case 1557: #line 43 "third_party/libpg_query/grammar/statements/delete.y" { PGAlias *alias = makeNode(PGAlias); @@ -32178,27 +32343,27 @@ YYLTYPE yylloc; ;} break; - case 1552: + case 1558: #line 53 "third_party/libpg_query/grammar/statements/delete.y" { (yyval.node) = (yyvsp[(2) - (2)].node); ;} break; - case 1553: + case 1559: #line 54 "third_party/libpg_query/grammar/statements/delete.y" { (yyval.node) = NULL; ;} break; - case 1554: + case 1560: #line 60 "third_party/libpg_query/grammar/statements/delete.y" { (yyval.list) = (yyvsp[(2) - (2)].list); ;} break; - case 1555: + case 1561: #line 61 "third_party/libpg_query/grammar/statements/delete.y" { (yyval.list) = NIL; ;} break; - case 1556: + case 1562: #line 10 "third_party/libpg_query/grammar/statements/analyze.y" { PGVacuumStmt *n = makeNode(PGVacuumStmt); @@ -32211,7 +32376,7 @@ YYLTYPE yylloc; ;} break; - case 1557: + case 1563: #line 20 "third_party/libpg_query/grammar/statements/analyze.y" { PGVacuumStmt *n = makeNode(PGVacuumStmt); @@ -32224,7 +32389,7 @@ YYLTYPE yylloc; ;} break; - case 1558: + case 1564: #line 8 "third_party/libpg_query/grammar/statements/attach.y" { PGAttachStmt *n = makeNode(PGAttachStmt); @@ -32236,7 +32401,7 @@ YYLTYPE yylloc; ;} break; - case 1559: + case 1565: #line 17 "third_party/libpg_query/grammar/statements/attach.y" { PGAttachStmt *n = makeNode(PGAttachStmt); @@ -32248,7 +32413,7 @@ YYLTYPE yylloc; ;} break; - case 1560: + case 1566: #line 26 "third_party/libpg_query/grammar/statements/attach.y" { PGAttachStmt *n = makeNode(PGAttachStmt); @@ -32260,7 +32425,7 @@ YYLTYPE yylloc; ;} break; - case 1561: + case 1567: #line 38 "third_party/libpg_query/grammar/statements/attach.y" { PGDetachStmt *n = makeNode(PGDetachStmt); @@ -32270,7 +32435,7 @@ YYLTYPE yylloc; ;} break; - case 1562: + case 1568: #line 45 "third_party/libpg_query/grammar/statements/attach.y" { PGDetachStmt *n = makeNode(PGDetachStmt); @@ -32280,7 +32445,7 @@ YYLTYPE yylloc; ;} break; - case 1563: + case 1569: #line 52 "third_party/libpg_query/grammar/statements/attach.y" { PGDetachStmt *n = makeNode(PGDetachStmt); @@ -32290,72 +32455,72 @@ YYLTYPE yylloc; ;} break; - case 1564: + case 1570: #line 60 "third_party/libpg_query/grammar/statements/attach.y" {;} break; - case 1565: + case 1571: #line 61 "third_party/libpg_query/grammar/statements/attach.y" {;} break; - case 1566: + case 1572: #line 65 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.str) = (yyvsp[(2) - (2)].str); ;} break; - case 1567: + case 1573: #line 66 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.str) = NULL; ;} break; - case 1568: + case 1574: #line 77 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.node) = (PGNode *) (yyvsp[(1) - (1)].node); ;} break; - case 1569: + case 1575: #line 78 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.node) = NULL; ;} break; - case 1570: + case 1576: #line 83 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.defelt) = makeDefElem((yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].node), (yylsp[(1) - (2)])); ;} break; - case 1571: + case 1577: #line 90 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.list) = list_make1((yyvsp[(1) - (1)].defelt)); ;} break; - case 1572: + case 1578: #line 94 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.list) = lappend((yyvsp[(1) - (3)].list), (yyvsp[(3) - (3)].defelt)); ;} break; - case 1573: + case 1579: #line 101 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.list) = (yyvsp[(2) - (3)].list); ;} break; - case 1574: + case 1580: #line 105 "third_party/libpg_query/grammar/statements/attach.y" { (yyval.list) = NULL; ;} break; - case 1575: + case 1581: #line 3 "third_party/libpg_query/grammar/statements/variable_reset.y" { (yyvsp[(2) - (2)].vsetstmt)->scope = VAR_SET_SCOPE_DEFAULT; @@ -32363,7 +32528,7 @@ YYLTYPE yylloc; ;} break; - case 1576: + case 1582: #line 8 "third_party/libpg_query/grammar/statements/variable_reset.y" { (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_LOCAL; @@ -32371,7 +32536,7 @@ YYLTYPE yylloc; ;} break; - case 1577: + case 1583: #line 13 "third_party/libpg_query/grammar/statements/variable_reset.y" { (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_SESSION; @@ -32379,7 +32544,7 @@ YYLTYPE yylloc; ;} break; - case 1578: + case 1584: #line 18 "third_party/libpg_query/grammar/statements/variable_reset.y" { (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_GLOBAL; @@ -32387,7 +32552,7 @@ YYLTYPE yylloc; ;} break; - case 1579: + case 1585: #line 23 "third_party/libpg_query/grammar/statements/variable_reset.y" { (yyvsp[(3) - (3)].vsetstmt)->scope = VAR_SET_SCOPE_VARIABLE; @@ -32395,7 +32560,7 @@ YYLTYPE yylloc; ;} break; - case 1580: + case 1586: #line 32 "third_party/libpg_query/grammar/statements/variable_reset.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -32405,7 +32570,7 @@ YYLTYPE yylloc; ;} break; - case 1581: + case 1587: #line 39 "third_party/libpg_query/grammar/statements/variable_reset.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -32414,12 +32579,12 @@ YYLTYPE yylloc; ;} break; - case 1582: + case 1588: #line 48 "third_party/libpg_query/grammar/statements/variable_reset.y" { (yyval.vsetstmt) = (yyvsp[(1) - (1)].vsetstmt); ;} break; - case 1583: + case 1589: #line 50 "third_party/libpg_query/grammar/statements/variable_reset.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -32429,7 +32594,7 @@ YYLTYPE yylloc; ;} break; - case 1584: + case 1590: #line 57 "third_party/libpg_query/grammar/statements/variable_reset.y" { PGVariableSetStmt *n = makeNode(PGVariableSetStmt); @@ -32439,7 +32604,7 @@ YYLTYPE yylloc; ;} break; - case 1585: + case 1591: #line 3 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt); @@ -32450,7 +32615,7 @@ YYLTYPE yylloc; ;} break; - case 1586: + case 1592: #line 10 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowSelectStmt *n = makeNode(PGVariableShowSelectStmt); @@ -32461,7 +32626,7 @@ YYLTYPE yylloc; ;} break; - case 1587: + case 1593: #line 18 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32471,7 +32636,7 @@ YYLTYPE yylloc; ;} break; - case 1588: + case 1594: #line 25 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32482,7 +32647,7 @@ YYLTYPE yylloc; ;} break; - case 1589: + case 1595: #line 33 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32492,7 +32657,7 @@ YYLTYPE yylloc; ;} break; - case 1590: + case 1596: #line 40 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32502,7 +32667,7 @@ YYLTYPE yylloc; ;} break; - case 1591: + case 1597: #line 47 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32512,7 +32677,7 @@ YYLTYPE yylloc; ;} break; - case 1592: + case 1598: #line 54 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32522,7 +32687,7 @@ YYLTYPE yylloc; ;} break; - case 1593: + case 1599: #line 61 "third_party/libpg_query/grammar/statements/variable_show.y" { PGVariableShowStmt *n = makeNode(PGVariableShowStmt); @@ -32532,17 +32697,17 @@ YYLTYPE yylloc; ;} break; - case 1600: + case 1606: #line 75 "third_party/libpg_query/grammar/statements/variable_show.y" { (yyval.str) = (yyvsp[(1) - (1)].str); ;} break; - case 1601: + case 1607: #line 77 "third_party/libpg_query/grammar/statements/variable_show.y" { (yyval.str) = psprintf("%s.%s", (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str)); ;} break; - case 1602: + case 1608: #line 7 "third_party/libpg_query/grammar/statements/call.y" { PGCallStmt *n = makeNode(PGCallStmt); @@ -32551,7 +32716,7 @@ YYLTYPE yylloc; ;} break; - case 1603: + case 1609: #line 10 "third_party/libpg_query/grammar/statements/view.y" { PGViewStmt *n = makeNode(PGViewStmt); @@ -32566,7 +32731,7 @@ YYLTYPE yylloc; ;} break; - case 1604: + case 1610: #line 23 "third_party/libpg_query/grammar/statements/view.y" { PGViewStmt *n = makeNode(PGViewStmt); @@ -32581,7 +32746,7 @@ YYLTYPE yylloc; ;} break; - case 1605: + case 1611: #line 36 "third_party/libpg_query/grammar/statements/view.y" { PGViewStmt *n = makeNode(PGViewStmt); @@ -32596,7 +32761,7 @@ YYLTYPE yylloc; ;} break; - case 1606: + case 1612: #line 49 "third_party/libpg_query/grammar/statements/view.y" { PGViewStmt *n = makeNode(PGViewStmt); @@ -32616,7 +32781,7 @@ YYLTYPE yylloc; ;} break; - case 1607: + case 1613: #line 67 "third_party/libpg_query/grammar/statements/view.y" { PGViewStmt *n = makeNode(PGViewStmt); @@ -32636,27 +32801,27 @@ YYLTYPE yylloc; ;} break; - case 1608: + case 1614: #line 87 "third_party/libpg_query/grammar/statements/view.y" { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;} break; - case 1609: + case 1615: #line 88 "third_party/libpg_query/grammar/statements/view.y" { (yyval.viewcheckoption) = CASCADED_CHECK_OPTION; ;} break; - case 1610: + case 1616: #line 89 "third_party/libpg_query/grammar/statements/view.y" { (yyval.viewcheckoption) = PG_LOCAL_CHECK_OPTION; ;} break; - case 1611: + case 1617: #line 90 "third_party/libpg_query/grammar/statements/view.y" { (yyval.viewcheckoption) = PG_NO_CHECK_OPTION; ;} break; - case 1612: + case 1618: #line 12 "third_party/libpg_query/grammar/statements/create_as.y" { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); @@ -32672,7 +32837,7 @@ YYLTYPE yylloc; ;} break; - case 1613: + case 1619: #line 25 "third_party/libpg_query/grammar/statements/create_as.y" { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); @@ -32688,7 +32853,7 @@ YYLTYPE yylloc; ;} break; - case 1614: + case 1620: #line 38 "third_party/libpg_query/grammar/statements/create_as.y" { PGCreateTableAsStmt *ctas = makeNode(PGCreateTableAsStmt); @@ -32704,22 +32869,22 @@ YYLTYPE yylloc; ;} break; - case 1615: + case 1621: #line 54 "third_party/libpg_query/grammar/statements/create_as.y" { (yyval.boolean) = true; ;} break; - case 1616: + case 1622: #line 55 "third_party/libpg_query/grammar/statements/create_as.y" { (yyval.boolean) = false; ;} break; - case 1617: + case 1623: #line 56 "third_party/libpg_query/grammar/statements/create_as.y" { (yyval.boolean) = true; ;} break; - case 1618: + case 1624: #line 62 "third_party/libpg_query/grammar/statements/create_as.y" { (yyval.into) = makeNode(PGIntoClause); @@ -32734,7 +32899,7 @@ YYLTYPE yylloc; /* Line 1267 of yacc.c. */ -#line 32738 "third_party/libpg_query/grammar/grammar_out.cpp" +#line 32903 "third_party/libpg_query/grammar/grammar_out.cpp" default: break; } YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); diff --git a/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp b/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp index 7ee4f39c2..7aba4df0f 100644 --- a/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp +++ b/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp @@ -343,16 +343,20 @@ bool Utf8Proc::CodepointToUtf8(int cp, int &sz, char *c) { int Utf8Proc::CodepointLength(int cp) { if (cp <= 0x7F) { return 1; - } else if (cp <= 0x7FF) { + } + if (cp <= 0x7FF) { return 2; - } else if (0xd800 <= cp && cp <= 0xdfff) { - return -1; - } else if (cp <= 0xFFFF) { + } + if (0xd800 <= cp && cp <= 0xdfff) { + throw InternalException("invalid code point detected in Utf8Proc::CodepointLength (0xd800 to 0xdfff), likely due to invalid UTF-8"); + } + if (cp <= 0xFFFF) { return 3; - } else if (cp <= 0x10FFFF) { + } + if (cp <= 0x10FFFF) { return 4; } - return -1; + throw InternalException("invalid code point detected in Utf8Proc::CodepointLength, likely due to invalid UTF-8"); } int32_t Utf8Proc::UTF8ToCodepoint(const char *u_input, int &sz) { @@ -369,7 +373,7 @@ int32_t Utf8Proc::UTF8ToCodepoint(const char *u_input, int &sz) { return (u0 - 192) * 64 + (u1 - 128); } if (u[0] == 0xed && (u[1] & 0xa0) == 0xa0) { - return -1; // code points, 0xd800 to 0xdfff + throw InternalException("invalid code point detected in Utf8Proc::UTF8ToCodepoint (0xd800 to 0xdfff), likely due to invalid UTF-8"); } unsigned char u2 = u[2]; if (u0 >= 224 && u0 <= 239) { @@ -381,7 +385,7 @@ int32_t Utf8Proc::UTF8ToCodepoint(const char *u_input, int &sz) { sz = 4; return (u0 - 240) * 262144 + (u1 - 128) * 4096 + (u2 - 128) * 64 + (u3 - 128); } - return -1; + throw InternalException("invalid code point detected in Utf8Proc::UTF8ToCodepoint, likely due to invalid UTF-8"); } size_t Utf8Proc::RenderWidth(const char *s, size_t len, size_t pos) { diff --git a/src/duckdb/ub_extension_core_functions_scalar_generic.cpp b/src/duckdb/ub_extension_core_functions_scalar_generic.cpp index 68eb6db63..07f2ee65f 100644 --- a/src/duckdb/ub_extension_core_functions_scalar_generic.cpp +++ b/src/duckdb/ub_extension_core_functions_scalar_generic.cpp @@ -16,7 +16,7 @@ #include "extension/core_functions/scalar/generic/stats.cpp" -#include "extension/core_functions/scalar/generic/typeof.cpp" +#include "extension/core_functions/scalar/generic/type_functions.cpp" #include "extension/core_functions/scalar/generic/system_functions.cpp" diff --git a/src/duckdb/ub_src_catalog_catalog_entry.cpp b/src/duckdb/ub_src_catalog_catalog_entry.cpp index 2e11f6d71..6028f3295 100644 --- a/src/duckdb/ub_src_catalog_catalog_entry.cpp +++ b/src/duckdb/ub_src_catalog_catalog_entry.cpp @@ -1,3 +1,5 @@ +#include "src/catalog/catalog_entry/aggregate_function_catalog_entry.cpp" + #include "src/catalog/catalog_entry/copy_function_catalog_entry.cpp" #include "src/catalog/catalog_entry/duck_index_entry.cpp" diff --git a/src/duckdb/ub_src_common_types.cpp b/src/duckdb/ub_src_common_types.cpp index 5b4b933e1..57aa028c4 100644 --- a/src/duckdb/ub_src_common_types.cpp +++ b/src/duckdb/ub_src_common_types.cpp @@ -38,6 +38,8 @@ #include "src/common/types/timestamp.cpp" +#include "src/common/types/type_manager.cpp" + #include "src/common/types/time.cpp" #include "src/common/types/validity_mask.cpp" diff --git a/src/duckdb/ub_src_function_cast.cpp b/src/duckdb/ub_src_function_cast.cpp index 99f3378ca..3b71c2026 100644 --- a/src/duckdb/ub_src_function_cast.cpp +++ b/src/duckdb/ub_src_function_cast.cpp @@ -28,6 +28,8 @@ #include "src/function/cast/time_casts.cpp" +#include "src/function/cast/type_cast.cpp" + #include "src/function/cast/union_casts.cpp" #include "src/function/cast/uuid_casts.cpp" diff --git a/src/duckdb/ub_src_function_scalar_generic.cpp b/src/duckdb/ub_src_function_scalar_generic.cpp index 926f394d3..6b6bbcb09 100644 --- a/src/duckdb/ub_src_function_scalar_generic.cpp +++ b/src/duckdb/ub_src_function_scalar_generic.cpp @@ -4,3 +4,5 @@ #include "src/function/scalar/generic/getvariable.cpp" +#include "src/function/scalar/generic/invoke.cpp" + diff --git a/src/duckdb/ub_src_main.cpp b/src/duckdb/ub_src_main.cpp index b8bc22b97..5028119d6 100644 --- a/src/duckdb/ub_src_main.cpp +++ b/src/duckdb/ub_src_main.cpp @@ -36,6 +36,8 @@ #include "src/main/extension.cpp" +#include "src/main/extension_callback_manager.cpp" + #include "src/main/extension_install_info.cpp" #include "src/main/extension_manager.cpp" @@ -62,5 +64,7 @@ #include "src/main/stream_query_result.cpp" +#include "src/main/user_settings.cpp" + #include "src/main/valid_checker.cpp" diff --git a/src/duckdb/ub_src_main_settings.cpp b/src/duckdb/ub_src_main_settings.cpp index 6dbcd419e..c341379a7 100644 --- a/src/duckdb/ub_src_main_settings.cpp +++ b/src/duckdb/ub_src_main_settings.cpp @@ -2,3 +2,5 @@ #include "src/main/settings/autogenerated_settings.cpp" +#include "src/main/settings/settings.cpp" + diff --git a/src/duckdb/ub_src_parser_expression.cpp b/src/duckdb/ub_src_parser_expression.cpp index 1d9ba299b..d4bd7486e 100644 --- a/src/duckdb/ub_src_parser_expression.cpp +++ b/src/duckdb/ub_src_parser_expression.cpp @@ -32,5 +32,7 @@ #include "src/parser/expression/subquery_expression.cpp" +#include "src/parser/expression/type_expression.cpp" + #include "src/parser/expression/window_expression.cpp" diff --git a/src/duckdb/ub_src_planner_binder_expression.cpp b/src/duckdb/ub_src_planner_binder_expression.cpp index 86a595025..f02698c85 100644 --- a/src/duckdb/ub_src_planner_binder_expression.cpp +++ b/src/duckdb/ub_src_planner_binder_expression.cpp @@ -34,6 +34,8 @@ #include "src/planner/binder/expression/bind_subquery_expression.cpp" +#include "src/planner/binder/expression/bind_type_expression.cpp" + #include "src/planner/binder/expression/bind_unnest_expression.cpp" #include "src/planner/binder/expression/bind_window_expression.cpp" diff --git a/src/duckdb/ub_src_storage_table.cpp b/src/duckdb/ub_src_storage_table.cpp index 2a3777e94..e06c2d1cc 100644 --- a/src/duckdb/ub_src_storage_table.cpp +++ b/src/duckdb/ub_src_storage_table.cpp @@ -8,6 +8,8 @@ #include "src/storage/table/column_segment.cpp" +#include "src/storage/table/geo_column_data.cpp" + #include "src/storage/table/array_column_data.cpp" #include "src/storage/table/list_column_data.cpp"